"""query.py - Report arbitrary queries with advanced loading and formatting"""

# Copyright © 2021  Brett Smith

# License: AGPLv3-or-later WITH Beancount-Plugin-Additional-Permission-1.0

#

# Full copyright and licensing details can be found at toplevel file

# LICENSE.txt in the repository.

import argparse

import contextlib

import datetime

import enum

import itertools

import logging

import sys

from typing import (

    cast,

    Any,

    Callable,

    Dict,

    Iterable,

    Iterator,

    List,

    Mapping,

    NamedTuple,

    Optional,

    Sequence,

    TextIO,

    Tuple,

    Type,

    Union,

)

from ..beancount_types import (

    MetaKey,

    MetaValue,

        # It should match the annotated return type of __call__.

    def __call__(self, context: Context) -> List[str]:

        raw_value = super().__call__(context)

        if isinstance(raw_value, str):

            return raw_value.split()

        else:

            return []

class StrMeta(bc_query_env.AnyMeta):

    """Looks up metadata like AnyMeta, then always returns a string."""

    def __init__(self, operands: List[str]) -> None:

        super(bc_query_env.AnyMeta, self).__init__(operands, str)

    def __call__(self, context: Context) -> str:

        raw_value = super().__call__(context)

        if raw_value is None:

            return ''

        else:

            return str(raw_value)

class AggregateSet(bc_query_compile.EvalAggregator):

    __intypes__ = [object]

    def __init__(self, operands: List[str]) -> None:

       super().__init__(operands, set)

    def allocate(self, allocator: bc_query_execute.Allocator) -> None:

        """Allocate and save an index handle into result storage."""

        self.handle = allocator.allocate()

    def initialize(self, store: Store) -> None:

        """Prepare result storage for a new aggregation."""

        store[self.handle] = self.dtype()

        # self.dtype() is our return type, aka the second argument to __init__

        # above, aka the annotated return type of __call__.

    def update(self, store: Store, context: Context) -> None:

        """Update existing storage with new result data."""

        value, = self.eval_args(context)

        if isinstance(value, Sequence) and not isinstance(value, (str, tuple)):

            store[self.handle].update(value)

        else:

            store[self.handle].add(value)

    def __call__(self, context: Context) -> set:

class BQLShell(bc_query_shell.BQLShell):

    def __init__(

            self,

            is_interactive: bool,

            loadfun: Callable[[], books.LoadResult],

            outfile: TextIO,

            default_format: str='text',

            do_numberify: bool=False,

            rt_wrapper: Optional[rtutil.RT]=None,

    ) -> None:

        super().__init__(is_interactive, loadfun, outfile, default_format, do_numberify)

        self.env_postings = FilterPostingsEnvironment()

        self.env_targets = TargetsEnvironment()

        self.ods = QueryODS(rt_wrapper)

        self.last_line_parsed = ''

    def run_parser(

            self,

            line: str,

            default_close_date: Optional[datetime.datetime]=None,

    ) -> None:

        self.last_line_parsed = line

        super().run_parser(line, default_close_date)

    def on_Select(self, statement: QueryStatement) -> None:

        output_format: str = self.vars['format']

        try:

            render_func = getattr(self, f'_render_{output_format}')

        except AttributeError:

            logger.error("unknown output format %r", output_format)

            return

        try:

            logger.debug("compiling query")

            compiled_query = bc_query_compile.compile(

                statement, self.env_targets, self.env_postings, self.env_entries,

            )

            logger.debug("executing query")

            row_types, rows = bc_query_execute.execute_query(

                compiled_query, self.entries, self.options_map,

            )

            if self.vars['numberify']:

                logger.debug("numberifying query")

                row_types, rows = bc_query_numberify.numberify_results(

                    row_types, rows, self.options_map['dcontext'].build(),

                )

        except Exception as error:

            logger.error(str(error), exc_info=logger.isEnabledFor(logging.DEBUG))