from ..beancount_types import (

    MetaValue,

)

from decimal import Decimal

from pathlib import Path

import odf.table  # type:ignore[import]

from beancount.parser import printer as bc_printer

from . import core

from .. import books

from .. import cliutil

from .. import config as configmod

from .. import data

AccountsMap = Mapping[data.Account, core.PeriodPostings]

FundPosts = Tuple[MetaValue, AccountsMap]

EQUITY_ACCOUNTS = ['Equity', 'Income', 'Expenses']

INFO_ACCOUNTS = [

    'Assets:Receivable',

    'Assets:Prepaid',

    'Liabilities:UnearnedIncome',

    'Liabilities:Payable',

]

PROGNAME = 'fund-report'

UNRESTRICTED_FUND = 'Conservancy'

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

class ODSReport(core.BaseODS[FundPosts, None]):

    def __init__(self, start_date: datetime.date, stop_date: datetime.date) -> None:

        super().__init__()

        self.start_date = start_date

        self.stop_date = stop_date

    def section_key(self, row: FundPosts) -> None:

        return None

    def start_spreadsheet(self, *, expanded: bool=True) -> None:

        headers = [["Fund"], ["Balance as of", self.start_date.isoformat()]]

        if expanded:

            sheet_name = "With Breakdowns"

            headers += [["Income"], ["Expenses"], ["Equity"]]

        else:

            sheet_name = "Fund Report"

            headers += [["Additions"], ["Releases from", "Restrictions"]]

        headers.append(["Balance as of", self.stop_date.isoformat()])

        if expanded:

            headers += [

                ["Of which", "Receivable"],

                ["Of which", "Prepaid Expenses"],

                ["Of which", "Payable"],

                ["Of which", "Unearned Income"],

            ]

        self.use_sheet(sheet_name)

        for header in headers:

            first_line = header[0]

            if first_line == 'Fund':

                width = 2.0

            elif first_line == 'Balance as of':

                width = 1.5

            elif first_line == 'Of which':

                width = 1.3

            else:

                width = 1.2

            col_style = self.column_style(width)

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

        center_bold = self.merge_styles(self.style_centertext, self.style_bold)

        row = self.add_row(*(

            self.multiline_cell(header, stylename=center_bold)

            for header in headers

        ))

        row.firstChild.setAttribute(

            'stylename', self.merge_styles(self.style_endtext, self.style_bold),

        )

        self.lock_first_row()

        self.lock_first_column()

        self.add_row()

        self.add_row(self.string_cell(

            f"Fund Report From {self.start_date.isoformat()} To {self.stop_date.isoformat()}",

            stylename=center_bold,

            numbercolumnsspanned=6,

        ))

        self.add_row()

    def end_spreadsheet(self) -> None:

        start_sheet = self.sheet

        self.set_open_sheet(self.sheet)

        self.start_spreadsheet(expanded=False)

        bal_indexes = [0, 1, 2, 4]

        totals = [core.MutableBalance() for _ in bal_indexes]

        threshold = Decimal('.5')

            if (not all(bal.clean_copy(threshold).le_zero() for bal in balances)

                and fund != UNRESTRICTED_FUND):

                self.write_balances(fund, balances)

                for total, bal in zip(totals, balances):

                    total += bal

        self.write_balances('', totals, self.merge_styles(

            self.border_style(core.Border.TOP, '.75pt'),

            self.border_style(core.Border.BOTTOM, '1.5pt', 'double'),

        ))

        self.document.spreadsheet.childNodes.reverse()

        self.sheet = start_sheet

    def _row_balances(self, accounts_map: AccountsMap) -> Iterator[core.Balance]:

        acct_order = ['Income', 'Expenses', 'Equity']

        key_order = [core.OPENING_BALANCE_NAME, *acct_order, core.ENDING_BALANCE_NAME]

        balances: Dict[str, core.Balance] = {key: core.MutableBalance() for key in key_order}

        for acct_s, balance in core.account_balances(accounts_map, acct_order):

            if acct_s in balances:

                balances[acct_s] = balance

            else:

                acct_root, _, _ = acct_s.partition(':')

                balances[acct_root] += balance

        for key in key_order:

            if key == 'Expenses':

                yield balances[key]

            else:

                yield -balances[key]

        for info_key in INFO_ACCOUNTS:

            for _, balance in core.account_balances(accounts_map, [info_key]):

                pass

            yield core.normalize_amount_func(info_key)(balance)

    def write_balances(self,

                       fund: str,

                       balances: Iterable[core.Balance],

                       style: Union[None, str, odf.style.Style]=None,

    ) -> odf.table.TableRow:

        return self.add_row(

            self.string_cell(fund, stylename=self.style_endtext),

            *(self.balance_cell(bal, stylename=style) for bal in balances),

        )

    def write_row(self, row: FundPosts) -> None:

        fund, accounts_map = row

        self.balances[fund] = list(self._row_balances(accounts_map))

        if fund != UNRESTRICTED_FUND:

            self.write_balances(fund, self.balances[fund])

    def write(self, rows: Iterable[FundPosts]) -> None:

        self.balances: Dict[str, Sequence[core.Balance]] = collections.OrderedDict()

        super().write(rows)

        try:

            unrestricted = self.balances[UNRESTRICTED_FUND]

        except KeyError:

            pass

        else:

            self.add_row()

            self.write_balances("Unrestricted", unrestricted)

class TextReport:

    def __init__(self,

                 start_date: datetime.date,

                 stop_date: datetime.date,

                 out_file: TextIO) -> None:

        self.start_date = start_date

        self.stop_date = stop_date

        self.out_file = out_file

    def _account_balances(self,

                          fund: str,

                          account_map: AccountsMap,

    ) -> Iterator[Tuple[str, Sequence[str]]]:

        total_fmt = f'{fund} balance as of {{}}'

        for acct_s, balance in core.account_balances(account_map, EQUITY_ACCOUNTS):

            if acct_s is core.OPENING_BALANCE_NAME:

                acct_s = total_fmt.format(self.start_date.isoformat())

            elif acct_s is core.ENDING_BALANCE_NAME:

                acct_s = total_fmt.format(self.stop_date.isoformat())

            yield acct_s, (-balance).format(None, sep='\0').split('\0')

        for _, account in core.sort_and_filter_accounts(account_map, INFO_ACCOUNTS):

            balance = account_map[account].stop_bal

            if not balance.is_zero():

                balance = core.normalize_amount_func(account)(balance)

                yield account, balance.format(None, sep='\0').split('\0')

    def write(self, rows: Iterable[FundPosts]) -> None:

        output = [

            line

            for fund, account_map in rows

            for line in self._account_balances(fund, account_map)

        ]

        acct_width = max(len(acct_s) for acct_s, _ in output) + 2

        bal_width = max(len(s) for _, bal_s in output for s in bal_s)

        bal_width = max(bal_width, 8)

        line_fmt = f'{{:>{acct_width}}}  {{:>{bal_width}}}'

2018-01-01 open Liabilities:UnearnedIncome

2018-02-28 * "Opening balances"

  Equity:Funds:Unrestricted  -4,000 USD

  project: "Conservancy"

  Equity:Funds:Restricted    -3,000 USD

  project: "Alpha"

  Equity:Funds:Restricted    -2,000 USD

  project: "Bravo"

  Equity:Funds:Restricted    -1,000 USD

  project: "Charlie"

  Assets:Checking            10,000 USD

2018-03-03 * "Conservancy receivable 2018"

  project: "Conservancy"

  Income:Other               -32 EUR {1.25 USD}

  Assets:Receivable:Accounts  32 EUR {1.25 USD}

2018-03-06 * "Conservancy payable 2018"

  project: "Conservancy"

  Expenses:Other                 4 USD

  Liabilities:Payable:Accounts  -4 USD

2018-06-03 * "Alpha income 2018"

  project: "Alpha"

  Income:Other    -60 USD

  Assets:Checking  60 USD

2018-06-06 * "Alpha unearned income"

  project: "Alpha"

  Liabilities:UnearnedIncome  -30 USD

  Assets:Checking              30 USD

2018-06-09 * "Alpha prepaid expense"

  project: "Alpha"

  Assets:Prepaid:Expenses  20 USD

  Assets:Checking         -20 USD

2018-09-03 * "Bravo expense"

  project: "Bravo"

  Expenses:Other    20 USD

  Assets:Checking  -20 USD

2018-12-03 * "Delta income"

  project: "Delta"

  Income:Other    -0.40 USD

  Assets:Checking  0.40 USD

2019-03-03 * "Conservancy receivable paid"

  project: "Conservancy"

  Assets:Receivable:Accounts  -32 EUR {1.25 USD} @ 1.5 USD

  Assets:EUR                   32 EUR {1.5 USD}

  Equity:Realized:CurrencyConversion

2019-03-06 * "Conservancy payable paid"

  project: "Conservancy"

  Liabilities:Payable:Accounts  4 USD

  Assets:Checking              -4 USD

2019-03-12 * "Conservancy income 2019"

  project: "Conservancy"

  Income:Other    -28 EUR {1.5 USD}

  Assets:Checking  40 USD

  Equity:Realized:CurrencyConversion

2019-03-15 * "Conservancy expense 2019"

  project: "Conservancy"

  Expenses:Other    2.80 EUR {1.5 USD}

  Assets:Checking  -4.00 USD

  Equity:Realized:CurrencyConversion

2019-06-06 * "Alpha unearned income converted"

  project: "Alpha"

  Liabilities:UnearnedIncome  30 USD

  Income:Other               -30 USD

2019-06-09 * "Alpha prepaid expense converted"

  project: "Alpha"

  Assets:Prepaid:Expenses  -20 USD

  Expenses:Other            20 USD

2019-06-12 * "Alpha expense 2019A"

  project: "Alpha"

  Expenses:Other    3 USD

  Assets:Checking  -3 USD

2019-06-15 * "Alpha expense 2019B"

  project: "Alpha"

  Expenses:Other    3 USD

  Assets:Checking  -3 USD

2019-09-03 * "Bravo income"

  project: "Bravo"

  Income:Other    -200 USD

  Assets:Checking  200 USD

  project: "Delta"

  Income:Other    -4.60 USD

  Assets:Checking  4.60 USD

        cost_s = f' {{{self.cost_number} {self.cost_currency}, {self.cost_date}}}'

        if cost_s == ' {None None, None}':

            cost_s = ''

        return f'<{self.account}  {self.units_number} {self.units_currency}{cost_s}>'

    @classmethod

    def make(cls,

             account,

             units_number,

             units_currency='USD',

             cost_number=None,

             cost_date=None,

             project=None,

             cost_currency=None,

    ):

        if cost_number is not None:

            cost_number = Decimal(cost_number)

            if cost_currency is None:

                cost_currency = 'USD'

            if isinstance(cost_date, str):

                cost_date = datetime.datetime.strptime(cost_date, '%Y-%m-%d').date()

        return cls(account, Decimal(units_number), units_currency,

                   cost_number, cost_currency, cost_date, project)

    @classmethod

    def from_beancount(cls, posting):

        units_number, units_currency = posting.units

        if posting.cost is None:

            cost_number = cost_currency = cost_date = None

        else:

            cost_number, cost_currency, cost_date, _ = posting.cost

        try:

            project = posting.meta['project']

        except (AttributeError, KeyError):

            project = None

        return cls(posting.account, units_number, units_currency,

                   cost_number, cost_currency, cost_date, project)

    @classmethod

    def from_output(cls, output):

        entries, _, _ = bc_loader.load_string(output.read())

        return (cls.from_beancount(post) for post in entries[-1].postings)

def run_main(arglist, config=None):

    if config is None:

        config = testutil.TestConfig(

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

        )

    output = io.StringIO()

    errors = io.StringIO()

    retcode = openbalmod.main(arglist, output, errors, config)

    output.seek(0)

    return retcode, output, errors

@pytest.mark.parametrize('arg', ['2018', '2018-03-01'])

def test_2018_opening(arg):

    retcode, output, errors = run_main([arg])

    assert not errors.getvalue()

    assert retcode == 0

    assert list(FlatPosting.from_output(output)) == [

        FlatPosting.make(A_CHECKING, 10000),

        FlatPosting.make(A_RESTRICTED, -3000, project='Alpha'),

        FlatPosting.make(A_RESTRICTED, -2000, project='Bravo'),

        FlatPosting.make(A_RESTRICTED, -1000, project='Charlie'),

        FlatPosting.make(A_UNRESTRICTED, -4000, project='Conservancy'),

    ]

@pytest.mark.parametrize('arg', ['2019', '2019-03-01'])

def test_2019_opening(arg):

    retcode, output, errors = run_main([arg])

    assert not errors.getvalue()

    assert retcode == 0

    assert list(FlatPosting.from_output(output)) == [

        FlatPosting.make(A_CHECKING, '10050.40'),

        FlatPosting.make(A_PREPAID, 20, project='Alpha'),

        FlatPosting.make(A_RECEIVABLE, 32, 'EUR', '1.25', '2018-03-03', 'Conservancy'),

        FlatPosting.make(A_RESTRICTED, -3060, project='Alpha'),

        FlatPosting.make(A_RESTRICTED, -1980, project='Bravo'),

        FlatPosting.make(A_RESTRICTED, -1000, project='Charlie'),

        FlatPosting.make(A_RESTRICTED, '-.40', project='Delta'),

        FlatPosting.make(A_UNRESTRICTED, -4036, project='Conservancy'),

        FlatPosting.make(A_PAYABLE, -4, project='Conservancy'),

        FlatPosting.make(A_UNEARNED, -30, project='Alpha'),

    ]

@pytest.mark.parametrize('arg', ['2020', '2020-12-31'])

def test_2020_opening(arg):

    retcode, output, errors = run_main([arg])

    assert not errors.getvalue()

    assert retcode == 0

    assert list(FlatPosting.from_output(output)) == [

        FlatPosting.make(A_CHECKING, 10281),

        FlatPosting.make(A_EUR, 32, 'EUR', '1.5', '2019-03-03'),

        FlatPosting.make(A_RESTRICTED, -3064, project='Alpha'),

        FlatPosting.make(A_RESTRICTED, -2180, project='Bravo'),

        FlatPosting.make(A_RESTRICTED, -5, project='Delta'),

    ]

"""test_reports_fund.py - Unit tests for fund report"""

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

import copy

import datetime

import io

import itertools

import pytest

from . import testutil

import babel.numbers

import odf.opendocument

import odf.table

from beancount import loader as bc_loader

from conservancy_beancount import data

from conservancy_beancount.reports import core

from conservancy_beancount.reports import fund

from decimal import Decimal

_ledger_load = bc_loader.load_file(testutil.test_path('books/fund.beancount'))

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

MID_DATE = datetime.date(2019, 3, 1)

STOP_DATE = datetime.date(2020, 3, 1)

EQUITY_ROOT_ACCOUNTS = ('Expenses:', 'Equity:', 'Income:')

OPENING_BALANCES = {

    'Alpha': 3000,

    'Bravo': 2000,

    'Charlie': 1000,

    'Conservancy': 4000,

    'Delta': 0,

}

BALANCES_BY_YEAR = {

    ('Conservancy', 2018): [

        ('Income:Other', 40),

        ('Expenses:Other', -4),

        ('Assets:Receivable:Accounts', 40),

        ('Liabilities:Payable:Accounts', 4),

    ],

    ('Conservancy', 2019): [

        ('Income:Other', 42),

        ('Expenses:Other', Decimal('-4.20')),

        ('Equity:Realized:CurrencyConversion', Decimal('6.20')),

        ('Assets:Receivable:Accounts', -40),

        ('Liabilities:Payable:Accounts', -4),

    ],

    ('Alpha', 2018): [

        ('Income:Other', 60),

        ('Liabilities:UnearnedIncome', 30),

        ('Assets:Prepaid:Expenses', 20),

    ],

    ('Alpha', 2019): [

        ('Income:Other', 30),

        ('Expenses:Other', -26),

        ('Assets:Prepaid:Expenses', -20),

        ('Liabilities:UnearnedIncome', -30),

    ],

    ('Bravo', 2018): [

        ('Expenses:Other', -20),

    ],

    ('Bravo', 2019): [

        ('Income:Other', 200),

    ],

    ('Delta', 2018): [

        ('Income:Other', Decimal('.40')),

    ],

    ('Delta', 2019): [

        ('Income:Other', Decimal('4.60')),

    ],

}

@pytest.fixture

def fund_entries():

    return copy.deepcopy(_ledger_load[0])

def split_text_lines(output):

    for line in output:

        account, amount = line.rsplit(None, 1)

        yield account.strip(), amount

def format_amount(amount, currency='USD'):

    return babel.numbers.format_currency(

        amount, currency, format_type='accounting',

    )

def check_text_balances(actual, expected, *expect_accounts):

    balance = Decimal()

    for expect_account in expect_accounts:

        expect_amount = expected[expect_account]

        if expect_amount:

            actual_account, actual_amount = next(actual)

            assert actual_account == expect_account

            assert actual_amount == format_amount(expect_amount)

            balance += expect_amount

    return balance

def check_text_report(output, project, start_date, stop_date):

    _, _, project = project.rpartition('=')

    balance_amount = Decimal(OPENING_BALANCES[project])

    expected = collections.defaultdict(Decimal)

    for year in range(2018, stop_date.year):

        try:

            amounts = BALANCES_BY_YEAR[(project, year)]

        except KeyError:

            pass

        else:

            for account, amount in amounts:

                if year < start_date.year and account.startswith(EQUITY_ROOT_ACCOUNTS):

                    balance_amount += amount

                else:

                    expected[account] += amount

    actual = split_text_lines(output)

    next(actual); next(actual)  # Discard headers

    open_acct, open_amt = next(actual)

    assert open_acct == "{} balance as of {}".format(

        project, start_date.isoformat(),

    )

    assert open_amt == format_amount(balance_amount)

    balance_amount += check_text_balances(

        actual, expected,

        'Equity:Realized:CurrencyConversion',

        'Income:Other',

        'Expenses:Other',

    )

    end_acct, end_amt = next(actual)

    assert end_acct == "{} balance as of {}".format(

        project, stop_date.isoformat(),

    )

    assert end_amt == format_amount(balance_amount)

    balance_amount += check_text_balances(

        actual, expected,

        'Assets:Receivable:Accounts',

        'Assets:Prepaid:Expenses',

        'Liabilities:Payable:Accounts',

        'Liabilities:UnearnedIncome',

    )

    assert next(actual, None) is None

def check_cell_balance(cell, balance):

    if balance:

        assert cell.value == balance

    else:

        assert not cell.value

def check_ods_sheet(sheet, account_balances, *, full):

    if full:

        account_bals = account_balances.copy()

        account_bals['Unrestricted'] = account_bals.pop('Conservancy')

    else:

        account_bals = {

            key: balances

            for key, balances in account_balances.items()

            if key != 'Conservancy' and any(v >= .5 for v in balances.values())

        }

        totals = {key: Decimal() for key in

        for fund, balances in account_bals.items():

            for key in totals:

                totals[key] += balances[key]

        account_bals[''] = totals

    for row in itertools.islice(sheet.getElementsByType(odf.table.TableRow), 4, None):

        cells = iter(testutil.ODSCell.from_row(row))

        try:

            fund = next(cells).firstChild.text

        except (AttributeError, StopIteration):

            continue

        try:

            balances = account_bals.pop(fund)

        except KeyError:

            pytest.fail(f"report included unexpected fund {fund}")

        check_cell_balance(next(cells), balances['opening'])

        check_cell_balance(next(cells), balances['Income'])

        if full:

        check_cell_balance(next(cells), sum(balances[key] for key in [

        ]))

        if full:

            check_cell_balance(next(cells), balances['Assets:Receivable'])

            check_cell_balance(next(cells), balances['Assets:Prepaid'])

            check_cell_balance(next(cells), balances['Liabilities'])

            check_cell_balance(next(cells), balances['Liabilities:Payable'])

        assert next(cells, None) is None

    assert not account_bals, "did not see all funds in report"

def check_ods_report(ods, start_date, stop_date):

    account_bals = collections.OrderedDict((key, {

        'opening': Decimal(amount),

        'Income': Decimal(0),

        'Expenses': Decimal(0),

        'Assets:Receivable': Decimal(0),

        'Assets:Prepaid': Decimal(0),

        'Liabilities:Payable': Decimal(0),

        'Liabilities': Decimal(0),  # UnearnedIncome

    }) for key, amount in sorted(OPENING_BALANCES.items()))

    for fund, year in itertools.product(account_bals, range(2018, stop_date.year)):

        try:

            amounts = BALANCES_BY_YEAR[(fund, year)]

        except KeyError:

            pass

        else:

            for account, amount in amounts:

                else:

                    acct_key, _, _ = account.rpartition(':')

                account_bals[fund][acct_key] += amount

    sheets = iter(ods.getElementsByType(odf.table.Table))

    check_ods_sheet(next(sheets), account_bals, full=False)

    check_ods_sheet(next(sheets), account_bals, full=True)

    assert next(sheets, None) is None, "found unexpected sheet"

def run_main(out_type, arglist, config=None):

    if config is None:

        config = testutil.TestConfig(

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

        )

    arglist.insert(0, '--output-file=-')

    output = out_type()

    errors = io.StringIO()

    retcode = fund.main(arglist, output, errors, config)

    output.seek(0)

    return retcode, output, errors

@pytest.mark.parametrize('project,start_date,stop_date', [

    ('Conservancy', START_DATE, STOP_DATE),

    ('project=Conservancy', MID_DATE, STOP_DATE),

    ('Conservancy', START_DATE, MID_DATE),

    ('Alpha', START_DATE, STOP_DATE),

    ('project=Alpha', MID_DATE, STOP_DATE),

    ('Alpha', START_DATE, MID_DATE),

    ('Bravo', START_DATE, STOP_DATE),

    ('project=Bravo', MID_DATE, STOP_DATE),

    ('Bravo', START_DATE, MID_DATE),

    ('project=Charlie', START_DATE, STOP_DATE),

])

def test_text_report(project, start_date, stop_date):

    retcode, output, errors = run_main(io.StringIO, [

        '-b', start_date.isoformat(), '-e', stop_date.isoformat(), project,

    ])

    assert not errors.getvalue()

    assert retcode == 0

    check_text_report(output, project, start_date, stop_date)

@pytest.mark.parametrize('start_date,stop_date', [

    (START_DATE, STOP_DATE),

    (MID_DATE, STOP_DATE),

    (START_DATE, MID_DATE),

])

def test_ods_report(start_date, stop_date):

    retcode, output, errors = run_main(io.BytesIO, [

        '--begin', start_date.isoformat(), '--end', stop_date.isoformat(),

    ])

    assert not errors.getvalue()

    assert retcode == 0

    ods = odf.opendocument.load(output)

    check_ods_report(ods, start_date, stop_date)

def test_main_no_postings(caplog):

    retcode, output, errors = run_main(io.StringIO, ['NonexistentProject'])

    assert retcode == 65

    assert any(log.levelname == 'WARNING' for log in caplog.records)