# Copyright © 2020  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 abc

import collections

import copy

import datetime

import enum

import itertools

import operator

import re

import shlex

import sys

import urllib.parse as urlparse

import babel.core  # type:ignore[import]

import babel.numbers  # type:ignore[import]

import git  # type:ignore[import]

import odf.config  # type:ignore[import]

import odf.element  # type:ignore[import]

import odf.meta  # type:ignore[import]

import odf.number  # type:ignore[import]

import odf.opendocument  # type:ignore[import]

import odf.style  # type:ignore[import]

import odf.table  # type:ignore[import]

import odf.text  # type:ignore[import]

from decimal import Decimal

from pathlib import Path

from beancount.core import amount as bc_amount

from odf.namespaces import TOOLSVERSION  # type:ignore[import]

from .. import cliutil

from .. import data

from .. import filters

from .. import ranges

from .. import rtutil

from typing import (

    cast,

    overload,

    Any,

    BinaryIO,

    Callable,

    Collection,

                retval.removeAttribute('valuetype')

            except KeyError:

                pass

        else:

            retval.setAttribute('valuetype', valuetype)

        retval.childNodes.clear()

        retval.addText(value)

        return retval

    def set_properties(self, *,

                       created: Optional[datetime.datetime]=None,

                       generator: str='conservancy_beancount',

    ) -> None:

        if created is None:

            created = datetime.datetime.now()

        created_elem = self.ensure_child(self.document.meta, odf.meta.CreationDate)

        created_elem.childNodes.clear()

        created_elem.addText(created.isoformat())

        generator_elem = self.ensure_child(self.document.meta, odf.meta.Generator)

        generator_elem.childNodes.clear()

        generator_elem.addText(f'{generator}/{cliutil.VERSION} {TOOLSVERSION}')

    ### Rows and cells

    def add_row(self, *cells: odf.table.TableCell, **attrs: Any) -> odf.table.TableRow:

        row = odf.table.TableRow(**attrs)

        for cell in cells:

            row.addElement(cell)

        self.sheet.addElement(row)

        return row

    def row_count(self, sheet: Optional[odf.table.Table]=None) -> int:

        if sheet is None:

            sheet = self.sheet

        TableRow = odf.table.TableRow

        return sum(1 for cell in sheet.childNodes if cell.isInstanceOf(TableRow))

    def balance_cell(self, balance: Balance, **attrs: Any) -> odf.table.TableCell:

        balance = balance.clean_copy() or balance

        balance_currency_count = len(balance)

        if balance_currency_count == 0:

            return self.float_cell(0, **attrs)

        elif balance_currency_count == 1:

            amount = next(iter(balance.values()))

            attrs['stylename'] = self.merge_styles(

                attrs.get('stylename'), self.currency_style(amount.currency),

            )

            return self.currency_cell(amount, **attrs)

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

    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.info(

                    "HINT: Are you using ORDER BY or comparisons with metadata "

                    "that isn't consistently set?\n  "

                    "Try looking up that metadata with str_meta() instead to "

                    "ensure your comparisons use a consistent data type.",

                )

            return

        if not rows and output_format != 'ods':

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

        else:

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

            render_func(statement, row_types, rows)

    def _render_csv(self, statement: QueryStatement, 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_ods(self, statement: QueryStatement, row_types: RowTypes, rows: Rows) -> None:

        logger.info(

            "%s rows of results saved in sheet %s",

            len(rows),

            self.ods.sheet.getAttribute('name'),

        )

    def _render_text(self, statement: QueryStatement, 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 QueryODS(core.BaseODS[NamedTuple, None]):

    def _cell_types(self, statement: QueryStatement, row_types: RowTypes) -> Iterator[CellFunc]:

        """Return functions to create table cells from result rows

        Given a parsed query and the types of return rows, yields a function

        to create a cell for each column in the row, in order. The returned

        functions vary in order to provide the best available formatting for

        different data types.

        """

        if (isinstance(statement, bc_query_parser.Select)

            and isinstance(statement.targets, Sequence)):

            targets = [t.expression for t in statement.targets]

        else:

            # Synthesize something that makes clear we're not loading metadata.

            targets = [bc_query_parser.Column(name) for name, _ in row_types]

        for target, (_, row_type) in zip(targets, row_types):

            meta_key = self._meta_target(target)

            if meta_key is None:

                yield self._cell_type(row_type)

            elif meta_key in data.LINK_METADATA:

                yield self._link_cell_type(row_type)

            else:

                yield self._metadata_cell

        if self.is_empty():

            self.sheet.setAttribute('name', "Query 1")

        else:

            self.use_sheet(f"Query {len(self.document.spreadsheet.childNodes) + 1}")

        for name, row_type in row_types:

            if issubclass(row_type, datetime.date):

                col_width = 1.0

            elif issubclass(row_type, (BeancountAmount, Inventory, Position)):

                col_width = 1.5

            else:

                col_width = 2.0

            col_style = self.column_style(col_width)

            self.sheet.addElement(odf.table.TableColumn(stylename=col_style))

        self.add_row(*(

            self.string_cell(data.Metadata.human_name(name), stylename=self.style_bold)

            for name, _ in row_types

        ))

        self.lock_first_row()

        cell_funcs = list(self._cell_types(statement, row_types))

        for row in rows:

            self.add_row(*(

                cell_func(value)

                for cell_func, value in zip(cell_funcs, row)

            ))

class ReportFormat(enum.Enum):

    TEXT = 'text'

    TXT = TEXT

    CSV = 'csv'

    ODS = 'ods'

class SetCYDates(argparse.Action):

    def __call__(self,

                 parser: argparse.ArgumentParser,

                 namespace: argparse.Namespace,

                 values: Union[Sequence[Any], str, None]=None,

                 option_string: Optional[str]=None,

    ) -> None:

        value = cliutil.year_or_date_arg(str(values))

        if isinstance(value, int):

            args.report_type = ReportFormat.ODS if query else ReportFormat.TEXT

    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(

        not query,

        load_func,

        stdout,

        args.report_type.value,

        args.numberify,

        config.rt_wrapper(),

    )

    shell.on_Reload()

    if query:

        shell.onecmd(query)

    else:

        shell.cmdloop()

    if not shell.ods.is_empty():

        shell.ods.set_common_properties(config.books_repo())

        if args.output_file is None:

            out_dir_path = config.repository_path() or Path()

            args.output_file = out_dir_path / 'QueryResults_{}.ods'.format(

                datetime.datetime.now().isoformat(timespec='seconds'),

            )

            logger.info("Writing spreadsheet to %s", args.output_file)

        ods_file = cliutil.bytes_output(args.output_file, stdout)

        shell.ods.save_file(ods_file)

    return cliutil.ExitCode.OK

entry_point = cliutil.make_entry_point(__name__, PROGNAME)

if __name__ == '__main__':

    exit(entry_point())

#!/usr/bin/env python3

from setuptools import setup

setup(

    name='conservancy_beancount',

    description="Plugin, library, and reports for reading Conservancy's books",

    author='Software Freedom Conservancy',

    author_email='info@sfconservancy.org',

    license='GNU AGPLv3+',

    install_requires=[

        'babel>=2.6',  # Debian:python3-babel

        'beancount>=2.2',  # Debian:beancount

        'GitPython>=2.0',  # Debian:python3-git

        # 1.4.1 crashes when trying to save some documents.

        'odfpy>=1.4.0,!=1.4.1',  # Debian:python3-odf

        'pdfminer.six>=20200101',

        'PyYAML>=3.0',  # Debian:python3-yaml

        'regex',  # Debian:python3-regex

        'rt>=2.0',

    ],

    setup_requires=[

        'pytest-mypy',

        'pytest-runner',  # Debian:python3-pytest-runner

    ],

    tests_require=[

        'mypy>=0.770',  # Debian:python3-mypy

        'pytest',  # Debian:python3-pytest

    ],