# -*- coding: utf-8 -*-
# The COPYRIGHT file at the top level of this repository contains the full
# copyright notices and license terms.
import glob
import logging
import os
import re
import unicodedata
from decimal import Decimal
from jinja2 import Environment, FileSystemLoader
from lxml import etree
from operator import attrgetter
from subprocess import Popen, PIPE
from tempfile import NamedTemporaryFile

from trytond.model import ModelView, fields
from trytond.pool import Pool, PoolMeta
from trytond.pyson import Bool, Eval
from trytond.transaction import Transaction
from trytond.wizard import Wizard, StateView, StateTransition, Button
from trytond import backend

__all__ = ['Invoice', 'InvoiceLine', 'CreditInvoiceStart', 'CreditInvoice',
    'GenerateFacturaeStart', 'GenerateFacturae']

# Get from XSD scheme of Facturae 3.2.1
# http://www.facturae.gob.es/formato/Versiones/Facturaev3_2_1.xml
RECTIFICATIVE_REASON_CODES = [
    ("01", "Invoice number", "Número de la factura"),
    ("02", "Invoice serial number", "Serie de la factura"),
    ("03", "Issue date", "Fecha expedición"),
    ("04", "Name and surnames/Corporate name-Issuer (Sender)",
        "Nombre y apellidos/Razón Social-Emisor"),
    ("05", "Name and surnames/Corporate name-Receiver",
        "Nombre y apellidos/Razón Social-Receptor"),
    ("06", "Issuer's Tax Identification Number",
        "Identificación fiscal Emisor/obligado"),
    ("07", "Receiver's Tax Identification Number",
        "Identificación fiscal Receptor"),
    ("08", "Issuer's address", "Domicilio Emisor/Obligado"),
    ("09", "Receiver's address", "Domicilio Receptor"),
    ("10", "Item line", "Detalle Operación"),
    ("11", "Applicable Tax Rate", "Porcentaje impositivo a aplicar"),
    ("12", "Applicable Tax Amount", "Cuota tributaria a aplicar"),
    ("13", "Applicable Date/Period", "Fecha/Periodo a aplicar"),
    ("14", "Invoice Class", "Clase de factura"),
    ("15", "Legal literals", "Literales legales"),
    ("16", "Taxable Base", "Base imponible"),
    ("80", "Calculation of tax outputs", "Cálculo de cuotas repercutidas"),
    ("81", "Calculation of tax inputs", "Cálculo de cuotas retenidas"),
    ("82",
        "Taxable Base modified due to return of packages and packaging "
        "materials",
        "Base imponible modificada por devolución de envases / embalajes"),
    ("83", "Taxable Base modified due to discounts and rebates",
        "Base imponible modificada por descuentos y bonificaciones"),
    ("84",
        "Taxable Base modified due to firm court ruling or administrative "
        "decision",
        "Base imponible modificada por resolución firme, judicial o "
        "administrativa"),
    ("85",
        "Taxable Base modified due to unpaid outputs where there is a "
        "judgement opening insolvency proceedings",
        "Base imponible modificada cuotas repercutidas no satisfechas. Auto "
        "de declaración de concurso"),
    ]
# UoM Type from UN/CEFACT
UOM_CODE2TYPE = {
    'u': '01',
    'h': '02',
    'kg': '03',
    'g': '21',
    's': '34',
    'm': '25',
    'km': '22',
    'cm': '16',
    'mm': '26',
    'm³': '33',
    'l': '04',
    }
# Missing types in product/uom.xml
# "06", Boxes-BX
# "07", Trays, one layer no cover, plastic-DS
# "08", Barrels-BA
# "09", Jerricans, cylindrical-JY
# "10", Bags-BG
# "11", Carboys, non-protected-CO
# "12", Bottles, non-protected, cylindrical-BO
# "13", Canisters-CI
# "14", Tetra Briks
# "15", Centiliters-CLT
# "17", Bins-BI
# "18", Dozens
# "19", Cases-CS
# "20", Demijohns, non-protected-DJ
# "23", Cans, rectangular-CA
# "24", Bunches-BH
# "27", 6-Packs
# "28", Packages-PK
# "29", Portions
# "30", Rolls-RO
# "31", Envelopes-EN
# "32", Tubs-TB
# "35", Watt-WTT
FACe_REQUIRED_FIELDS = ['facturae_person_type', 'facturae_residence_type']

_slugify_strip_re = re.compile(r'[^\w\s-]')
_slugify_hyphenate_re = re.compile(r'[-\s]+')


def slugify(value):
    if not isinstance(value, str):
        value = str(value)
    value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore')
    value = str(_slugify_strip_re.sub('', value).strip().lower())
    return _slugify_hyphenate_re.sub('-', value)


def module_path():
    return os.path.dirname(os.path.abspath(__file__))


class Invoice(metaclass=PoolMeta):
    __name__ = 'account.invoice'
    credited_invoices = fields.Function(fields.One2Many('account.invoice',
            None, 'Credited Invoices'),
        'get_credited_invoices', searcher='search_credited_invoices')
    rectificative_reason_code = fields.Selection(
        [(None, "")] + [(x[0], x[1]) for x in RECTIFICATIVE_REASON_CODES],
        'Rectificative Reason Code', sort=False,
        states={
            'invisible': ~Bool(Eval('credited_invoices')),
            'required': (Bool(Eval('credited_invoices'))
                & (Eval('state').in_(['posted', 'paid']))),
            }, depends=['credited_invoices'])
    invoice_facturae = fields.Binary('Factura-e',
        filename='invoice_facturae_filename', readonly=True)
    invoice_facturae_filename = fields.Function(fields.Char(
        'Factura-e filename'), 'get_invoice_facturae_filename')

    @classmethod
    def __setup__(cls):
        super(Invoice, cls).__setup__()
        cls._check_modify_exclude.append('invoice_facturae')
        cls._buttons.update({
                'generate_facturae_wizard': {
                    'invisible': ((Eval('type') != 'out')
                        | ~Eval('state').in_(['posted', 'paid'])),
                    'readonly': Bool(Eval('invoice_facturae')),
                    }
                })
        cls._error_messages.update({
                'missing_certificate': (
                    'Missing Factura-e Certificate in company "%s".'),
                'company_vat_identifier': (
                    'Missing VAT Identifier in company\'s Party "%s", or its '
                    'length is not between 3 and 30.'),
                'company_address_fields': (
                    'Missing Street, Zip, City, Subdivision or Country in '
                    'default address of company\'s Party "%s".'),
                'party_facturae_fields': (
                    'Missing some Factura-e fields in party "%(party)s" of '
                    'invoice "%(invoice)s": "%(field)s"'),
                'party_vat_identifier': (
                    'Missing VAT Identifier in party "%(party)s" of invoice '
                    '"%(invoice)s", or its length is not between 3 and 30.'),
                'party_name_surname': (
                    'The name of "%(party)s" of invoice "%(invoice)s" '
                    'doesn\'t contain the Name and the, at least, First '
                    'Surname.\n'
                    'They must to be separated by one space: Name Surname.'),
                'invoice_address_fields': (
                    'Missing Street, Zip, City, Subdivision or Country in '
                    'Invoice Address of invoice "%s".'),
                'no_rate': ('No rate found for currency "%(currency)s" on '
                    '"%(date)s"'),
                'missing_payment_type': ('The payment type is missing in some '
                    'move lines of invoice "%s".'),
                'missing_payment_type_facturae_type': (
                    'The Factura-e Type is missing in payment type '
                    '"%(payment_type)s" used in invoice "%(invoice)s".'),
                'missing_account_bank_module': (
                    'You must to install "account_bank" module to inform the '
                    'Bank Account in invoices.\n'
                    'The payment type "%(payment_type)s" used in invoice '
                    '"%(invoice)s" is configured as "Direct Debit" or '
                    '"Credit Transfer" and it requires the company/party bank '
                    'account.'),
                'missing_bank_account': ('The Bank Account is missing in some '
                    'move lines of invoice "%s".'),
                'missing_iban': ('The Bank Account "%(bank_account)s" used in '
                    'invoice "%(invoice)s" doesn\'t have an IBAN number and '
                    'it\'s required to generate the Factura-e document.'),
                'invalid_factura_xml_file': (
                    'The Factura-e file (XML) generated for invoice "%s" is '
                    'not valid against the oficial XML Schema Definition:\n%s'),
                'error_signing': ('Error signing invoice "%(invoice)s".\n'
                    'Message returned by signing process: %(process_output)s'),
                })

    def get_credited_invoices(self, name):
        pool = Pool()
        InvoiceLine = pool.get('account.invoice.line')
        invoices = set()
        for line in self.lines:
            if isinstance(line.origin, InvoiceLine) and line.origin.invoice:
                invoices.add(line.origin.invoice.id)
        return list(invoices)

    @classmethod
    def search_credited_invoices(cls, name, clause):
        return [('lines.origin.invoice',) + tuple(clause[1:3])
            + ('account.invoice.line',) + tuple(clause[3:])]

    def get_invoice_facturae_filename(self, name):
        return 'facturae-%s.xsig' % slugify(self.number)

    @property
    def rectificative_reason_spanish_description(self):
        if self.rectificative_reason_code:
            for code, _, spanish_description in RECTIFICATIVE_REASON_CODES:
                if code == self.rectificative_reason_code:
                    return spanish_description

    @property
    def taxes_outputs(self):
        """Return list of 'impuestos repecutidos'"""
        return [inv_tax for inv_tax in self.taxes
            if inv_tax.tax and inv_tax.tax.rate >= Decimal(0)]

    @property
    def taxes_withheld(self):
        """Return list of 'impuestos retenidos'"""
        return [inv_tax for inv_tax in self.taxes
            if inv_tax.tax and inv_tax.tax.rate < Decimal(0)]

    @property
    def payment_details(self):
        return sorted([ml for ml in self.move.lines
                if ml.account.kind == 'receivable'],
            key=attrgetter('maturity_date'))

    def _credit(self):
        invoice_vals = super(Invoice, self)._credit()
        rectificative_reason_code = Transaction().context.get(
            'rectificative_reason_code')
        if rectificative_reason_code:
            invoice_vals['rectificative_reason_code'] = (
                rectificative_reason_code)
        return invoice_vals

    @classmethod
    @ModelView.button_action(
        'account_invoice_facturae.wizard_generate_signed_facturae')
    def generate_facturae_wizard(cls, invoices):
        pass

    @classmethod
    def generate_facturae_default(cls, invoices, certificate_password):
        to_save = []
        for invoice in invoices:
            if invoice.invoice_facturae:
                continue
            facturae_content = invoice.get_facturae()
            invoice._validate_facturae(facturae_content)
            if backend.name() != 'sqlite':
                invoice.invoice_facturae = invoice._sign_facturae(
                    facturae_content, certificate_password)
            to_save.append(invoice)
        if to_save:
            cls.save(to_save)

    def get_facturae(self):
        """Return the content of factura-e XML file"""
        pool = Pool()
        Currency = pool.get('currency.currency')
        Date = pool.get('ir.date')
        Rate = pool.get('currency.currency.rate')

        if self.type != 'out':
            return
        if self.state not in ('posted', 'paid'):
            return

        # These are an assert because it shouldn't happen
        assert self.invoice_date <= Date.today(), (
            "Invoice date of invoice %s is in the future" % self.id)
        assert len(self.credited_invoices) < 2, (
            "Too much credited invoices for invoice %s" % self.id)
        assert not self.credited_invoices or self.rectificative_reason_code, (
            "Missing rectificative_reason_code for invoice %s with credited "
            "invoices" % self.id)
        assert len(self.taxes_outputs) > 0, (
            "Missing some tax in invoice %s" % self.id)

        for field in FACe_REQUIRED_FIELDS:
            for party in [self.party, self.company.party]:
                if not getattr(party, field):
                    self.raise_user_error('party_facturae_fields', {
                            'party': party.rec_name,
                            'invoice': self.rec_name,
                            'field': field,
                            })
        if (not self.company.party.tax_identifier
                or len(self.company.party.tax_identifier.code) < 3
                or len(self.company.party.tax_identifier.code) > 30):
            self.raise_user_error('company_vat_identifier',
                (self.company.party.rec_name,))

        if (not self.company.party.addresses
                or not self.company.party.addresses[0].street
                or not self.company.party.addresses[0].zip
                or not self.company.party.addresses[0].city
                or not self.company.party.addresses[0].subdivision
                or not self.company.party.addresses[0].country):
            self.raise_user_error('company_address_fields',
                (self.company.party.rec_name,))

        if (not self.party.tax_identifier
                or len(self.party.tax_identifier.code) < 3
                or len(self.party.tax_identifier.code) > 30):
            self.raise_user_error('party_vat_identifier', {
                    'party': self.party.rec_name,
                    'invoice': self.rec_name,
                    })
        if (self.party.facturae_person_type == 'F'
                and len(self.party.name.split(' ', 2)) < 2):
            self.raise_user_error('party_name_surname', {
                    'party': self.party.rec_name,
                    'invoice': self.rec_name,
                    })
        if (not self.invoice_address.street
                or not self.invoice_address.zip
                or not self.invoice_address.city
                or not self.invoice_address.subdivision
                or not self.invoice_address.country):
            self.raise_user_error('invoice_address_fields', (self.rec_name,))

        euro, = Currency.search([('code', '=', 'EUR')])
        if self.currency != euro:
            assert (euro.rate == Decimal(1)
                or self.currency.rate == Decimal(1)), (
                "Euro currency or the currency of invoice %s must to be the "
                "base currency" % self.id)
            if euro.rate == Decimal(1):
                rates = Rate.search([
                        ('currency', '=', self.currency),
                        ('date', '<=', self.invoice_date),
                        ], limit=1, order=[('date', 'DESC')])
                if not rates:
                    self.raise_user_error('no_rate', {
                            'currency': self.currenc.name,
                            'date': self.invoice_date.strftime('%d/%m/%Y'),
                            })
                exchange_rate = rates[0].rate
                exchange_rate_date = rates[0].date
            else:
                rates = Rate.search([
                        ('currency', '=', euro),
                        ('date', '<=', self.invoice_date),
                        ], limit=1, order=[('date', 'DESC')])
                if not rates:
                    self.raise_user_error('no_rate', {
                            'currency': euro.name,
                            'date': self.invoice_date.strftime('%d/%m/%Y'),
                            })
                exchange_rate = Decimal(1) / rates[0].rate
                exchange_rate_date = rates[0].date
        else:
            exchange_rate = exchange_rate_date = None

        for invoice_tax in self.taxes:
            assert invoice_tax.tax, 'Empty tax in invoice %s' % self.id
            assert (invoice_tax.tax.type == 'percentage'), (
                'Unsupported non percentage tax %s of invoice %s'
                % (invoice_tax.tax.id, self.id))

        for move_line in self.payment_details:
            if not move_line.payment_type:
                self.raise_user_error('missing_payment_type', (self.rec_name,))
            if not move_line.payment_type.facturae_type:
                self.raise_user_error('missing_payment_type_facturae_type', {
                        'payment_type': move_line.payment_type.rec_name,
                        'invoice': self.rec_name,
                        })
            if move_line.payment_type.facturae_type in ('02', '04'):
                if not hasattr(move_line, 'account_bank'):
                    self.raise_user_error('missing_account_bank_module', {
                        'payment_type': move_line.payment_type.rec_name,
                        'invoice': self.rec_name,
                        })
                if not move_line.bank_account:
                    self.raise_user_error('missing_bank_account',
                        (self.rec_name,))
                if not [n for n in move_line.bank_account.numbers
                        if n.type == 'iban']:
                    self.raise_user_error('missing_iban', {
                        'bank_account': move_line.bank_account.rec_name,
                        'invoice': self.rec_name,
                        })

        jinja_env = Environment(
            loader=FileSystemLoader(module_path()),
            trim_blocks=True,
            lstrip_blocks=True,
            )
        jinja_template = jinja_env.get_template('template_facturae_3.2.1.xml')

        return jinja_template.render({
                'invoice': self,
                'Decimal': Decimal,
        		'Currency': Currency,
                'euro': euro,
                'exchange_rate': exchange_rate,
                'exchange_rate_date': exchange_rate_date,
                'UOM_CODE2TYPE': UOM_CODE2TYPE,
                }, ).encode('utf-8')

    def _validate_facturae(self, xml_string):
        """
        Inspired by https://github.com/pedrobaeza/l10n-spain/blob/d01d049934db55130471e284012be7c860d987eb/l10n_es_facturae/wizard/create_facturae.py
        """
        logger = logging.getLogger('account_invoice_facturae')

        schema_file_path = os.path.join(
            module_path(),
            'Facturaev3_2_1-offline.xsd')
        with open(schema_file_path) as schema_file:
            facturae_schema = etree.XMLSchema(file=schema_file)
            logger.debug("Schema Facturaev3_2_1-offline.xsd loaded")

        try:
            facturae_schema.assertValid(etree.fromstring(xml_string))
            logger.debug("Factura-e XML of invoice %s validated",
                self.rec_name)
        except Exception as e:
            logger.warning("Error validating generated Factura-e file",
                exc_info=True)
            logger.debug(xml_string)
            self.raise_user_error('invalid_factura_xml_file', (self.rec_name, e))
        return True

    def _sign_facturae(self, xml_string, certificate_password):
        """
        Inspired by https://github.com/pedrobaeza/l10n-spain/blob/d01d049934db55130471e284012be7c860d987eb/l10n_es_facturae/wizard/create_facturae.py
        """
        if not self.company.facturae_certificate:
            self.raise_user_error('missing_certificate',
                (self.company.rec_name,))

        logger = logging.getLogger('account_invoice_facturae')

        unsigned_file = NamedTemporaryFile(suffix='.xml', delete=False)
        unsigned_file.write(xml_string)
        unsigned_file.close()

        cert_file = NamedTemporaryFile(suffix='.pfx', delete=False)
        cert_file.write(self.company.facturae_certificate)
        cert_file.close()

        signed_file = NamedTemporaryFile(suffix='.xsig', delete=False)

        env = {}
        env.update(os.environ)
        libs = os.path.join(module_path(), 'java', 'lib', '*.jar')
        env['CLASSPATH'] = ':'.join(glob.glob(libs))

        # TODO: implement Signer with python
        # http://www.pyopenssl.org/en/stable/api/crypto.html#OpenSSL.crypto.load_pkcs12
        signature_command = [
            'java',
            '-Djava.awt.headless=true',
            'com.nantic.facturae.Signer',
            '0',
            unsigned_file.name,
            signed_file.name,
            'facturae31',
            cert_file.name,
            certificate_password
            ]
        signature_process = Popen(signature_command,
            stdout=PIPE,
            stderr=PIPE,
            env=env,
            cwd=os.path.join(module_path(), 'java'))
        output, err = signature_process.communicate()
        rc = signature_process.returncode
        if rc != 0:
            logger.warning('Error %s signing invoice "%s" with command '
                '"%s <password>": %s %s', rc, self.id,
                signature_command[:-1], output, err)
            self.raise_user_error('error_signing', {
                    'invoice': self.rec_name,
                    'process_output': output,
                    })
        logger.info("Factura-e for invoice %s (%s) generated and signed",
            self.rec_name, self.id)

        signed_file_content = signed_file.read()
        signed_file.close()

        os.unlink(unsigned_file.name)
        os.unlink(cert_file.name)
        os.unlink(signed_file.name)

        return signed_file_content


class InvoiceLine(metaclass=PoolMeta):
    __name__ = 'account.invoice.line'

    @property
    def taxes_outputs(self):
        """Return list of 'impuestos repecutidos'"""
        return [inv_tax for inv_tax in self.invoice_taxes
            if inv_tax.tax and inv_tax.tax.rate >= Decimal(0)]

    @property
    def taxes_withheld(self):
        """Return list of 'impuestos retenidos'"""
        return [inv_tax for inv_tax in self.invoice_taxes
            if inv_tax.tax and inv_tax.tax.rate < Decimal(0)]

    @property
    def taxes_additional_line_item_information(self):
        res = {}
        for inv_tax in self.invoice_taxes:
            if inv_tax.tax and (not inv_tax.tax.report_type
                    or inv_tax.tax.report_type == '05'):
                key = (inv_tax.tax.rate * 100, inv_tax.base, inv_tax.amount)
                res.setdefault('05', []).append((key, inv_tax.description))
            elif inv_tax.tax and inv_tax.tax.report_description:
                res[inv_tax.tax.report_type] = inv_tax.tax.report_description
        if '05' in res:
            if len(res['05']) == 1:
                res['05'] = res['05'][0]
            else:
                for key, tax_description in res['05']:
                    res['05 %s %s %s' % key] = tax_description
                del res['05']
        return res


class CreditInvoiceStart(metaclass=PoolMeta):
    __name__ = 'account.invoice.credit.start'
    rectificative_reason_code = fields.Selection(
        [(x[0], x[1]) for x in RECTIFICATIVE_REASON_CODES],
        'Rectificative Reason Code', required=True, sort=False)


class CreditInvoice(metaclass=PoolMeta):
    __name__ = 'account.invoice.credit'

    def do_credit(self, action):
        with Transaction().set_context(
                rectificative_reason_code=self.start.rectificative_reason_code
                ):
            return super(CreditInvoice, self).do_credit(action)


class GenerateFacturaeStart(ModelView):
    'Generate Factura-e file - Start'
    __name__ = 'account.invoice.generate_facturae.start'
    service = fields.Selection([
        ('default', 'Default'),
        ], 'Service', required=True)
    certificate_password = fields.Char('Certificate Password',
        states={
            'required': Eval('service') == 'default',
            'invisible': Eval('service') != 'default',
        }, depends=['service'])

    @staticmethod
    def default_service():
        return 'default'


class GenerateFacturae(Wizard):
    'Generate Factura-e file'
    __name__ = 'account.invoice.generate_facturae'
    start = StateView('account.invoice.generate_facturae.start',
        'account_invoice_facturae.generate_facturae_start_view_form', [
            Button('Cancel', 'end', 'tryton-cancel'),
            Button('Generate', 'generate', 'tryton-executable', default=True),
            ])
    generate = StateTransition()

    def transition_generate(self):
        Invoice = Pool().get('account.invoice')

        invoices = Invoice.browse(Transaction().context['active_ids'])
        service = 'generate_facturae_%s' % self.start.service
        getattr(Invoice, service)(invoices, self.start.certificate_password)
        return 'end'