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

from pathlib import Path

from beancount import loader as bc_loader

from typing import (

    Any,

    Iterable,

    Iterator,

    Mapping,

    NamedTuple,

    Optional,

    Union,

)

from .beancount_types import (

    LoadResult,

)

PathLike = Union[str, Path]

Year = Union[int, datetime.date]

class FiscalYear(NamedTuple):

    month: int = 3

    day: int = 1

    def for_date(self, date: Optional[datetime.date]=None) -> int:

        if date is None:

            date = datetime.date.today()

        if (date.month, date.day) < self:

            return date.year - 1

        else:

            return date.year

    def range(self, from_fy: Year, to_fy: Optional[Year]=None) -> Iterable[int]:

        """Return a range of fiscal years

        Both arguments can be either a year (represented as an integer) or a

        date. Dates will be converted into a year by calling for_date() on

        them.

                from_year = self.fiscal_year.for_date(from_year)

            elif from_year < 1000:

                from_year = self.fiscal_year.for_date() + from_year

            for index, path in enumerate(fy_paths):

                if self._path_year(path) >= from_year:

                    fy_paths = fy_paths[index:]

                    break

            else:

                fy_paths = []

        return self._load_paths(iter(fy_paths))

    def load_fy_range(self,

                      from_fy: Year,

                      to_fy: Optional[Year]=None,

    ) -> LoadResult:

        """Load books for a range of fiscal years

        This method generates a range of fiscal years by calling

        FiscalYear.range() with its arguments. It loads all the books within

        that range.

        """

        fy_range = self.fiscal_year.range(from_fy, to_fy)

        fy_paths = self._iter_fy_books(fy_range)

        return self._load_paths(fy_paths)

    Optional,

    Sequence,

    Set,

    TextIO,

    Tuple,

    TypeVar,

    Union,

)

from ..beancount_types import (

    Entries,

    Error,

    Errors,

    MetaKey,

    MetaValue,

    Transaction,

)

import odf.style  # type:ignore[import]

import odf.table  # type:ignore[import]

import rt

from beancount.parser import printer as bc_printer

from . import core

from .. import cliutil

from .. import config as configmod

from .. import data

from .. import filters

from .. import rtutil

PROGNAME = 'accrual-report'

CompoundAmount = TypeVar('CompoundAmount', data.Amount, core.Balance)

PostGroups = Mapping[Optional[MetaValue], 'AccrualPostings']

RTObject = Mapping[str, str]

T = TypeVar('T')

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

class Sentinel:

    pass

class Account(NamedTuple):

    name: str

    aging_thresholds: Sequence[int]

`TIK/ATT` format, is a shortcut for `invoice=LINK`.

""")

    args = parser.parse_args(arglist)

    if args.report_type is None and not args.search_terms:

        args.report_type = ReportType.AGING

    return args

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

         stdout: TextIO=sys.stdout,

         stderr: TextIO=sys.stderr,

         config: Optional[configmod.Config]=None,

) -> int:

    if cliutil.is_main_script(PROGNAME):

        global logger

        logger = logging.getLogger(PROGNAME)

        sys.excepthook = cliutil.ExceptHook(logger)

    args = parse_arguments(arglist)

    cliutil.setup_logger(logger, args.loglevel, stderr)

    if config is None:

        config = configmod.Config()

        config.load_file()

    books_loader = config.books_loader()

    if books_loader is None:

    elif args.report_type is ReportType.AGING:

        entries, load_errors, _ = books_loader.load_all()

    else:

        entries, load_errors, _ = books_loader.load_all(args.since)

    filters.remove_opening_balance_txn(entries)

    returncode = 0

    postings = filter_search(data.Posting.from_entries(entries), args.search_terms)

    groups: PostGroups = dict(AccrualPostings.group_by_meta(postings, 'invoice'))

    for error in load_errors:

        bc_printer.print_error(error, file=stderr)

        returncode |= ReturnFlag.LOAD_ERRORS

    for related in groups.values():

        for error in related.report_inconsistencies():

            bc_printer.print_error(error, file=stderr)

            returncode |= ReturnFlag.CONSISTENCY_ERRORS

    if not groups:

        logger.warning("no matching entries found to report")

        returncode |= ReturnFlag.NOTHING_TO_REPORT

    groups = {

        key: posts

        for source_posts in groups.values()

        for key, posts in source_posts.make_consistent()

    entries, errors, options_map = conservancy_loader.load_all(from_year)

    from_year = from_year or 2018

    assert not errors

    check_openings(entries)

    actual_years = txn_years(entries)

    assert actual_years.issuperset(range(from_year, 2021))

    assert min(actual_years) == from_year

@pytest.mark.parametrize('from_date', [

    date(2019, 2, 1),

    date(2019, 9, 15),

    date(2020, 1, 20),

    date(2020, 5, 31),

])

def test_load_all_from_date(conservancy_loader, from_date):

    from_year = from_date.year

    if from_date.month < FY_START_MONTH:

        from_year -= 1

    entries, errors, options_map = conservancy_loader.load_all(from_date)

    assert not errors

    check_openings(entries)

    actual_years = txn_years(entries)

    assert actual_years.issuperset(range(from_year, 2021))

    assert min(actual_years) == from_year

    ])

@pytest.mark.parametrize('arglist', [

    [],

    ['-t', 'aging', 'entity=Lawyer'],

])

def test_main_aging_report(tmp_path, arglist):

    if arglist:

        recv_rows = [row for row in AGING_AR if 'Lawyer' in row.entity]

        pay_rows = [row for row in AGING_AP if 'Lawyer' in row.entity]

    else:

        recv_rows = AGING_AR

        pay_rows = AGING_AP

    output_path = tmp_path / 'AgingReport.ods'

    arglist.insert(0, f'--output-file={output_path}')

    retcode, output, errors = run_main(arglist)

    assert not errors.getvalue()

    assert retcode == 0

    assert not output.getvalue()

    with output_path.open('rb') as ods_file:

        check_aging_ods(ods_file, None, recv_rows, pay_rows)

def test_main_no_books():

    check_main_fails([], testutil.TestConfig(), 1 | 8, [

    ])

@pytest.mark.parametrize('arglist', [

    ['499'],

    ['505/99999'],

    ['entity=NonExistent'],

])

def test_main_no_matches(arglist):

    check_main_fails(arglist, None, 8, [

        r': WARNING: no matching entries found to report$',

    ])

def test_main_no_rt():

    config = testutil.TestConfig(

        books_path=testutil.test_path('books/accruals.beancount'),

    )

    check_main_fails(['-t', 'out'], config, 4, [

        r': ERROR: unable to generate outgoing report: RT client is required\b',

    ])