# This file is part of facho.  The COPYRIGHT file at the top level of
# this repository contains the full copyright notices and license terms.

# import hashlib
# from functools import reduce
# import copy

import dataclasses
from dataclasses import dataclass, field
from datetime import datetime, date
# from collections import defaultdict
import decimal
from decimal import Decimal
import typing
from ..data.dian import codelist

DECIMAL_PRECISION = 6


class AmountCurrencyError(TypeError):
    pass


@dataclass
class Currency:
    code: str

    def __eq__(self, other):
        return self.code == other.code

    def __str__(self):
        return self.code


class Collection:

    def __init__(self, array):
        self.array = array

    def filter(self, filterer):
        new_array = filter(filterer, self.array)
        return self.__class__(new_array)

    def map(self, mapper):
        new_array = map(mapper, self.array)
        return self.__class__(new_array)

    def sum(self):
        return sum(self.array)


class AmountCollection(Collection):

    def sum(self):
        total = Amount(0)
        for v in self.array:
            total += v
        return total


class Amount:
    def __init__(
            self, amount: typing.Union[int, float, str, "Amount"],
            currency: Currency = Currency('COP')):

        # DIAN 1.7.-2020: 1.2.3.1
        if isinstance(amount, Amount):
            if amount < Amount(0.0):
                raise ValueError('amount must be positive >= 0')

            self.amount = amount.amount
            self.currency = amount.currency
        else:
            if float(amount) < 0:
                raise ValueError('amount must be positive >= 0')

            self.amount = Decimal(
                amount, decimal.Context(
                    prec=DECIMAL_PRECISION,
                    # DIAN 1.7.-2020: 1.2.1.1
                    rounding=decimal.ROUND_HALF_EVEN))
            self.currency = currency

    def fromNumber(self, val):
        return Amount(val, currency=self.currency)

    def round(self, prec):
        return Amount(round(self.amount, prec), currency=self.currency)

    def __round__(self, prec):
        return round(self.amount, prec)

    def __str__(self):
        return str(self.float())

    def __lt__(self, other):
        if not self.is_same_currency(other):
            raise AmountCurrencyError()
        return round(self.amount, DECIMAL_PRECISION) < round(other, 2)

    def __eq__(self, other):
        if not self.is_same_currency(other):
            raise AmountCurrencyError()
        return round(self.amount, DECIMAL_PRECISION) == round(
            other.amount, DECIMAL_PRECISION)

    def _cast(self, val):
        if type(val) in [int, float]:
            return self.fromNumber(val)
        if isinstance(val, Amount):
            return val
        raise TypeError("cant cast to amount")

    def __add__(self, rother):
        other = self._cast(rother)
        if not self.is_same_currency(other):
            raise AmountCurrencyError()
        return Amount(self.amount + other.amount, self.currency)

    def __sub__(self, rother):
        other = self._cast(rother)
        if not self.is_same_currency(other):
            raise AmountCurrencyError()
        return Amount(self.amount - other.amount, self.currency)

    def __mul__(self, rother):
        other = self._cast(rother)
        if not self.is_same_currency(other):
            raise AmountCurrencyError()
        return Amount(self.amount * other.amount, self.currency)

    def is_same_currency(self, other):
        return self.currency == other.currency

    def truncate_as_string(self, prec):
        parts = str(self.float()).split('.', 1)
        return '%s.%s' % (parts[0], parts[1][0:prec].ljust(prec, '0'))

    def float(self):
        return float(round(self.amount, DECIMAL_PRECISION))


class Quantity:

    def __init__(self, val, code):
        if type(val) not in [float, int]:
            raise ValueError('val expected int or float')
        if code not in codelist.UnidadesMedida:
            raise ValueError("code [%s] not found" % (code))

        self.value = Amount(val)
        self.code = code

    def __mul__(self, other):
        return self.value * other

    def __lt__(self, other):
        return self.value < other

    def __str__(self):
        return str(self.value)

    def __repr__(self):
        return str(self)


@dataclass
class Item:
    scheme_name: str
    scheme_agency_id: str
    scheme_id: str
    description: str
    id: str


class StandardItem(Item):
    def __init__(self, id_: str, description: str = '', name: str = ''):
        super().__init__(id=id_,
                         description=description,
                         scheme_name=name,
                         scheme_id='999',
                         scheme_agency_id='')


class UNSPSCItem(Item):
    def __init__(self, id_: str, description: str = ''):
        super().__init__(id=id_,
                         description=description,
                         scheme_name='UNSPSC',
                         scheme_id='001',
                         scheme_agency_id='10')


@dataclass
class Country:
    code: str
    name: str = ''

    def __post_init__(self):
        if self.code not in codelist.Paises:
            raise ValueError("code [%s] not found" % (self.code))
        self.name = codelist.Paises[self.code]['name']


@dataclass
class CountrySubentity:
    code: str
    name: str = ''

    def __post_init__(self):
        if self.code not in codelist.Departamento:
            raise ValueError("code [%s] not found" % (self.code))
        self.name = codelist.Departamento[self.code]['name']


@dataclass
class City:
    code: str
    name: str = ''

    def __post_init__(self):
        if self.code not in codelist.Municipio:
            raise ValueError("code [%s] not found" % (self.code))
        self.name = codelist.Municipio[self.code]['name']


@dataclass
class PostalZone:
    code: str = ''


@dataclass
class Address:
    name: str
    street: str = ''
    city: City = field(default_factory=lambda: City('05001'))
    country: Country = field(default_factory=lambda: Country('CO'))
    countrysubentity: CountrySubentity = field(
        default_factory=lambda: CountrySubentity('05'))
    postalzone: PostalZone = field(default_factory=lambda: PostalZone(''))


@dataclass
class PartyIdentification:
    number: str
    dv: str
    type_fiscal: str

    def __str__(self):
        return self.number

    def __eq__(self, other):
        return str(self) == str(other)

    def full(self):
        return "%s%s" % [self.number, self.dv]

    def __post_init__(self):
        if self.type_fiscal not in codelist.TipoIdFiscal:
            raise ValueError("type_fiscal [%s] not found" % (self.type_fiscal))


@dataclass
class Responsability:
    codes: list

    def __str__(self):
        return ';'.join(self.codes)

    def __eq__(self, other):
        return str(self) == str(other)

    def __iter__(self):
        return iter(self.codes)

    def __post_init__(self):
        for code in self.codes:
            if code not in codelist.TipoResponsabilidad:
                raise ValueError("code %s not found" % (code))


@dataclass
class TaxScheme:
    code: str
    name: str = ''

    def __post_init__(self):
        if self.code not in codelist.TipoImpuesto:
            raise ValueError("code not found")
        self.name = codelist.TipoImpuesto[self.code]['name']


@dataclass
class Party:
    name: str
    ident: str
    responsability_code: typing.List[Responsability]
    responsability_regime_code: str
    organization_code: str
    tax_scheme: TaxScheme = field(default_factory=lambda: TaxScheme('01'))

    phone: str = ''
    address: Address = field(default_factory=lambda: Address(''))
    email: str = ''
    legal_name: str = ''
    legal_company_ident: str = ''
    legal_address: str = ''

    def __post_init__(self):
        if self.organization_code not in codelist.TipoOrganizacion:
            raise ValueError("organization_code not found")


@dataclass
class TaxScheme:
    code: str = '01'

    @property
    def name(self):
        return codelist.TipoImpuesto[self.code]['name']

    def __post_init__(self):
        if self.code not in codelist.TipoImpuesto:
            raise ValueError("code [%s] not found" % (self.code))


@dataclass
class TaxSubTotal:
    percent: float
    scheme: typing.Optional[TaxScheme] = None
    tax_amount: Amount = field(default_factory=lambda: Amount(0.0))

    def calculate(self, invline):
        if self.percent is not None:
            self.tax_amount = invline.total_amount * Amount(self.percent / 100)


@dataclass
class TaxTotal:
    subtotals: list
    tax_amount: Amount = field(default_factory=lambda: Amount(0.0))
    taxable_amount: Amount = field(default_factory=lambda: Amount(0.0))

    def calculate(self, invline):
        self.taxable_amount = invline.total_amount
        for subtax in self.subtotals:
            subtax.calculate(invline)
            self.tax_amount += subtax.tax_amount


class TaxTotalOmit(TaxTotal):
    def __init__(self):
        super().__init__([])

    def calculate(self, invline):
        pass


@dataclass
class WithholdingTaxSubTotal:
    percent: float
    scheme: typing.Optional[TaxScheme] = None
    tax_amount: Amount = field(default_factory=lambda: Amount(0.0))

    def calculate(self, invline):
        if self.percent is not None:
            self.tax_amount = invline.total_amount * Amount(self.percent / 100)


@dataclass
class WithholdingTaxTotal:
    subtotals: list
    tax_amount: Amount = field(default_factory=lambda: Amount(0.0))
    taxable_amount: Amount = field(default_factory=lambda: Amount(0.0))

    def calculate(self, invline):
        self.taxable_amount = invline.total_amount

        for subtax in self.subtotals:
            subtax.calculate(invline)
            self.tax_amount += subtax.tax_amount


class WithholdingTaxTotalOmit(WithholdingTaxTotal):
    def __init__(self):
        super().__init__([])

    def calculate(self, invline):
        pass


@dataclass
class Price:
    amount: Amount
    type_code: str
    type: str
    quantity: int = 1

    def __post_init__(self):
        if self.type_code not in codelist.CodigoPrecioReferencia:
            raise ValueError("type_code [%s] not found" % (self.type_code))
        if not isinstance(self.quantity, int):
            raise ValueError("quantity must be int")

        self.amount *= self.quantity


@dataclass
class PaymentMean:
    DEBIT = '01'
    CREDIT = '02'

    def __init__(self, id: str, code: str, due_at: datetime, payment_id: str):
        if code not in codelist.MediosPago:
            raise ValueError("code not found")

        self.id = id
        self.code = code
        self.due_at = due_at
        self.payment_id = payment_id


@dataclass
class PrePaidPayment:
    # DIAN 1.7.-2020: FBD03
    paid_amount: Amount = field(default_factory=lambda: Amount(0.0))


@dataclass
class BillingResponse:
    id: str
    code: str
    description: str


class SupportDocumentCreditNoteResponse(BillingResponse):
    """
    ReferenceID: Identifica la sección del Documento
    Soporte original a la cual se aplica la corrección.
    ResponseCode: Código de descripción de la corrección.
    Description: Descripción de la naturaleza de la corrección.
    """


@dataclass
class BillingReference:
    ident: str
    uuid: str
    date: date


class CreditNoteDocumentReference(BillingReference):
    """
    ident: Prefijo + Numero de la factura relacionada
    uuid: CUFE de la factura electronica
    date: fecha de emision de la factura relacionada
    """


class DebitNoteDocumentReference(BillingReference):
    """
    ident: Prefijo + Numero de la factura relacionada
    uuid: CUFE de la factura electronica
    date: fecha de emision de la factura relacionada
    """


class InvoiceDocumentReference(BillingReference):
    """
    ident: Prefijo + Numero de la nota credito relacionada
    uuid: CUDE de la nota credito relacionada
    date: fecha de emision de la nota credito relacionada
    """


@dataclass
class AllowanceChargeReason:
    code: str
    reason: str

    def __post_init__(self):
        if self.code not in codelist.CodigoDescuento:
            raise ValueError("code [%s] not found" % (self.code))


@dataclass
class AllowanceCharge:
    # DIAN 1.7.-2020: FAQ03
    charge_indicator: bool = True
    amount: Amount = field(default_factory=lambda: Amount(0.0))
    reason: AllowanceChargeReason = None

    # Valor Base para calcular el descuento o el cargo
    base_amount: typing.Optional[Amount] = field(
        default_factory=lambda: Amount(0.0))

    # Porcentaje: Porcentaje que aplicar.
    multiplier_factor_numeric: Amount = field(
        default_factory=lambda: Amount(1.0))

    def isCharge(self):
        charge_indicator = self.charge_indicator is True
        return charge_indicator

    def isDiscount(self):
        charge_indicator = self.charge_indicator is False
        return charge_indicator

    def asCharge(self):
        self.charge_indicator = True

    def asDiscount(self):
        self.charge_indicator = False

    def hasReason(self):
        return self.reason is not None

    def set_base_amount(self, amount):
        self.base_amount = amount


class AllowanceChargeAsDiscount(AllowanceCharge):
    def __init__(self, amount: Amount = Amount(0.0)):
        self.charge_indicator = False
        self.amount = amount


@dataclass
class InvoiceLine:
    # RESOLUCION 0004: pagina 155
    quantity: Quantity
    description: str
    item: Item
    price: Price
    # TODO mover a Invoice
    # ya que al reportar los totales es sobre
    # la factura y el percent es unico por type_code
    # de subtotal
    tax: typing.Optional[TaxTotal]
    withholding: typing.Optional[WithholdingTaxTotal]
    allowance_charge: typing.List[AllowanceCharge] = dataclasses.field(
        default_factory=list)

    def add_allowance_charge(self, charge):
        if not isinstance(charge, AllowanceCharge):
            raise TypeError('charge invalid type expected AllowanceCharge')
        charge.set_base_amount(self.total_amount_without_charge)
        self.allowance_charge.add(charge)

    @property
    def total_amount_without_charge(self):
        return (self.quantity * self.price.amount)

    @property
    def total_amount(self):
        charge = AmountCollection(self.allowance_charge)\
            .filter(lambda charge: charge.isCharge())\
            .map(lambda charge: charge.amount)\
            .sum()

        discount = AmountCollection(self.allowance_charge)\
            .filter(lambda charge: charge.isDiscount())\
            .map(lambda charge: charge.amount)\
            .sum()

        return self.total_amount_without_charge + charge - discount

    @property
    def total_tax_inclusive_amount(self):
        # FAU06
        return self.total_amount + self.tax.tax_amount

    @property
    def total_tax_exclusive_amount(self):
        return self.tax.taxable_amount

    @property
    def tax_amount(self):
        return self.tax.tax_amount

    @property
    def taxable_amount(self):
        return self.tax.taxable_amount

    @property
    def withholding_amount(self):
        return self.withholding.tax_amount

    @property
    def withholding_taxable_amount(self):
        return self.withholding.taxable_amount

    def calculate(self):
        self.tax.calculate(self)
        self.withholding.calculate(self)

    def __post_init__(self):
        if not isinstance(self.quantity, Quantity):
            raise ValueError("quantity must be Amount")

        if self.tax is None:
            self.tax = TaxTotalOmit()

        if self.withholding is None:
            self.withholding = WithholdingTaxTotalOmit()


@dataclass
class LegalMonetaryTotal:
    line_extension_amount: Amount = field(default_factory=lambda: Amount(0.0))
    tax_exclusive_amount: Amount = field(default_factory=lambda: Amount(0.0))
    tax_inclusive_amount: Amount = field(default_factory=lambda: Amount(0.0))
    charge_total_amount: Amount = field(default_factory=lambda: Amount(0.0))
    allowance_total_amount: Amount = field(default_factory=lambda: Amount(0.0))
    payable_amount: Amount = field(default_factory=lambda: Amount(0.0))
    prepaid_amount: Amount = field(default_factory=lambda: Amount(0.0))

    def calculate(self):
        # DIAN 1.7.-2020: FAU14
        self.payable_amount = \
            self.tax_inclusive_amount \
            + self.allowance_total_amount \
            + self.charge_total_amount \
            - self.prepaid_amount


class NationalSalesInvoiceDocumentType(str):
    def __str__(self):
        # 6.1.3
        return '01'


class CreditNoteDocumentType(str):
    def __str__(self):
        # 6.1.3
        return '91'


class DebitNoteDocumentType(str):
    def __str__(self):
        # 6.1.3
        return '92'


class CreditNoteSupportDocumentType(str):
    def __str__(self):
        return '95'


class Invoice:
    def __init__(self, type_code: str):
        if str(type_code) not in codelist.TipoDocumento:
            raise ValueError("type_code [%s] not found")

        self.invoice_period_start = None
        self.invoice_period_end = None
        self.invoice_issue = None
        self.invoice_ident = None
        self.invoice_operation_type = None
        self.invoice_legal_monetary_total = LegalMonetaryTotal()
        self.invoice_customer = None
        self.invoice_supplier = None
        self.invoice_payment_mean = None
        self.invoice_payments = []
        self.invoice_lines = []
        self.invoice_allowance_charge = []
        self.invoice_prepaid_payment = []
        self.invoice_billing_reference = None
        self.invoice_discrepancy_response = None
        self.invoice_type_code = str(type_code)
        self.invoice_ident_prefix = None

    def set_period(self, startdate, enddate):
        self.invoice_period_start = startdate
        self.invoice_period_end = enddate

    def set_issue(self, dtime: datetime):
        if dtime.tzname() not in ['UTC-05:00', '-05', None]:
            raise ValueError("dtime must be UTC-05:00")

        self.invoice_issue = dtime

    def _set_ident_prefix_automatic(self):
        if not self.invoice_ident_prefix:
            prefix = ''
            for idx, val in enumerate(self.invoice_ident):
                if val.isalpha():
                    prefix += val
                else:
                    break

            if len(prefix) <= 4:
                self.invoice_ident_prefix = prefix
            else:
                raise ValueError(
                    'ident prefix failed to get, expected 0  to 4 chars')

    def set_ident(self, ident: str):
        """
        identificador de factura; prefijo + consecutivo
        """
        self.invoice_ident = ident
        self._set_ident_prefix_automatic()

    def _check_ident_prefix(self, prefix):
        if len(prefix) != 4:
            raise ValueError('prefix must be 4 length')

    def set_ident_prefix(self, prefix: str):
        """
        prefijo de facturacion: ejemplo SETP
        """
        self._check_ident_prefix(prefix)
        self.invoice_ident_prefix = prefix

    def set_supplier(self, party: Party):
        self.invoice_supplier = party

    def set_customer(self, party: Party):
        self.invoice_customer = party

    def set_payment_mean(self, payment_mean: PaymentMean):
        self.invoice_payment_mean = payment_mean

    def _get_codelist_tipo_operacion(self):
        return codelist.TipoOperacionF

    def set_operation_type(self, operation):
        if operation not in self._get_codelist_tipo_operacion():
            raise ValueError("operation not found")

        self.invoice_operation_type = operation

    def add_allowance_charge(self, charge: AllowanceCharge):
        self.invoice_allowance_charge.append(charge)

    def add_invoice_line(self, line: InvoiceLine):
        self.invoice_lines.append(line)

    def add_prepaid_payment(self, paid: PrePaidPayment):
        self.invoice_prepaid_payment.append(paid)

    def set_billing_reference(self, billing_reference: BillingReference):
        self.invoice_billing_reference = billing_reference

    def set_discrepancy_response(self, billing_response: BillingResponse):
        self.invoice_discrepancy_response = billing_response

    def accept(self, visitor):
        visitor.visit_payment_mean(self.invoice_payment_mean)
        visitor.visit_customer(self.invoice_customer)
        visitor.visit_supplier(self.invoice_supplier)
        for payment in self.invoice_payments:
            visitor.visit_payment(payment)
        for invline in self.invoice_lines:
            visitor.visit_invoice_line(invline)

    def _calculate_legal_monetary_total(self):
        for invline in self.invoice_lines:
            self.invoice_legal_monetary_total.line_extension_amount +=\
                invline.total_amount
            self.invoice_legal_monetary_total.tax_exclusive_amount +=\
                invline.total_tax_exclusive_amount
            # DIAN 1.7.-2020: FAU6
            self.invoice_legal_monetary_total.tax_inclusive_amount +=\
                invline.total_tax_inclusive_amount

        # DIAN 1.7.-2020: FAU08
        self.invoice_legal_monetary_total.allowance_total_amount =\
            AmountCollection(self.invoice_allowance_charge)\
            .filter(lambda charge: charge.isDiscount())\
            .map(lambda charge: charge.amount)\
            .sum()

        # DIAN 1.7.-2020: FAU10
        self.invoice_legal_monetary_total.charge_total_amount =\
            AmountCollection(self.invoice_allowance_charge)\
            .filter(lambda charge: charge.isCharge())\
            .map(lambda charge: charge.amount)\
            .sum()

        # DIAN 1.7.-2020: FAU12
        self.invoice_legal_monetary_total.prepaid_amount = AmountCollection(
            self.invoice_prepaid_payment).map(
                lambda paid: paid.paid_amount).sum()

        # DIAN 1.7.-2020: FAU14
        self.invoice_legal_monetary_total.calculate()

    def _refresh_charges_base_amount(self):
        if self.invoice_allowance_charge:
            for invline in self.invoice_lines:
                if invline.allowance_charge:
                    # TODO actualmente solo uno de los cargos es permitido
                    raise ValueError(
                        'allowance charge in invoice exclude invoice line')

        # cargos a nivel de factura
        for charge in self.invoice_allowance_charge:
            charge.set_base_amount(
                self.invoice_legal_monetary_total.line_extension_amount)

    def calculate(self):
        for invline in self.invoice_lines:
            invline.calculate()
        self._calculate_legal_monetary_total()
        self._refresh_charges_base_amount()


class NationalSalesInvoice(Invoice):
    def __init__(self):
        super().__init__(NationalSalesInvoiceDocumentType())


class CreditNote(Invoice):
    def __init__(self, invoice_document_reference: BillingReference):
        super().__init__(CreditNoteDocumentType())

        if not isinstance(invoice_document_reference, BillingReference):
            raise TypeError('invoice_document_reference invalid type')
        self.invoice_billing_reference = invoice_document_reference

    def _get_codelist_tipo_operacion(self):
        return codelist.TipoOperacionNC

    def _check_ident_prefix(self, prefix):
        if len(prefix) != 6:
            raise ValueError('prefix must be 6 length')

    def _set_ident_prefix_automatic(self):
        if not self.invoice_ident_prefix:
            self.invoice_ident_prefix = self.invoice_ident[0:6]


class DebitNote(Invoice):
    def __init__(self, invoice_document_reference: BillingReference):
        super().__init__(DebitNoteDocumentType())

        if not isinstance(invoice_document_reference, BillingReference):
            raise TypeError('invoice_document_reference invalid type')
        self.invoice_billing_reference = invoice_document_reference

    def _get_codelist_tipo_operacion(self):
        return codelist.TipoOperacionND

    def _check_ident_prefix(self, prefix):
        if len(prefix) != 6:
            raise ValueError('prefix must be 6 length')

    def _set_ident_prefix_automatic(self):
        if not self.invoice_ident_prefix:
            self.invoice_ident_prefix = self.invoice_ident[0:6]


class SupportDocument(Invoice):
    pass


class SupportDocumentCreditNote(SupportDocument):
    def __init__(
            self, invoice_document_reference: BillingReference,
            invoice_discrepancy_response: BillingResponse):
        super().__init__(CreditNoteSupportDocumentType())

        if not isinstance(invoice_document_reference, BillingReference):
            raise TypeError('invoice_document_reference invalid type')
        self.invoice_billing_reference = invoice_document_reference
        self.invoice_discrepancy_response = invoice_discrepancy_response

    def _get_codelist_tipo_operacion(self):
        return codelist.TipoOperacionNCDS

    def _check_ident_prefix(self, prefix):
        if len(prefix) != 6:
            raise ValueError('prefix must be 6 length')

    def _set_ident_prefix_automatic(self):
        if not self.invoice_ident_prefix:
            self.invoice_ident_prefix = self.invoice_ident[0:6]
    pass