"""core.py - Common data classes for reporting functionality"""

# Copyright © 2020  Brett Smith

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU Affero General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <https://www.gnu.org/licenses/>.

import abc

import collections

import copy

import datetime

import enum

import itertools

import operator

import re

import urllib.parse as urlparse

import babel.core  # type:ignore[import]

import babel.numbers  # type:ignore[import]

import odf.config  # type:ignore[import]

import odf.element  # type:ignore[import]

import odf.meta  # type:ignore[import]

import odf.number  # type:ignore[import]

import odf.opendocument  # type:ignore[import]

import odf.style  # type:ignore[import]

import odf.table  # type:ignore[import]

import odf.text  # type:ignore[import]

from decimal import Decimal

from pathlib import Path

from beancount.core import amount as bc_amount

from odf.namespaces import TOOLSVERSION  # type:ignore[import]

from ..cliutil import VERSION

from .. import data

from .. import filters

from .. import rtutil

from typing import (

    cast,

    overload,

    Any,

    BinaryIO,

    Callable,

    Dict,

    Generic,

    Iterable,

    Iterator,

    List,

    Mapping,

    MutableMapping,

    Optional,

    Sequence,

    Set,

    Tuple,

    Type,

    TypeVar,

    Union,

)

from ..beancount_types import (

    MetaKey,

    MetaValue,

)

OPENING_BALANCE_NAME = "OPENING BALANCE"

ENDING_BALANCE_NAME = "ENDING BALANCE"

        views = self.ensure_child(

            view_settings, odf.config.ConfigItemMapIndexed, name='Views',

        )

        self.view = self.ensure_child(views, odf.config.ConfigItemMapEntry)

        self.set_config(self.view, 'ViewId', 'view1')

    def init_styles(self) -> None:

        """Hook called to initialize settings

        This method is called by __init__ to populate

        ``self.document.styles``. This implementation creates basic building

        block cell styles often used in financial reports.

        """

        styles = self.document.styles

        self.style_bold = self.ensure_child(

            styles, odf.style.Style, name='Bold', family='table-cell',

        )

        self.ensure_child(

            self.style_bold, odf.style.TextProperties, fontweight='bold',

        )

        date_style = self.replace_child(styles, odf.number.DateStyle, name='ISODate')

        date_style.addElement(odf.number.Year(style='long'))

        date_style.addElement(odf.number.Text(text='-'))

        date_style.addElement(odf.number.Month(style='long'))

        date_style.addElement(odf.number.Text(text='-'))

        date_style.addElement(odf.number.Day(style='long'))

        self.style_date = self.ensure_child(

            styles,

            odf.style.Style,

            name=f'{date_style.getAttribute("name")}Cell',

            family='table-cell',

            datastylename=date_style,

        )

        self.style_starttext: odf.style.Style

        self.style_centertext: odf.style.Style

        self.style_endtext: odf.style.Style

        for textalign in ['start', 'center', 'end']:

            aligned_style = self.replace_child(

                styles, odf.style.Style, name=f'{textalign.title()}Text',

            )

            aligned_style.setAttribute('family', 'table-cell')

            aligned_style.addElement(odf.style.ParagraphProperties(textalign=textalign))

            setattr(self, f'style_{textalign}text', aligned_style)

    ### Properties

    def set_custom_property(self,

                            name: str,

                            value: Any,

                            valuetype: Optional[str]=None,

    ) -> odf.meta.UserDefined:

        if valuetype is None:

            if isinstance(value, bool):

                valuetype = 'boolean'

            elif isinstance(value, (datetime.date, datetime.datetime)):

                valuetype = 'date'

            elif isinstance(value, (int, float, Decimal)):

                valuetype = 'float'

        if not isinstance(value, str):

            if valuetype == 'boolean':

                value = 'true' if value else 'false'

            elif valuetype == 'date':

                value = value.isoformat()

            else:

                value = str(value)

        retval = self.ensure_child(self.document.meta, odf.meta.UserDefined, name=name)

        if valuetype is None:

            try:

                retval.removeAttribute('valuetype')

            except KeyError:

                pass

        else:

            retval.setAttribute('valuetype', valuetype)

        retval.childNodes.clear()

        retval.addText(value)

        return retval

    def set_properties(self, *,

                       created: Optional[datetime.datetime]=None,

                       generator: str='conservancy_beancount',

    ) -> None:

        if created is None:

            created = datetime.datetime.now()

        created_elem = self.ensure_child(self.document.meta, odf.meta.CreationDate)

        created_elem.childNodes.clear()

        created_elem.addText(created.isoformat())

        generator_elem = self.ensure_child(self.document.meta, odf.meta.Generator)

        generator_elem.childNodes.clear()

        generator_elem.addText(f'{generator}/{VERSION} {TOOLSVERSION}')

    ### Rows and cells

    def add_row(self, *cells: odf.table.TableCell, **attrs: Any) -> odf.table.TableRow:

        row = odf.table.TableRow(**attrs)

    assert actual1 is not child1

    assert actual2 is not child2

    actual_a, = actual1.childNodes

    assert actual_a.getAttribute('href') == 'linkhref'

    assert actual_a.text == 'linktext'

    assert actual2.text == 'para2'

def test_ods_writer_default_properties(ods_writer):

    meta = ods_writer.document.meta

    yesterday = datetime.datetime.now() - datetime.timedelta(days=1)

    creation_date_elem = get_child(meta, odf.meta.CreationDate)

    creation_date = datetime.datetime.strptime(

        creation_date_elem.text, '%Y-%m-%dT%H:%M:%S.%f',

    )

    assert creation_date > yesterday

    generator = get_child(meta, odf.meta.Generator)

    assert re.match(r'conservancy_beancount/\d+\.\d+', generator.text)

def test_ods_writer_set_properties(ods_writer):

    ctime = datetime.datetime(2009, 9, 19, 9, 49, 59)

    ods_writer.set_properties(created=ctime, generator='testgen')

    meta = ods_writer.document.meta

    creation_date_elem = get_child(meta, odf.meta.CreationDate)

    assert creation_date_elem.text == ctime.isoformat()

    generator = get_child(meta, odf.meta.Generator)

    assert re.match(r'testgen/\d+\.\d+', generator.text)

@pytest.mark.parametrize('value,exptype', [

    (1, 'float'),

    (12.34, 'float'),

    (Decimal('5.99'), 'float'),

    (datetime.date(2009, 8, 17), 'date'),

    (datetime.datetime(2009, 8, 17, 18, 38, 58), 'date'),

    (True, 'boolean'),

    (False, 'boolean'),

    ('foo', None)

])

def test_ods_writer_set_custom_property(ods_writer, value, exptype):

    cprop = ods_writer.set_custom_property('cprop', value)

    assert cprop.getAttribute('name') == 'cprop'

    assert cprop.getAttribute('valuetype') == exptype

    if exptype == 'boolean':

        expected = str(value).lower()

    elif exptype == 'date':

        expected = value.isoformat()

    else:

        expected = str(value)

    assert cprop.text == expected

"""Mock Beancount objects for testing"""

# Copyright © 2020  Brett Smith

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU Affero General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <https://www.gnu.org/licenses/>.

import datetime

import itertools

import re

import beancount.core.amount as bc_amount

import beancount.core.data as bc_data

import beancount.loader as bc_loader

import beancount.parser.options as bc_options

import odf.element

import odf.opendocument

import odf.table

from decimal import Decimal

from pathlib import Path

from typing import Any, Optional, NamedTuple

from conservancy_beancount import books, data, rtutil

EXTREME_FUTURE_DATE = datetime.date(datetime.MAXYEAR, 12, 30)

FUTURE_DATE = datetime.date.today() + datetime.timedelta(days=365 * 99)

FY_START_DATE = datetime.date(2020, 3, 1)

FY_MID_DATE = datetime.date(2020, 9, 1)

PAST_DATE = datetime.date(2000, 1, 1)

TESTS_DIR = Path(__file__).parent

# This function is a teardown fixture, but different test files use

# it with different scopes. Typical usage looks like:

#   clean_account_meta = pytest.fixture([options])(testutil.clean_account_meta)

def clean_account_meta():

    try:

        yield

    finally:

        data.Account.load_options_map(bc_options.OPTIONS_DEFAULTS)

        data.Account._meta_map.clear()

def _ods_cell_value_type(cell):

    assert cell.tagName == 'table:table-cell'

    return cell.getAttribute('valuetype')

def _ods_cell_value(cell):

    value_type = cell.getAttribute('valuetype')

    if value_type == 'currency' or value_type == 'float':

        return Decimal(cell.getAttribute('value'))

    elif value_type == 'date':

        return datetime.datetime.strptime(

            cell.getAttribute('datevalue'), '%Y-%m-%d',

        ).date()

    else:

        return cell.getAttribute('value')

def _ods_elem_text(elem):

    if isinstance(elem, odf.element.Text):

        return elem.data

    else:

        return '\0'.join(_ods_elem_text(child) for child in elem.childNodes)

    def load_fy_range(self, from_fy, to_fy=None):

        return self.load_all()

class TestConfig:

    def __init__(self, *,

                 books_path=None,

                 fiscal_year=(3, 1),

                 payment_threshold=0,

                 repo_path=None,

                 rt_client=None,

    ):

        if books_path is None:

            self._books_loader = None

        else:

            self._books_loader = TestBooksLoader(books_path)

        self.fiscal_year = fiscal_year

        self._payment_threshold = Decimal(payment_threshold)

        self.repo_path = test_path(repo_path)

        self._rt_client = rt_client

        if rt_client is None:

            self._rt_wrapper = None

        else:

            self._rt_wrapper = rtutil.RT(rt_client)

    def books_loader(self):

        return self._books_loader

    def config_file_path(self):

        return test_path('userconfig/conservancy_beancount/config.ini')

    def fiscal_year_begin(self):

        return books.FiscalYear(*self.fiscal_year)

    def payment_threshold(self):

        return self._payment_threshold

    def repository_path(self):

        return self.repo_path

    def rt_client(self):

        return self._rt_client

    def rt_wrapper(self):

        return self._rt_wrapper

class _TicketBuilder:

    MESSAGE_ATTACHMENTS = [

        ('(Unnamed)', 'multipart/alternative', '0b'),

        ('(Unnamed)', 'text/plain', '1.2k'),

        ('(Unnamed)', 'text/html', '1.4k'),

    ]

    MISC_ATTACHMENTS = [

        ('Forwarded Message.eml', 'message/rfc822', '3.1k'),

        ('photo.jpg', 'image/jpeg', '65.2k'),

        ('ConservancyInvoice-301.pdf', 'application/pdf', '326k'),

        ('Company_invoice-2020030405_as-sent.pdf', 'application/pdf', '50k'),

        ('statement.txt', 'text/plain', '652b'),

        ('screenshot.png', 'image/png', '1.9m'),

    ]

    def __init__(self):

        self.id_seq = itertools.count(1)

        self.misc_attchs = itertools.cycle(self.MISC_ATTACHMENTS)

    def new_attch(self, attch):

        return (str(next(self.id_seq)), *attch)

    def new_msg_with_attachments(self, attachments_count=1):

        for attch in self.MESSAGE_ATTACHMENTS:

            yield self.new_attch(attch)

        for _ in range(attachments_count):

            yield self.new_attch(next(self.misc_attchs))

    def new_messages(self, messages_count, attachments_count=None):

        for n in range(messages_count):

            if attachments_count is None:

                att_count = messages_count - n

            else:

                att_count = attachments_count

            yield from self.new_msg_with_attachments(att_count)

class RTClient:

    _builder = _TicketBuilder()

    DEFAULT_URL = 'https://example.org/defaultrt/REST/1.0/'

    TICKET_DATA = {

        '1': list(_builder.new_messages(1, 3)),

        '2': list(_builder.new_messages(2, 1)),

        '3': list(_builder.new_messages(3, 0)),

    }

    del _builder

    def __init__(self,