"""Beancount plugin entry point for Conservancy"""

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

import beancount.core.data as bc_data

from typing import (

    AbstractSet,

    Any,

    Dict,

    Iterable,

    List,

    Set,

    Tuple,

    Type,

)

from ..beancount_types import (

    ALL_DIRECTIVES,

    Directive,

)

from .. import config as configmod

from .core import (

    Hook,

    HookName,

)

from ..errors import (

    Error,

)

__plugins__ = ['run']

class HookRegistry:

    def __init__(self) -> None:

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

            t.__name__: set() for t in ALL_DIRECTIVES

        }

        self.group_name_map['all'] = set()

    def add_hook(self, hook_cls: Type[Hook]) -> Type[Hook]:

        self.group_name_map['all'].add(hook_cls)

        self.group_name_map[hook_cls.DIRECTIVE.__name__].add(hook_cls)

        for key in hook_cls.HOOK_GROUPS:

            self.group_name_map.setdefault(key, set()).add(hook_cls)

        return hook_cls  # to allow use as a decorator

        module = importlib.import_module(mod_name, package)

        for hook_name in hook_names:

            self.add_hook(getattr(module, hook_name))

    def group_by_directive(self, config_str: str='') -> Iterable[Tuple[HookName, Type[Hook]]]:

        config_str = config_str.strip()

        if not config_str:

            config_str = 'all'

        elif config_str.startswith('-'):

            config_str = 'all ' + config_str

        available_hooks: Set[Type[Hook]] = set()

        for token in config_str.split():

            if token.startswith('-'):

                update_available = available_hooks.difference_update

                key = token[1:]

            else:

                update_available = available_hooks.update

                key = token

            try:

                update_set = self.group_name_map[key]

            except KeyError:

                raise ValueError("configuration refers to unknown hooks {!r}".format(key)) from None

            else:

                update_available(update_set)

        for directive in ALL_DIRECTIVES:

            key = directive.__name__

            for hook in self.group_name_map[key] & available_hooks:

                yield key, hook

HOOK_REGISTRY = HookRegistry()

HOOK_REGISTRY.import_hooks('.meta_expense_allocation', 'MetaExpenseAllocation')

HOOK_REGISTRY.import_hooks('.meta_tax_implication', 'MetaTaxImplication')

def run(

        entries: List[Directive],

        options_map: Dict[str, Any],

        config: str='',

        hook_registry: HookRegistry=HOOK_REGISTRY,

) -> Tuple[List[Directive], List[Error]]:

    errors: List[Error] = []

    hooks: Dict[HookName, List[Hook]] = {}

    user_config = configmod.Config()

    for key, hook_type in hook_registry.group_by_directive(config):

        try:

            hook = hook_type(user_config)

        except Error as error:

            errors.append(error)

        else:

            hooks.setdefault(key, []).append(hook)

    for entry in entries:

        entry_type = type(entry).__name__

        for hook in hooks[entry_type]:

            errors.extend(hook.run(entry))

    return entries, errors

[aliases]

test=pytest

typecheck=pytest --addopts="--mypy conservancy_beancount"

[mypy]

disallow_any_unimported = True

disallow_untyped_defs = True

show_error_codes = True

strict_equality = True

warn_redundant_casts = True

warn_return_any = True

warn_unreachable = True

warn_unused_configs = True