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

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

import abc

import datetime

import beancount.core.data as bc_data

from typing import (

    Any,

    FrozenSet,

    Iterable,

    List,

    Set,

    Tuple,

    Type,

)

Account = bc_data.Account

MetaKey = str

MetaValue = Any

MetaValueEnum = str

Posting = bc_data.Posting

class Directive(NamedTuple):

    meta: bc_data.Meta

    date: datetime.date

class Transaction(Directive):

# 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/>.

    def __init__(self, message, entry, source=None):

        self.message = message

        self.entry = entry

        self.source = entry.meta if source is None else source

    def __repr__(self):

            clsname=type(self).__name__,

            message=self.message,

            source=self.source,

        )

    def __init__(self, txn, post, key, value=None, source=None):

        if value is None:

            msg_fmt = "{post.account} missing {key}"

        else:

            msg_fmt = "{post.account} has invalid {key}: {value}"

        super().__init__(

    List,

    Mapping,

    Set,

    Tuple,

    Type,

)

    ALL_DIRECTIVES,

    Directive,

)

from .core import (

    Hook,

    HookName,

)

__plugins__ = ['run']

class HookRegistry:

    def __init__(self) -> None:

        self.group_name_map: Dict[HookName, Set[Type[Hook]]] = {

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

import abc

import datetime

import re

from typing import (

    FrozenSet,

    Generic,

    Iterable,

    Iterator,

    Mapping,

    Optional,

    TypeVar,

)

    Account,

    Directive,

    MetaKey,

    MetaValue,

    MetaValueEnum,

    Posting,

    Transaction,

    Type,

Entry = TypeVar('Entry', bound=Directive)

class Hook(Generic[Entry], metaclass=abc.ABCMeta):

    DIRECTIVE: Type[Directive]

    HOOK_GROUPS: FrozenSet[HookName] = frozenset()

    @abc.abstractmethod

    def __init_subclass__(cls):

        cls.DIRECTIVE = cls.__orig_bases__[0].__args__[0]

TransactionHook = Hook[Transaction]

### HELPER CLASSES

CT = TypeVar('CT', bound=LessComparable)

class _GenericRange(Generic[CT]):

    """Convenience class to check whether a value is within a range.

    `foo in generic_range` is equivalent to `start <= foo < stop`.

    Since we have multiple user-configurable ranges, having the check

    def _run_on_txn(self, txn: Transaction) -> bool:

        return txn.date in self.TXN_DATE_RANGE

    def _run_on_post(self, txn: Transaction, post: Posting) -> bool:

        return True

        if self._run_on_txn(txn):

            for index, post in enumerate(txn.postings):

                if self._run_on_post(txn, post):

                    yield from self.post_run(txn, post, index)

    @abc.abstractmethod

class _NormalizePostingMetadataHook(_PostingHook):

    """Base class to normalize posting metadata from an enum."""

    # This class provides basic functionality to filter postings, normalize

    # metadata values, and set default values.

    # _default_value to get a default. This method should either return

    # a value string from METADATA_ENUM, or else raise InvalidMetadataError.

    # This base implementation does the latter.

    def _default_value(self, txn: Transaction, post: Posting) -> MetaValueEnum:

        raise errormod.InvalidMetadataError(txn, post, self.METADATA_KEY)

        source_value = self._meta_get(txn, post, self.METADATA_KEY)

        set_value = source_value

        if source_value is None:

            try:

                set_value = self._default_value(txn, post)

                error = error_

        else:

            try:

                set_value = self.VALUES_ENUM[source_value]

            except KeyError:

                error = errormod.InvalidMetadataError(

# 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/>.

from . import core

    MetaValueEnum,

    Posting,

    Transaction,

)

class MetaExpenseAllocation(core._NormalizePostingMetadataHook):

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

from . import core

    Posting,

    Transaction,

)

DEFAULT_STOP_AMOUNT = decimal.Decimal(0)

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

import pytest

from . import testutil

CONFIG_MAP = {}

HOOK_REGISTRY = plugin.HookRegistry()

@HOOK_REGISTRY.add_hook

class TransactionCounter:

    HOOK_GROUPS = frozenset()

    def run(self, txn):

        return ['txn:{}'.format(id(txn))]

@HOOK_REGISTRY.add_hook

class PostingCounter(TransactionCounter):

    HOOK_GROUPS = frozenset(['posting'])

    def run(self, txn):

        return ['post:{}'.format(id(post)) for post in txn.postings]