# -*- coding: utf-8 -*-

import base64

from odoo import http, _
from odoo.http import request
from odoo import tools

from odoo.addons.website_portal.controllers.main import website_account

from logging import getLogger
_logger = getLogger(__name__)


class website_account_extend(website_account):

    # Campos obligatorios para compañias
    CMANDATORY = ['denominacion_comercial', 'numero_licencia', 'name', 'rif', 'actividad_economica_id',  # Datos Basicos
                  'fecha_registro', 'numero_registro', 'folio', 'tomo', 'fecha_operaciones', ]  # Registro Mercantil

    # Campos obligatorios para individuales
    IMANDATORY = ['cedula', 'first_name', 'first_last_name', 'gender', 'mobile']  # Datos Básicos

    def __init__(self):
        # Campos oblligatorios que aplican para compañias e individuales
        self.MANDATORY_BILLING_FIELDS = ['fiscal_figure_id', 'phone', 'email', 'street', 'country_id', 'state_id', 'municipality_id', 'parish_id']
        # Campos opcionales que aplican para compañias e individuales
        self.OPTIONAL_BILLING_FIELDS = ['zipcode', 'vat', 'website', 'fax', 'second_name', 'second_last_name', 'numero_contribuyente']
        res = super(website_account_extend, self).__init__()
        return res

    @http.route(['/my/account',
                 '/my/account/edit/<int:partner_id>',
                 '/my/account/new/<int:tipo>'], type='http', auth='user', website=True)
    def details(self, partner_id=None, tipo=False, redirect=None, **post):
        user = request.env.user.partner_id
        values = {
            'error': {},
            'error_message': []
        }

        if partner_id is not None:
            partner = request.env['res.partner'].sudo().browse([partner_id])
            if partner not in user.representante_legal_ids or partner in user.sujeto_pasivo_ids:
                return request.render("website.403")
        elif tipo:
            partner = request.env['res.partner'].sudo()
        else:
            partner = user

        if tipo:
            self.limpiar(partner, True)
        else:
            self.limpiar(partner)

        _logger.info('\n\n\n POST{} \n\n\n'.format(post))
        _logger.info('\n\n\n TIPO{} \n\n\n'.format(tipo))
        if post:
            error, error_message = self.details_form_validate(post, partner)
            values.update({'error': error, 'error_message': error_message})
            values.update(post)
            if not error:
                values = {key: post[key] for key in self.MANDATORY_BILLING_FIELDS}
                values.update({key: post[key] for key in self.OPTIONAL_BILLING_FIELDS if key in post})
                values.update({'zip': values.pop('zipcode', '')})
                if post['image']:
                    datas = post.get('image').stream.getvalue()
                    values.update({'image': datas.encode('base64')})

                if self.create_responsable(post, values, tipo, user, partner):
                    pass
                else:
                    partner.sudo().write(values)

                if redirect:
                    return request.redirect(redirect)
                return request.redirect('/my/account/responsables')

        # Campos many2one
        countries = request.env['res.country'].sudo().search([])
        states = request.env['res.country.state'].sudo().search([])
        municipalities = request.env['res.country.state.municipality'].sudo().search([])
        parishes = request.env['res.country.state.municipality.parish'].sudo().search([])
        actividades_economicas = request.env['sgt_actividad_economica'].sudo().search([])
        if partner.is_company:
            ffiscales = request.env['sgt_figura_fiscal'].sudo().search([('tipo', '=', 'company')])
        else:
            ffiscales = request.env['sgt_figura_fiscal'].sudo().search([('tipo', '=', 'person')])

        values.update({
            'partner': partner,
            'partner_id': partner_id,
            'tipo': tipo,
            'countries': countries,
            'states': states,
            'municipalities': municipalities,
            'parishes': parishes,
            'ffiscales': ffiscales,
            'actividades_economicas': actividades_economicas,
            'has_check_vat': hasattr(request.env['res.partner'], 'check_vat'),
            'redirect': redirect,
        })

        if partner_id is not None:
            return request.render("kyb_sgt_website_ruc.details_representantes", values)
        if tipo:
            return request.render("kyb_sgt_website_ruc.new_registro", values)
        else:
            return request.render("website_portal.details", values)

    @http.route('/my/account/responsables', type='http', auth="user", website=True)
    def responsables_details(self, redirect=None, **kw):
        values = {
            # 'error': {},
            # 'error_message': []
        }
        partner = request.env.user.partner_id
        # if redirect:
        #     _logger.info('\n\n\n\n {} \n\n\n\n'.format(kw))
        #     error, error_message = self.validate_responsables(partner)
        #     values.update({'error': error, 'error_message': error_message})
        #     if not error:
        #         if redirect:
        #             return request.redirect(redirect)
        #         return request.redirect('/my/home')
        values = {'partner': partner,
                  'redirect': redirect}
        return request.render("kyb_sgt_website_ruc.responsables_details", values)

    def details_form_validate(self, data, partner_id, tipo=0):
        partners = request.env['res.partner'].sudo().search([])
        error = dict()
        error_message = []

        # Validation
        for field_name in self.MANDATORY_BILLING_FIELDS:
            if not data.get(field_name):
                error[field_name] = 'missing'

        # email validation
        if data.get('email') and not tools.single_email_re.match(data.get('email')):
            error["email"] = 'error'
            error_message.append(_('¡Email inválido! Por favor, introduce una dirección de correo electrónico válida.'))

        # vat validation
        if data.get("vat") and hasattr(request.env["res.partner"], "check_vat"):
            if data.get("country_id"):
                data["vat"] = request.env["res.partner"].fix_eu_vat_number(int(data.get("country_id")), data.get("vat"))
            if request.website.company_id.sudo().vat_check_vies:
                # force full VIES online check
                check_func = request.env["res.partner"].vies_vat_check
            else:
                # quick and partial off-line checksum validation
                check_func = request.env["res.partner"].simple_vat_check
            vat_country, vat_number = request.env["res.partner"]._split_vat(data.get("vat"))
            if not check_func(vat_country, vat_number):  # simple_vat_check
                error["vat"] = 'error'

        # error message for empty required fields
        if [err for err in error.values() if err == 'missing']:
            error_message.append(_('Algunos campos obligatorios están vacíos.'))

        # Diccionario de los fields que son solo dígitos
        vals_digit = {'cedula': 'Cedula',
                      'rif': 'Rif',
                      'folio': 'Folio',
                      'tomo': 'Tomo',
                      'numero_registro': 'Número de Registro',
                      'phone': 'Telefono',
                      'mobile': 'Movil', }
        # Diccionarion de los fields que son alfabéticos
        vals_string = {'first_name': 'Primer Nombre',
                       'first_last_name': 'Primer Apellido', }

        for key, val in vals_string.items():
            k = str(key)
            if data.get(k) and not data.get(k).isalpha():
                error[k] = 'error'
                error_message.append(_('{} debe contener solo valores alfabéticos'.format(val)))

        for key, val in vals_digit.items():
            k = str(key)
            if data.get(k) and not data.get(k).isdigit():
                error[k] = 'error'
                error_message.append(_('{} debe contener solo valores numéricos').format(val))

        if data.get('email') == partner_id.email:
            pass
        else:
            for record in partners:
                if data.get('email') == record.email:
                    error['email'] = 'error'
                    error_message.append(_('El correo electrónico que ingresó ya está registrado'))

        if data.get('rif'):
            if data.get('rif') == partner_id.rif:
                pass
            else:
                for record in partners:
                    if data.get('rif') == record.rif:
                        error['rif'] = 'error'
                        error_message.append(_('El rif ingresado ya está registrado'))

        if data.get('cedula'):
            if data.get('cedula') == partner_id.cedula:
                pass
            else:
                for record in partners:
                    if data.get('cedula') == record.cedula:
                        error['cedula'] = 'error'
                        error_message.append(_('La cédula ingresada ya está registrada'))

        # unknown = [k for k in data.iterkeys() if k not in self.MANDATORY_BILLING_FIELDS + self.OPTIONAL_BILLING_FIELDS]
        # if unknown:
        #     error['common'] = 'Unknown field'
        #     error_message.append("Unknown field '%s'" % ','.join(unknown))

        return error, error_message

    def validate_responsables(self, partner_id):
        error = dict()
        error_message = []
        if len(partner_id.sujeto_pasivo_ids) < 3:
                error['responsables'] = 'error'
                error_message.append(_('Debe registrar al menos 3 responsables'))
        return error, error_message

    def limpiar(self, partner, new=False):
        """ Función que permite unir la lista de campos obligatorios, con la lista
        de campos obligatorios que aplican para compañias o personas individuales.
        Además, limpia de la lista aquellos campos que no aplican según su tipo """
        if new:
            # Iteración para quitar los campos obligatorios de una compañia
            [self.MANDATORY_BILLING_FIELDS.remove(i) for i in self.CMANDATORY if i in self.MANDATORY_BILLING_FIELDS]
            # Uniendo las lista de campos obligatorios para compañias con los campos obligatorios del controlador
            self.MANDATORY_BILLING_FIELDS = list(set(self.MANDATORY_BILLING_FIELDS) | set(self.IMANDATORY))
            _logger.info('\n\n\n\n %s \n\n\n\n' % self.MANDATORY_BILLING_FIELDS)
        else:
            if partner.is_company:
                # Iteración para quitar los campos obligatorios de una persona individual
                [self.MANDATORY_BILLING_FIELDS.remove(i) for i in self.IMANDATORY if i in self.MANDATORY_BILLING_FIELDS]
                # Uniendo las lista de campos obligatorios para compañias con los campos obligatorios del controlador
                self.MANDATORY_BILLING_FIELDS = list(set(self.MANDATORY_BILLING_FIELDS) | set(self.CMANDATORY))
                _logger.info('\n\n\n\n %s \n\n\n\n' % self.MANDATORY_BILLING_FIELDS)
            else:
                # Iteración para quitar los campos obligatorios de una compañia
                [self.MANDATORY_BILLING_FIELDS.remove(i) for i in self.CMANDATORY if i in self.MANDATORY_BILLING_FIELDS]
                # Uniendo las lista de campos obligatorios para compañias con los campos obligatorios del controlador
                self.MANDATORY_BILLING_FIELDS = list(set(self.MANDATORY_BILLING_FIELDS) | set(self.IMANDATORY))
                _logger.info('\n\n\n\n %s \n\n\n\n' % self.MANDATORY_BILLING_FIELDS)

    def create_responsable(self, data, vals, tipo, user, partner):
        if tipo:
            ffiscal_id = int(data.get('fiscal_figure_id'))
            vals.update({
                'is_responsable': True,
                'fiscal_figure_id': ffiscal_id,
                'company_type': 'person',
                'name': '{0} {1}'.format(data.get('first_name'), data.get('first_last_name')),
            })
            if tipo == 1:
                p_id = partner.create(vals)
                user.sudo().write({'representante_legal_ids': [(4, p_id.id)]})

            elif tipo == 2:
                p_id = partner.create(vals)
                user.sudo().write({'sujeto_pasivo_ids': [(4, p_id.id)]})
            return True
        else:
            return False
