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]

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"

        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"],

            ]

                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]:

        balances: Dict[str, core.Balance] = {key: core.MutableBalance() for key in key_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]):

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

        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}}}'

        print(line_fmt.replace('{:>', '{:^').format("ACCOUNT", "BALANCE"),

              file=self.out_file)

        fund_start = f' balance as of {self.start_date.isoformat()}'

        for acct_s, bal_seq in output:

                      file=self.out_file)

            bal_iter = iter(bal_seq)

            print(line_fmt.format(acct_s, next(bal_iter)), file=self.out_file)

            for bal_s in bal_iter:

                print(line_fmt.format('', bal_s), file=self.out_file)

class ReportType(enum.Enum):

    TEXT = TextReport

    ODS = ODSReport

    TXT = TEXT

    SPREADSHEET = ODS

    @classmethod

    def from_arg(cls, s: str) -> 'ReportType':

        try:

            return cls[s.upper()]

        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)

    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:

                    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:Funds:Restricted',

        'Equity:Funds:Unrestricted',

        'Equity:Realized:CurrencyConversion',

    )

    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