"""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 re

import sys

from typing import (

    cast,

    AbstractSet,

    Callable,

    Dict,

    Iterable,

    Iterator,

    Mapping,

    NamedTuple,

    Optional,

    Sequence,

    TextIO,

    Tuple,

    Type,

    Union,

)

from ..beancount_types import (

    MetaValue,

    Posting,

    Transaction,

)

from decimal import Decimal

from pathlib import Path

import beancount.query.numberify as bc_query_numberify

import beancount.query.query_compile as bc_query_compile

import beancount.query.query_env as bc_query_env

import beancount.query.query_execute as bc_query_execute

import beancount.query.query_parser as bc_query_parser

import beancount.query.query_render as bc_query_render

import beancount.query.shell as bc_query_shell

from . import core

from . import rewrite

from .. import books

from .. import cliutil

from .. import config as configmod

from .. import data

BUILTIN_FIELDS: AbstractSet[str] = frozenset(itertools.chain(

    bc_query_env.TargetsEnvironment.columns,  # type:ignore[has-type]

    bc_query_env.TargetsEnvironment.functions,  # type:ignore[has-type]

))

PROGNAME = 'query-report'

QUERY_PARSER = bc_query_parser.Parser()

logger = logging.getLogger('conservancy_beancount.reports.query')

RowTypes = Sequence[Tuple[str, Type]]

Rows = Sequence[NamedTuple]

class BooksLoader:

    """Closure to load books with a zero-argument callable

    This matches the load interface that BQLShell expects.

    """

    def __init__(

            self,

            books_loader: Optional[books.Loader],

            start_date: Optional[datetime.date]=None,

            stop_date: Optional[datetime.date]=None,

            rewrite_rules: Sequence[rewrite.RewriteRuleset]=(),

    ) -> None:

        self.books_loader = books_loader

        self.start_date = start_date

        self.stop_date = stop_date

        self.rewrite_rules = rewrite_rules

    def __call__(self) -> books.LoadResult:

        logger.debug("BooksLoader called")

        result = books.Loader.dispatch(self.books_loader, self.start_date, self.stop_date)

        logger.debug("books loaded from Beancount")

        if self.rewrite_rules:

            for index, entry in enumerate(result.entries):

                # entry might not be a Transaction; we catch that later.

                # The type ignores are because the underlying Beancount type isn't

                # type-checkable.

                postings = data.Posting.from_txn(entry)  # type:ignore[arg-type]

                for ruleset in self.rewrite_rules:

                    postings = ruleset.rewrite(postings)

                try:

                    result.entries[index] = entry._replace(postings=list(postings))  # type:ignore[call-arg]

                except AttributeError:

                    pass

            logger.debug("rewrite rules applied")

        return result

class BQLShell(bc_query_shell.BQLShell):

    def on_Select(self, statement: str) -> 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'] and output_format != 'ods':

                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))

            return

        if not rows and output_format != 'ods':

            print("(empty)", file=self.outfile)

        else:

            logger.debug("rendering query as %s", output_format)

            render_func(row_types, rows)

    def _render_csv(self, row_types: RowTypes, rows: Rows) -> None:

        bc_query_render.render_csv(

            row_types,

            rows,

            self.options_map['dcontext'],

            self.outfile,

            self.vars['expand'],

        )

    def _render_text(self, row_types: RowTypes, rows: Rows) -> None:

        with contextlib.ExitStack() as stack:

            if self.is_interactive:

                output = stack.enter_context(self.get_pager())

            else:

                output = self.outfile

            bc_query_render.render_text(

                row_types,

                rows,

                self.options_map['dcontext'],

                output,

                self.vars['expand'],

                self.vars['boxed'],

                self.vars['spaced'],

            )

class JoinOperator(enum.Enum):

    AND = 'AND'

    OR = 'OR'

    def join(self, parts: Iterable[str]) -> str:

        return f' {self.value} '.join(parts)

class ReportFormat(enum.Enum):

    TEXT = 'text'

    TXT = TEXT

    CSV = 'csv'

def _date_condition(

        date: Union[int, datetime.date],

        year_to_date: Callable[[int], datetime.date],

        op: str,

) -> str:

    if isinstance(date, int):

        date = year_to_date(date)

    return f'date {op} {date.isoformat()}'

def build_query(

        args: argparse.Namespace,

        fy: books.FiscalYear,

        in_file: Optional[TextIO]=None,

) -> Optional[str]:

    if not args.query:

        args.query = [] if in_file is None else [line[:-1] for line in in_file]

    plain_query = ' '.join(args.query)

    if not plain_query or plain_query.isspace():

        return None

    try:

        QUERY_PARSER.parse(plain_query)

    except bc_query_parser.ParseError:

        if args.join is None:

            args.join = JoinOperator.AND

        select = [

            'date',

            *(f'ANY_META("{field}") AS {field.replace("-", "_")}'

              if field not in BUILTIN_FIELDS

              and re.fullmatch(r'[a-z][-_A-Za-z0-9]*', field)

              else field

              for field in args.select),

        ]

        conds = [f'({args.join.join(args.query)})']

        if args.start_date is not None:

            conds.append(_date_condition(args.start_date, fy.first_date, '>='))

        if args.stop_date is not None:

            conds.append(_date_condition(args.stop_date, fy.next_fy_date, '<'))

        return f'SELECT {", ".join(select)} WHERE {" AND ".join(conds)}'

    else:

        if args.join:

            raise ValueError("cannot specify --join with a full query")

        if args.select:

            raise ValueError("cannot specify --select with a full query")

        return plain_query

def parse_arguments(arglist: Optional[Sequence[str]]=None) -> argparse.Namespace:

    parser = argparse.ArgumentParser(prog=PROGNAME)

    cliutil.add_version_argument(parser)

    cliutil.add_loglevel_argument(parser)

    parser.add_argument(

        '--begin', '--start', '-b',

        dest='start_date',

        metavar='DATE',

        type=cliutil.year_or_date_arg,

        help="""Begin loading entries from this fiscal year. When query-report

builds the query, it will include a condition `date >= DATE`.

""")

    parser.add_argument(

        '--end', '--stop', '-e',

        dest='stop_date',

        metavar='DATE',

        type=cliutil.year_or_date_arg,

        help="""End loading entries from this fiscal year. When query-report

builds the query, it will include a condition `date < DATE`. If you specify a

begin date but not an end date, the default end date will be the end of the

fiscal year of the begin date.

""")

    cliutil.add_rewrite_rules_argument(parser)

    format_arg = cliutil.EnumArgument(ReportFormat)

    parser.add_argument(

        '--report-type', '--format', '-t', '-f',

        metavar='TYPE',

        type=format_arg.enum_type,

        help="""Format of report to generate. Choices are

        metavar='COLUMN',

        help="""Group output by this column

""")

    # query_group.add_argument(

    #     '--order-by', '--sort', '-r',

    #     metavar='COLUMN',

    #     help="""Order output by this column

    # """),

    query_group.add_argument(

        '--join', '-j',

        metavar='OP',

        type=join_arg.enum_type,

        help=f"""Join your WHERE conditions with this operator.

Choices are {join_arg.choices_str()}. Default 'and'.

"""),

    query_group.add_argument(

        'query',

        nargs=argparse.ZERO_OR_MORE,

        help="""Full query or WHERE conditions to run non-interactively

""")

    args = parser.parse_args(arglist)

    return args

def main(arglist: Optional[Sequence[str]]=None,

         stdout: TextIO=sys.stdout,

         stderr: TextIO=sys.stderr,

         config: Optional[configmod.Config]=None,

) -> int:

    args = parse_arguments(arglist)

    cliutil.set_loglevel(logger, args.loglevel)

    if config is None:

        config = configmod.Config()

        config.load_file()

    fy = config.fiscal_year_begin()

    if args.stop_date is None and args.start_date is not None:

        args.stop_date = fy.next_fy_date(args.start_date)

    try:

        query = build_query(args, fy, None if sys.stdin.isatty() else sys.stdin)

    except ValueError as error:

        logger.error(error.args[0], exc_info=logger.isEnabledFor(logging.DEBUG))

        return 2

    is_interactive = query is None and sys.stdin.isatty()

    if args.report_type is None:

        try:

            args.report_type = ReportFormat[args.output_file.suffix[1:].upper()]

        except (AttributeError, KeyError):

    load_func = BooksLoader(

        config.books_loader(),

        args.start_date,

        args.stop_date,

        [rewrite.RewriteRuleset.from_yaml(path) for path in args.rewrite_rules],

    )

    shell = BQLShell(

        is_interactive,

        load_func,

        stdout,

        args.report_type.value,

        args.numberify,

    )

    shell.on_Reload()

    if query is None:

        shell.cmdloop()

    else:

        shell.onecmd(query)

    return cliutil.ExitCode.OK

entry_point = cliutil.make_entry_point(__name__, PROGNAME)

if __name__ == '__main__':

    exit(entry_point())

"""test_reports_query.py - Unit tests for query report"""

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

import copy

import csv

import datetime

import io

import itertools

import re

import pytest

from . import testutil

from conservancy_beancount.books import FiscalYear

from conservancy_beancount.reports import query as qmod

from decimal import Decimal

class MockRewriteRuleset:

    def __init__(self, multiplier=2):

        self.multiplier = multiplier

    def rewrite(self, posts):

        for post in posts:

            number, currency = post.units

            number *= self.multiplier

            yield post._replace(units=testutil.Amount(number, currency))

@pytest.fixture(scope='module')

def fy():

    return FiscalYear(3, 1)

    stderr = io.StringIO()

    returncode = qmod.main(arglist, stdout, stderr, config)

    return returncode, stdout, stderr

def query_args(query=None, start_date=None, stop_date=None, join=None, select=None):

    if isinstance(join, str):

        join = qmod.JoinOperator[join]

    if select is None:

        select = []

    elif isinstance(select, str):

        select = select.split(',')

    return argparse.Namespace(**locals())

def test_books_loader_empty():

    result = qmod.BooksLoader(None)()

    assert not result.entries

    assert len(result.errors) == 1

def test_books_loader_plain():

    books_path = testutil.test_path(f'books/books/2018.beancount')

    loader = testutil.TestBooksLoader(books_path)

    result = qmod.BooksLoader(loader)()

    assert not result.errors

    assert result.entries

    min_date = datetime.date(2018, 3, 1)

    assert all(ent.date >= min_date for ent in result.entries)

def test_books_loader_rewrites():

    rewrites = [MockRewriteRuleset()]

    books_path = testutil.test_path(f'books/books/2018.beancount')

    loader = testutil.TestBooksLoader(books_path)

    result = qmod.BooksLoader(loader, None, None, rewrites)()

    assert not result.errors

    assert result.entries

    numbers = frozenset(

        abs(post.units.number)

        for entry in result.entries

        for post in getattr(entry, 'postings', ())

    )

    assert numbers

    assert all(abs(number) >= 40 for number in numbers)

@pytest.mark.parametrize('file_s', [None, '', ' \n \n\n'])

def test_build_query_empty(fy, file_s):

    args = query_args()

    if file_s is None:

        query = qmod.build_query(args, fy)

    else:

def test_text_query(arglist, fy):

    books_path = testutil.test_path(f'books/books/{fy}.beancount')

    config = testutil.TestConfig(books_path=books_path)

    arglist += ['select', 'date,', 'narration,', 'account,', 'position']

    returncode, stdout, stderr = pipe_main(arglist, config)

    assert returncode == 0

    stdout.seek(0)

    lines = iter(stdout)

    next(lines); next(lines)  # Skip header

    for count, line in enumerate(lines, 1):

        assert re.match(rf'^{fy}-\d\d-\d\d\s+{fy} ', line)

    assert count >= 2

@pytest.mark.parametrize('arglist,fy', testutil.combine_values(

    [['--format=csv'], ['-f', 'csv'], ['-t', 'csv']],

    range(2018, 2021),

))

def test_csv_query(arglist, fy):

    books_path = testutil.test_path(f'books/books/{fy}.beancount')

    config = testutil.TestConfig(books_path=books_path)

    arglist += ['select', 'date,', 'narration,', 'account,', 'position']

    returncode, stdout, stderr = pipe_main(arglist, config)

    assert returncode == 0

    stdout.seek(0)

    for count, row in enumerate(csv.DictReader(stdout), 1):

        assert re.fullmatch(rf'{fy}-\d\d-\d\d', row['date'])

        assert row['narration'].startswith(f'{fy} ')

    assert count >= 2

@pytest.mark.parametrize('end_index', range(3))

def test_rewrite_query(end_index):

    books_path = testutil.test_path(f'books/books/2018.beancount')

    config = testutil.TestConfig(books_path=books_path)

    accounts = ['Assets', 'Income']

    expected = frozenset(accounts[:end_index])

    rewrite_paths = [

        testutil.test_path(f'userconfig/Rewrite{s}.yml')

        for s in expected

    ]

    arglist = [f'--rewrite-rules={path}' for path in rewrite_paths]

    arglist.append('--format=txt')

    arglist.append('select any_meta("root") as root')

    returncode, stdout, stderr = pipe_main(arglist, config)

    assert returncode == 0

    stdout.seek(0)

    actual = frozenset(line.rstrip('\n') for line in stdout)

    assert expected.issubset(actual)

    assert frozenset(accounts).difference(expected).isdisjoint(actual)