# © 2021 Le Filament (<http://www.le-filament.com>)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import base64

from odoo import models, api
from odoo import fields as odooFields
from odoo.addons.cmis_field import fields
from odoo.exceptions import UserError


class ScopAlfrescoAdhesionPartner(models.Model):
    _inherit = 'res.partner'

    alfresco_invoice_adhesion_file = odooFields.Char("Facture d'adhésion")
    alfresco_report_adhesion_file = odooFields.Char("Courrier d'adhésion")
    adhesion_cmis_folder = fields.CmisFolder(
        allow_create=True,
        allow_delete=False,
    )

    # ------------------------------------------------------
    # Actions
    # ------------------------------------------------------
    @api.multi
    def generate_alfresco_file(self, invoice_id):
        """
            Ajoute un fichier sur la GED Alfresco
            @return: fonction get_partner_files() de res.partner
        """
        # Get proof folder nodeRef
        backend = self.env['cmis.backend'].search([], limit=1)

        # Create folder adhesion if needed
        self._create_folder_adhesion(backend)
        path_proj = backend.get_cmis_repository(). \
            getFolder(self.adhesion_cmis_folder).getPaths()

        path_n0 = path_proj
        path = '/'.join(path_n0)
        cmis_obj = backend.get_folder_by_path(path)

        ###
        # Invoice adhesion attachment
        invoice_adhesion = self.env['account.invoice'].browse(invoice_id)
        invoice_adhesion = self.env.ref('account.account_invoices').\
            render_qweb_pdf(invoice_adhesion.id)[0]
        invoice_adhesion = base64.b64encode(invoice_adhesion)

        name = 'Facture adhésion'

        invoice_adhesion_attachment = self.env['ir.attachment'].create({
            'name': name,
            'type': 'binary',
            'datas': invoice_adhesion,
            'datas_fname': name + '.pdf',
            'store_fname': name,
            'res_model': self._name,
            'res_id': self.id,
            'mimetype': 'application/pdf'
        })
        if not invoice_adhesion_attachment:
            raise UserError(
                "Erreur lors de la génération de la facture pour Alfresco")

        content_type = invoice_adhesion_attachment.mimetype

        file_invoice_adhesion = cmis_obj.createDocument(
            name=invoice_adhesion_attachment.name,
            properties={},
            contentFile=base64.b64decode(invoice_adhesion_attachment.datas),
            contentType=content_type
        )
        self.alfresco_invoice_adhesion_file = \
            file_invoice_adhesion.getObjectId()

        ###
        # Report adhesion attachment
        report_adhesion = self.env.ref(
            'cgscop_adhesion.cgscop_adhesion_report'). \
            render_qweb_pdf(self.id)[0]
        report_adhesion = base64.b64encode(report_adhesion)

        name = "Courrier ahdésion"

        report_adhesion_attachment = self.env['ir.attachment'].create({
            'name': name,
            'type': 'binary',
            'datas': report_adhesion,
            'datas_fname': name + '.pdf',
            'store_fname': name,
            'res_model': self._name,
            'res_id': self.id,
            'mimetype': 'application/pdf'
        })
        if not report_adhesion_attachment:
            raise UserError(
                "Erreur lors de la génération du courrier d'adhésion "
                "pour Alfresco")

        content_type = report_adhesion_attachment.mimetype

        file_report_adhesion = cmis_obj.createDocument(
            name=report_adhesion_attachment.name,
            properties={},
            contentFile=base64.b64decode(report_adhesion_attachment.datas),
            contentType=content_type
        )
        self.alfresco_report_adhesion_file = \
            file_report_adhesion.getObjectId()

    # ------------------------------------------------------
    # Override Alfodoo
    # ------------------------------------------------------
    def _create_folder_adhesion(self, backend):
        """
        Récupère ou crée le répertoire Adhésions s'il n'existe pas
        :param records: lm records
        :param backend: lm backend
        :return: lm_cmis_folder objectId
        """
        # Check de si le répertoire existe
        for partner in self:
            # Si le répertoire parent n'existe pas on le crée
            if not partner.partner_cmis_folder:
                partner.create_cmis_folder()
            # Récupération du path parent
            parent_path = backend.get_cmis_repository().\
                getFolder(partner.partner_cmis_folder).getPaths()
            path_parts = parent_path + ['Adhésion']
            path = '/'.join(path_parts)
            # Création ou récupération du répertoire partner
            partner.adhesion_cmis_folder = backend.get_folder_by_path(path)

    # ------------------------------------------------------
    # Override parent
    # ------------------------------------------------------
    @api.multi
    def scop_valid_cg(self):
        """
        Inherit function to :
        - generate files on Alfresco
        """
        res = super(ScopAlfrescoAdhesionPartner, self).scop_valid_cg()
        invoice_adhesion_id = res['invoice_adhesion']
        self.generate_alfresco_file(invoice_adhesion_id.id)
        return res

    @api.multi
    def check_compulsory_docs(self):
        """
        Override function to check docs with cmis query
        :return:
        """
        errors = ''
        compulsory_docs = self.env['scop.adhesion.file'].search([
            ('coop_type_id', '=', self.cooperative_form_id.id),
            ('is_compulsory', '=', True)
        ])
        loaded_docs = self.env['scop.adhesion.file'].\
            compulsory_doc_cmis_query(self)
        # TODO : Check diff between compulsory docs and loaded docs
        if errors:
            res = '---\n Documents manquants :\n' + errors
            return res
        else:
            return str()