import collections

import datetime

import decimal

import functools

import re

from beancount.core import account as bc_account

from beancount.core import amount as bc_amount

from beancount.core import convert as bc_convert

from beancount.core import data as bc_data

from beancount.core import position as bc_position

from typing import (

    cast,

    overload,

    Callable,

    Hashable,

    Iterable,

    Iterator,

    MutableMapping,

    Optional,

    Sequence,

    TypeVar,

    Union,

)

from .beancount_types import (

    Close,

    Currency,

    Directive,

    Meta,

    MetaKey,

    MetaValue,

    Open,

    Posting as BasePosting,

    Transaction,

)

DecimalCompat = Union[decimal.Decimal, int]

LINK_METADATA = frozenset([

    'approval',

    'bank-statement',

    'check',

    'contract',

    'invoice',

        return self._opening.meta

class Account(str):

    """Account name string

    This is a string that names an account, like Assets:Bank:Checking

    or Income:Donations. This class provides additional methods for common

    account name parsing and queries.

    """

    __slots__ = ()

    SEP = bc_account.sep

    _meta_map: MutableMapping[str, AccountMeta] = {}

    @classmethod

    def load_opening(cls, opening: Open) -> None:

        cls._meta_map[opening.account] = AccountMeta(opening)

    @classmethod

    def load_closing(cls, closing: Close) -> None:

        try:

            cls._meta_map[closing.account].add_closing(closing)

        except KeyError:

            raise ValueError(

                f"tried to load {closing.account} close directive before open",

            ) from None

    @classmethod

    def load_openings_and_closings(cls, entries: Iterable[Directive]) -> None:

        for entry in entries:

            # type ignores because Beancount's directives aren't type-checkable.

            if isinstance(entry, bc_data.Open):

                cls.load_opening(entry)  # type:ignore[arg-type]

            elif isinstance(entry, bc_data.Close):

                cls.load_closing(entry)  # type:ignore[arg-type]

    @property

    def meta(self) -> AccountMeta:

        return self._meta_map[self]

    def is_cash_equivalent(self) -> bool:

        return (

            self.is_under('Assets:') is not None

            and self.is_under('Assets:Prepaid', 'Assets:Receivable') is None

        )

    def is_checking(self) -> bool:

        return self.is_cash_equivalent() and ':Check' in self

        else:

            part_slice = slice(start, stop)

        return self.split(self.SEP)[part_slice]

    def root_part(self, count: int=1) -> str:

        """Return the first part(s) of the account name as a string"""

        try:

            stop = self._find_part_slice(count - 1).stop

        except IndexError:

            return self

        else:

            return self[:stop]

class Amount(bc_amount.Amount):

    """Beancount amount after processing

    Beancount's native Amount class declares number to be Optional[Decimal],

    because the number is None when Beancount first parses a posting that does

    not have an amount, because the user wants it to be automatically balanced.

    As part of the loading process, Beancount replaces those None numbers

    with the calculated amount, so it will always be a Decimal. This class

    overrides the type declaration accordingly, so the type checker knows

# 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 pytest

from . import testutil

from datetime import date as Date

from beancount.core.data import Open, Close, Booking

from conservancy_beancount import data

clean_account_meta = pytest.fixture()(testutil.clean_account_meta)

def check_account_meta(acct_meta, opening, closing=None):

    if isinstance(acct_meta, str):

        acct_meta = data.Account(acct_meta).meta

    assert acct_meta == opening.meta

    assert acct_meta.account == opening.account

    assert acct_meta.booking == opening.booking

    assert acct_meta.currencies == opening.currencies

             Date(2000, 4, 1), 'Assets:Checking', ['USD', 'EUR'], Booking.STRICT),

        testutil.Transaction(date=Date(2000, 4, 10), postings=[

            ('Income:Donations', -10),

            ('Assets:Checking', 10),

        ]),

        Close({'lineno': 30, 'why': 'Changed banks'},

              Date(2000, 5, 1), 'Assets:Checking')

    ]

    data.Account.load_openings_and_closings(iter(entries))

    check_account_meta('Income:Donations', entries[0])

    check_account_meta('Income:Other', entries[1])

    check_account_meta('Assets:Checking', entries[2], entries[-1])

# 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 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 primarily used as a 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():

    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(