# This file is part of Tryton.  The COPYRIGHT file at the top level of
# this repository contains the full copyright notices and license terms.
from decimal import Decimal
from itertools import chain

from simpleeval import simple_eval

from trytond.i18n import gettext
from trytond.model import (
    DeactivableMixin, ModelSQL, ModelView, Workflow, fields)
from trytond.modules.company.model import (
    CompanyMultiValueMixin, CompanyValueMixin)
from trytond.modules.currency.fields import Monetary
from trytond.pool import Pool, PoolMeta
from trytond.pyson import Bool, Eval
from trytond.tools import decistmt
from trytond.transaction import Transaction

from .exceptions import FormulaError


class AdvancePaymentTerm(
        DeactivableMixin, ModelSQL, ModelView):
    "Advance Payment Term"
    __name__ = 'sale.advance_payment_term'

    name = fields.Char("Name", required=True, translate=True)
    lines = fields.One2Many(
        'sale.advance_payment_term.line', 'advance_payment_term', "Lines")

    def get_advance_payment_context(self, sale):
        return {
            'total_amount': sale.total_amount,
            'untaxed_amount': sale.untaxed_amount,
            }

    def get_conditions(self, sale):
        conditions = []
        term_context = self.get_advance_payment_context(sale)
        for line in self.lines:
            condition = line.get_condition(sale.currency, **term_context)
            if condition.amount > 0:
                conditions.append(condition)
        return conditions


class AdvancePaymentTermLine(ModelView, ModelSQL, CompanyMultiValueMixin):
    "Advance Payment Term Line"
    __name__ = 'sale.advance_payment_term.line'
    _rec_name = 'description'

    advance_payment_term = fields.Many2One(
        'sale.advance_payment_term', "Advance Payment Term",
        required=True, ondelete='CASCADE')
    description = fields.Char(
        "Description", required=True, translate=True,
        help="Used as description for the invoice line.")
    account = fields.MultiValue(
        fields.Many2One('account.account', "Account", required=True,
            domain=[
                ('type.unearned_revenue', '=', True),
                ],
            help="Used for the line of advance payment invoice."))
    accounts = fields.One2Many(
        'sale.advance_payment_term.line.account', 'line', "Accounts")
    block_supply = fields.Boolean(
        "Block Supply",
        help="Check to prevent any supply request before advance payment.")
    block_shipping = fields.Boolean(
        "Block Shipping",
        help="Check to prevent the packing of the shipment "
        "before advance payment.")
    invoice_delay = fields.TimeDelta(
        "Invoice Delay",
        help="Delta to apply on the sale date for the date of "
        "the advance payment invoice.")
    formula = fields.Char('Formula', required=True,
        help="A python expression used to compute the advance payment amount "
            "that will be evaluated with:\n"
            "- total_amount: The total amount of the sale.\n"
            "- untaxed_amount: The total untaxed amount of the sale.")

    @classmethod
    def __setup__(cls):
        super().__setup__()
        cls.__access__.add('advance_payment_term')

    @fields.depends('formula', 'description')
    def pre_validate(self, **names):
        super(AdvancePaymentTermLine, self).pre_validate()
        names['total_amount'] = names['untaxed_amount'] = 0
        try:
            if not isinstance(self.compute_amount(**names), Decimal):
                raise Exception('The formula does not return a Decimal')
        except Exception as exception:
            raise FormulaError(
                gettext('sale_advance_payment.msg_term_line_invalid_formula',
                    formula=self.formula,
                    term_line=self.description or '',
                    exception=exception)) from exception

    def get_compute_amount_context(self, **names):
        return {
            'names': names,
            'functions': {
                'Decimal': Decimal,
                },
            }

    def compute_amount(self, **names):
        context = self.get_compute_amount_context(**names)
        return simple_eval(decistmt(self.formula), **context)

    def get_condition(self, currency, **context):
        pool = Pool()
        AdvancePaymentCondition = pool.get('sale.advance_payment.condition')

        return AdvancePaymentCondition(
            block_supply=self.block_supply,
            block_shipping=self.block_shipping,
            amount=currency.round(self.compute_amount(**context)),
            account=self.account,
            invoice_delay=self.invoice_delay,
            description=self.description)


class AdvancePaymentTermLineAccount(ModelSQL, CompanyValueMixin):
    "Advance Payment Term Line Account"
    __name__ = 'sale.advance_payment_term.line.account'

    line = fields.Many2One(
        'sale.advance_payment_term.line', "Line",
        required=True, ondelete='CASCADE',
        context={
            'company': Eval('company', -1),
            })
    account = fields.Many2One(
        'account.account', "Account", required=True,
        domain=[
            ('type.unearned_revenue', '=', True),
            ('company', '=', Eval('company', -1)),
            ])


class AdvancePaymentCondition(ModelSQL, ModelView):
    "Advance Payment Condition"
    __name__ = 'sale.advance_payment.condition'
    _rec_name = 'description'

    _states = {
        'readonly': Eval('sale_state') != 'draft',
        }

    sale = fields.Many2One(
        'sale.sale', "Sale", required=True, ondelete='CASCADE',
        states={
            'readonly': ((Eval('sale_state') != 'draft')
                & Bool(Eval('sale'))),
            })
    description = fields.Char("Description", required=True, states=_states)
    amount = Monetary(
        "Amount", currency='currency', digits='currency', states=_states)
    account = fields.Many2One(
        'account.account', "Account", required=True,
        domain=[
            ('type.unearned_revenue', '=', True),
            ('company', '=', Eval('sale_company')),
            ],
        states=_states)
    block_supply = fields.Boolean("Block Supply", states=_states)
    block_shipping = fields.Boolean("Block Shipping", states=_states)
    invoice_delay = fields.TimeDelta("Invoice Delay", states=_states)

    invoice_lines = fields.One2Many(
        'account.invoice.line', 'origin', "Invoice Lines", readonly=True)
    completed = fields.Function(fields.Boolean("Completed"), 'get_completed')

    sale_state = fields.Function(fields.Selection(
            'get_sale_states', "Sale State"), 'on_change_with_sale_state')
    sale_company = fields.Function(fields.Many2One(
            'company.company', "Company"), 'on_change_with_sale_company')
    currency = fields.Function(fields.Many2One(
            'currency.currency', "Currency"),
        'on_change_with_currency')

    del _states

    @classmethod
    def __setup__(cls):
        super(AdvancePaymentCondition, cls).__setup__()
        cls._order.insert(0, ('amount', 'ASC'))
        cls.__access__.add('sale')

    @classmethod
    def get_sale_states(cls):
        pool = Pool()
        Sale = pool.get('sale.sale')
        return Sale.fields_get(['state'])['state']['selection']

    @fields.depends('sale', '_parent_sale.state')
    def on_change_with_sale_state(self, name=None):
        if self.sale:
            return self.sale.state

    @fields.depends('sale', '_parent_sale.company')
    def on_change_with_sale_company(self, name=None):
        return self.sale.company if self.sale else None

    @fields.depends('sale', '_parent_sale.currency')
    def on_change_with_currency(self, name=None):
        return self.sale.currency if self.sale else None

    @classmethod
    def copy(cls, conditions, default=None):
        if default is None:
            default = {}
        else:
            default = default.copy()
        default.setdefault('invoice_lines', [])
        return super(AdvancePaymentCondition, cls).copy(conditions, default)

    def create_invoice(self):
        invoice = self.sale._get_invoice_sale()
        if self.invoice_delay is not None:
            invoice.invoice_date = self.sale.sale_date + self.invoice_delay
        invoice.payment_term = None

        invoice_lines = self.get_invoice_advance_payment_lines(invoice)
        if not invoice_lines:
            return None
        invoice.lines = invoice_lines
        return invoice

    def get_invoice_advance_payment_lines(self, invoice):
        pool = Pool()
        InvoiceLine = pool.get('account.invoice.line')

        advance_amount = self._get_advance_amount()
        advance_amount += self._get_ignored_amount()
        if advance_amount >= self.amount:
            return []

        invoice_line = InvoiceLine()
        invoice_line.invoice = invoice
        invoice_line.type = 'line'
        invoice_line.quantity = 1
        invoice_line.account = self.account
        invoice_line.unit_price = self.amount - advance_amount
        invoice_line.description = self.description
        invoice_line.origin = self
        invoice_line.company = self.sale.company
        invoice_line.currency = self.sale.currency
        # Set taxes
        invoice_line.on_change_account()
        return [invoice_line]

    def _get_advance_amount(self):
        return sum(l.amount for l in self.invoice_lines
            if l.invoice.state != 'cancelled')

    def _get_ignored_amount(self):
        skips = {l for i in self.sale.invoices_recreated for l in i.lines}
        return sum(l.amount for l in self.invoice_lines
            if l.invoice.state == 'cancelled' and l not in skips)

    def get_completed(self, name):
        advance_amount = 0
        lines_ignored = set(l for i in self.sale.invoices_ignored
            for l in i.lines)
        for l in self.invoice_lines:
            if l.invoice.state == 'paid' or l in lines_ignored:
                advance_amount += l.amount
        return advance_amount >= self.amount


class Sale(metaclass=PoolMeta):
    __name__ = 'sale.sale'

    advance_payment_term = fields.Many2One('sale.advance_payment_term',
        'Advance Payment Term',
        ondelete='RESTRICT', states={
            'readonly': Eval('state') != 'draft',
            })
    advance_payment_conditions = fields.One2Many(
        'sale.advance_payment.condition', 'sale',
        'Advance Payment Conditions',
        states={
            'readonly': Eval('state') != 'draft',
            })
    advance_payment_invoices = fields.Function(fields.Many2Many(
            'account.invoice', None, None, "Advance Payment Invoices"),
        'get_advance_payment_invoices',
        searcher='search_advance_payment_invoices')

    @classmethod
    def __setup__(cls):
        super().__setup__()
        cls.invoices_ignored.domain = [
            'OR', cls.invoices_ignored.domain, [
                ('id', 'in', Eval('advance_payment_invoices', [])),
                ('state', '=', 'cancelled'),
                ],
            ]

    @classmethod
    @ModelView.button
    @Workflow.transition('quotation')
    def quote(cls, sales):
        pool = Pool()
        AdvancePaymentCondition = pool.get('sale.advance_payment.condition')

        super(Sale, cls).quote(sales)

        AdvancePaymentCondition.delete(
            list(chain(*(s.advance_payment_conditions for s in sales))))

        for sale in sales:
            sale.set_advance_payment_term()
        cls.save(sales)

    @classmethod
    def copy(cls, sales, default=None):
        if default is None:
            default = {}
        else:
            default = default.copy()
        default.setdefault('advance_payment_conditions', None)
        return super(Sale, cls).copy(sales, default=default)

    def set_advance_payment_term(self):
        pool = Pool()
        AdvancePaymentTerm = pool.get('sale.advance_payment_term')
        if self.advance_payment_term:
            if self.party and self.party.lang:
                with Transaction().set_context(language=self.party.lang.code):
                    advance_payment_term = AdvancePaymentTerm(
                        self.advance_payment_term.id)
            else:
                advance_payment_term = self.advance_payment_term
            self.advance_payment_conditions = \
                advance_payment_term.get_conditions(self)

    def get_advance_payment_invoices(self, name):
        invoices = set()
        for condition in self.advance_payment_conditions:
            for invoice_line in condition.invoice_lines:
                if invoice_line.invoice:
                    invoices.add(invoice_line.invoice.id)
        return list(invoices)

    @classmethod
    def search_advance_payment_invoices(cls, name, clause):
        return [('advance_payment_conditions.invoice_lines.invoice'
                + clause[0][len(name):], *clause[1:])]

    @property
    def _invoices_for_state(self):
        return super()._invoices_for_state + self.advance_payment_invoices

    def get_recall_lines(self, invoice):
        pool = Pool()
        InvoiceLine = pool.get('account.invoice.line')

        recall_lines = []
        advance_lines = [
            l
            for c in self.advance_payment_conditions
            for l in c.invoice_lines
            if l.type == 'line' and l.invoice.state == 'paid']
        for advance_line in advance_lines:
            amount = advance_line.amount
            for recalled_line in advance_line.advance_payment_recalled_lines:
                amount += recalled_line.amount
            if amount:
                line = InvoiceLine(
                    invoice=invoice,
                    company=invoice.company,
                    type='line',
                    quantity=-1,
                    account=advance_line.account,
                    unit_price=amount,
                    description=advance_line.description,
                    origin=advance_line,
                    taxes=advance_line.taxes,
                    taxes_date=advance_line.tax_date,
                    )
                recall_lines.append(line)
        return recall_lines

    @classmethod
    def _process_invoice(cls, sales):
        pool = Pool()
        Invoice = pool.get('account.invoice')
        invoices = []
        for sale in sales:
            if (sale.advance_payment_eligible()
                    and not sale.advance_payment_completed):
                for condition in sale.advance_payment_conditions:
                    invoice = condition.create_invoice()
                    if invoice:
                        invoices.append(invoice)
        Invoice.save(invoices)

        super()._process_invoice(sales)

    def create_invoice(self):
        invoice = super(Sale, self).create_invoice()

        if (invoice is not None
                and self.advance_payment_eligible()
                and self.advance_payment_completed):
            invoice.lines = (
                list(getattr(invoice, 'lines', ()))
                + self.get_recall_lines(invoice))
        return invoice

    def advance_payment_eligible(self, shipment_type=None):
        """
        Returns True when the shipment_type is eligible to further processing
        of the sale's advance payment.
        """
        return bool((shipment_type == 'out' or shipment_type is None)
            and self.advance_payment_conditions)

    @property
    def advance_payment_completed(self):
        """
        Returns True when the advance payment process is completed
        """
        return (bool(self.advance_payment_conditions)
            and all(c.completed for c in self.advance_payment_conditions))

    @property
    def supply_blocked(self):
        for condition in self.advance_payment_conditions:
            if not condition.block_supply:
                continue
            if not condition.completed:
                return True
        return False

    @property
    def shipping_blocked(self):
        for condition in self.advance_payment_conditions:
            if not condition.block_shipping:
                continue
            if not condition.completed:
                return True
        return False


class SaleLine(metaclass=PoolMeta):
    __name__ = 'sale.line'

    def get_move(self, shipment_type):
        move = super(SaleLine, self).get_move(shipment_type)
        if (self.sale.advance_payment_eligible(shipment_type)
                and self.sale.supply_blocked):
            return None
        return move

    def get_purchase_request(self, product_quantities):
        request = super().get_purchase_request(product_quantities)
        if (self.sale.advance_payment_eligible()
                and self.sale.supply_blocked):
            return None
        return request

    def get_invoice_line(self):
        lines = super(SaleLine, self).get_invoice_line()
        if (self.sale.advance_payment_eligible()
                and not self.sale.advance_payment_completed):
            return []
        return lines


class HandleInvoiceException(metaclass=PoolMeta):
    __name__ = 'sale.handle.invoice.exception'

    def default_ask(self, fields):
        default = super(HandleInvoiceException, self).default_ask(fields)
        invoices = default['domain_invoices']

        sale = self.record
        skips = set(sale.invoices_ignored)
        skips.update(sale.invoices_recreated)
        for invoice in sale.advance_payment_invoices:
            if invoice.state == 'cancelled' and invoice not in skips:
                invoices.append(invoice.id)
        return default
