# -*- coding: utf-8 -*-
from odoo import models, fields, api, exceptions
from odoo.exceptions import ValidationError, Warning
from datetime import datetime
import base64, requests, json
vista_previa = """<h2>Vista Previa</h2>
<img src="{}" alt="Previsualizacion" style="max-height: 400px; max-width: 400px;"/> 
<h2>Publicado</h2>
<img src="{}" alt="Previsualizacion" style="max-height: 400px; max-width: 400px;"/> 
"""
class trans_transportista(models.Model):
    _name = 'trans.transportista'
    _description = 'Transportista'
    _rec_name = 'trans_nombre'
    _order = 'trans_nombre'
    
    trans_razon_social = fields.Char(
        string=u'Razón Social',
    )

    trans_cuit = fields.Char(
        string=u'CUIT')

    trans_pagina_web = fields.Char(
        string=u'Página Web',
        help='Ingrese su página web si es que posee',
    )
    
    trans_nombre = fields.Char(
        string=u'Nombre',
        #required=True,
    )
    
    trans_logo = fields.Binary(
        string=u'Logo',
        help='Archivo png o jpg de menos de 2 Mb'        
    )

    trans_logo_nombre = fields.Char(
        string=u'Logo',
        help='Archivo png o jpg de menos de 2 Mb'        
    )
    trans_categoria  = fields.Selection(
        string=u'Categoría',
        selection=[('p', 'Paga'), ('np', 'No Paga')],
        readonly=True,
        default="np"
    )
    
    trans_telefono = fields.Char(
        string=u'Teléfono',    
    )

    trans_email = fields.Char(
        string = u'Correo Electrónico',
    )

    trans_tipo_ent = fields.Selection(
        string=u'Tipo de entidad',
        selection=[('emp', 'Empresa'), ('ca', 'Camionero'), ('co', 'Comisionista')],
        required = True,
    )

    trans_restriccion_elem = fields.Char(
        string=u'Elementos que no transporta',
        help='Aclarar aquí qué elementos no transporta, si los hubiera',
    )

    trans_tipo = fields.Many2many(
        string=u'Tipo de Transporte',
        comodel_name='trans.tipo_transporte',
        relation='tipo_transporte_transportista_rel',
        column1='trans_tipo_transporte_id',
        column2='trans_transportista_id',
    )

    trans_pto_retiro = fields.Many2many(
        string=u'Punto de Retiro',
        comodel_name='trans.punto_retiro',
        relation='pto_retiro_transportista_rel',
        column1='trans_punto_retiro_id',
        column2='trans_transportista_id',
    )

    trans_posee_ayu = fields.Boolean(
        string=u'Posee ayudantes de carga?',
    )

    trans_observ = fields.Text(
        string=u'Observaciones',
        help = u'Utilice este campo para agregar cualquier observación que desee',
    )
    
    ejecutor = fields.Many2one(
        string='Ejecuta',
        comodel_name='res.users',
        index=True,
        default= lambda self: self.env.user
    )

    controlar_robot = fields.Boolean(string='Datos sin confianza')

    imagen = fields.Binary(string='Logo')
    
    soy_admin = fields.Char(string='Soy adminstrador de LAPPA',compute="_soy_administrador")

    url_img = fields.Char(string='URL imagen')
    
    url_img_publica = fields.Char(string='URL imagen')


    publicada_img = fields.Selection(string='Publicar imagen', selection=[
        ('sa', 'Sin Autorizar'), 
        ('a', 'Autorizado'),],
        required=True,
        default="sa")
    
    muestra = fields.Html(string='Previsualizador',compute="_compute_prev", sanitize=False)

    fac_tipo = fields.Selection(string='Tipo Factura', selection=[('A', 'A'), ('B', 'B'),],
        required=True, default="B")

    fac_doc = fields.Char(string='Documento Facturacion', default="0", required=True)

    fac_documento = fields.Float(string='Documento',
        size=15,
        digits=(15, 0)
        )

    fac_doc_tipo = fields.Selection(string='Tipo documento', selection=[('cuit', 'CUIT'), ('dni', 'DNI'),],required=True,default="dni")

    cli_doc_tipo = fields.Many2one(comodel_name='asw.tipo_documento', string='Tipo Documnto')
    
    cli_resp = fields.Many2one(comodel_name='asw.responsabilidad', string='Responsabilidad fiscal')
    

    comprobantes = fields.Many2many(comodel_name='asw.comprobante', string='Comprobantes')

    cliente = fields.Many2many(comodel_name='asw.cliente', string='Cliente')

    cliente_fac = fields.Many2one(comodel_name='asw.cliente', string='Cliente')

    cliente_nombre = fields.Char(string='Razon social a facturar')
    
    
    #trans_no_transporta = fields.Many2one(comodel_name='trans.no_transporta', 
        #string='Elementos que no transporta')
    
    trans_no_trasnporta = fields.Many2many(
        comodel_name='trans.no_transporta', 
        string='Elementos que no transporta')
    
    
    viejo_db_id = fields.Integer(string='Base de datos vieja', default=0, readonly=True)

    origen_dato = fields.Selection(string='Origen de los datos', 
        selection=[
            ('manual', 'Cargado a mano o generado por el cliente'), 
            ('excel', 'Generado desde el excel'),
            ('viejo','Generado desde la base de dato vieja'),
            ('mixto','Generado desde el excel y se agrega localidades desde db vieja')
            ],readonly=True,
            default="manual")
    
    
    def _compute_prev(self):
        #print(dir(self.trans_logo), self.trans_logo, dir(self.imagen))
        for rec in self:
            imagen = "http://hgtarg.com/logo.jpg"
            if (rec.trans_categoria == "p") and (not (rec.url_img_publica == False or self.url_img_publica == "")):
                imagen = rec. url_img_publica
            rec.muestra = vista_previa.format(rec.url_img,imagen)
    
    #@api.depends('ejecutor')
    def _soy_administrador(self):
        for rec in self:
            if rec.env.user.has_group("hgt_transportar.module_group_administrador"):
                rec.soy_admin = "Soy adinistrador"
            else:
                rec.soy_admin = ""

    @api.one
    @api.constrains('trans_cuit', 'trans_telefono')
    def _requerir_valores(self):
        if self.trans_cuit == 0:
            #raise exceptions.ValidationError('Por favor ingrese el CUIT')
            pass
        if self.trans_telefono == 0:
            #raise exceptions.ValidationError('Por favor ingrese el teléfono')
            pass

    def CargaTranspoorteRobot(self,vals):
        """Funcion para el robot, revisar si esta localidad y provincia y si no crearla
        agregar transportista si no existe, agregar localidad-provincia al transportista"""
        #print(vals)
        try:
            localidad = vals["localidad"]
            provincia = vals["provincia"]
            transportista = vals["transportista"]
        except:
            return("nop")
        #print(localidad,provincia,transportista)
        Localidad = self.env["asw.localidad"].search([["descripcion","=ilike",localidad],["loc_provincia","=ilike",provincia]], limit=1)
        self.transportista_punto(transportista, Localidad, vals)
        return(vals)


    def transportista_punto(self, transportista, localidad, vals):
        trans = self.search([['trans_nombre','=ilike',transportista]])
        if len(trans) == 0:
            try:
                total = self.search_count([])
                if vals["trans_cuit"] == 0:
                    vals["trans_cuit"] = ""
                vals["trans_cuit"] = str(vals["trans_cuit"])
            except:
                vals["trans_cuit"] = "" 
            #vals["trans_cuit"] = total
            #vals["trans_telefono"] = total
            #vals["trans_razon_social"] = transportista
            del vals["localidad"]
            del vals["transportista"]
            del vals["provincia"]
            vals["trans_tipo_ent"] = "emp"
            try:
                if vals['trans_nombre'] == False or vals['trans_nombre'] == "":
                    vals['trans_nombre'] = transportista
            except:
                vals['trans_nombre'] = transportista
            trans = self.create(vals)
        elif len(trans) == 1:
            trans.write(vals)
        #print("vals 142", vals)
        self.punto(trans, localidad)
        #print(trans)

    
    def punto(self, transportista, localidad):
        #print(transportista,localidad)
        for punto in transportista.trans_pto_retiro:
            try:
                if punto.pr_localiad.id == localiad.id:
                    return()
            except:
                pass
        lista = transportista.trans_pto_retiro.ids
        vals = {"pr_direccion":"-----------"}
        vals["pr_localidad"] = localidad.id
        vals["pr_horario"] = "-----------"
        vals["pr_telefono"] = 555555555
        #print(vals)
        punto = self.env['trans.punto_retiro'].create(vals)
        lista.append(punto.id)
        transportista.trans_pto_retiro = lista

        
    def Transportistas(self,vals):
        transportistas = self.search([])
        lista = []
        for transportista in transportistas:
            lista.append(transportista.trans_nombre)
        return({"transportistas":lista})

    def Usuario(self,vals):
        modelos = self.env["hgt.usuarios_externos"].sudo()
        usuario = modelos.search([["ultimo_uso", "=", False], ["id_sistema", "=", "lapabot"], ["habilitado", "=", True]], limit=1)
        if len(usuario) == 0:
            dominio = []
            dominio.append(["id_sistema", "=", "lapabot"])
            dominio.append(["habilitado", "=", True])
            usuario = modelos.search(dominio, order="ultimo_uso asc", limit=1)
        vals = {}
        vals["usuario"] = usuario.user
        vals["passw"] = usuario.passw
        usuario.ultimo_uso = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        return(vals)

    def Localidad_busqueda(self,vals):
        #print(vals)
        Id = vals["Id"]
        modelo = self.env["asw.localidad"].sudo()
        localidad = modelo.search([["id", ">=", Id]], limit=1)
        Localidad = localidad.descripcion
        Provincia = localidad.loc_provincia.descripcion
        return({"localidad":Localidad, "provincia":Provincia, "Id": localidad.id})


    def deduplicar_pr(self):
        """herramenta para mantener los herrores de carga al minimo"""
        transportistas = self.search([])
        for transportista in transportistas:
            #print(transportista)
            transportista.deduplicar_punto_retiro()
            transportista.marcar_control()


    def marcar_control(self):
        control = False
        if (self.trans_cuit == 0) or (self.trans_cuit == False):
            control = True 
        if (self.trans_telefono == 0) or (self.trans_telefono == False):
            control = True
        if (self.trans_razon_social == "") or (self.trans_telefono == False):
            control = True
        if (self.trans_nombre == "") or (self.trans_nombre == False):
            control = True
        #print(control)
        self.controlar_robot = control


    def deduplicar_punto_retiro(self):
        """Elimina puntos de retiros duplicados en un transportista"""
        puntos = [] # lista de id de localidad en los puntos ya cargados
        for punto_retiro in self.trans_pto_retiro:
            if punto_retiro.pr_localidad.id in puntos:
                self.trans_pto_retiro = [(2,punto_retiro.id)]#Comanndo remover id y eliminar
            else:
                puntos.append(punto_retiro.pr_localidad.id)#si no esta en la lista agrego la localidad en la lista puntos cargados
        #print(puntos)

    def subir_img(self):
        decoded_image_data = base64.decodebytes(self.trans_logo)
        path = requests.post(url = "https://img.hgtsa.com.ar/", files = { 'data' : (self.trans_logo_nombre,decoded_image_data)  })
        ruta = "https://img.hgtsa.com.ar/" + path.text
        self.url_img = ruta

    @api.onchange('trans_logo')
    def _onchange_trans_logo(self):
        #registro = self.env['trans.transportista'].browse(self._origin.id)
        #try:
        #    registro.subir_img()
        #except Exception as e:
        #    print(e)
        pass
    
    def previsualizar_imagen(self):
        if self.trans_logo:
            self.subir_img()
        else:
            raise exceptions.Warning("No se ha cargado imagen para actualizar")

    def comprar(self):
        self.ActualizarCliente()
        #print(self)
        #subs = self.env["elc.cobrosubs"].sudo().search([["id_master","=",self.id],["estado","in",["t","a","p"]]],order="id desc",limit=1)
        subs = []
        if len(subs) == 0:
            msubs = self.env['elc.subcripciones'].sudo().browse(1)#Esto hay q ponerlo dinamico no se como aun
            #print(msubs)
            rta = msubs.CrearSubscripcionSDK(self.cliente_fac.id,self.id)    
            return(rta)
        else:
            data = json.loads(subs.raw_entrante)
            url = data["init_point"]
            return({"url": url, "type": "ir.actions.act_url" })

    def ComprarMembresia(self):
        try:
            rta = self.comprar()
            url = {"url":rta["url"],"error":False,
            "mensaje":""}
        except Exception as e:
            url = {"url":"","error":True,
            "mensaje":f"""Revise si tiene todos los datos fiscales cargados CUIT DNI Email Razon Social etc, si falta alguno no se podra completar la operacion \nDev: {str(e)}"""}
            
        return(url)

    def ActualizarMembresia(self):
        rta = self.comprar()
        url = rta["url"]
        return(url)

    def ActualizarCliente(self):
        try:
            from email_validator import validate_email, EmailNotValidError
            valid = validate_email(self.trans_email)
        except EmailNotValidError as e:
            raise Warning(f"El mail es obligatorio para el abono, {self.trans_email} no es valido")
        if self.cliente_nombre == False:
            raise Warning("Defina razon social de facturacion")
        if len(self.cli_doc_tipo) == 0:
            raise Warning("Defina tipo de documento")
        if len(self.cli_resp) == 0:
            raise Warning("Defina responsabilidad")
        if self.fac_documento == "0":
            raise Warning("Defina numero de documento o cuit")
        cliente = self.env["asw.cliente"].sudo().search([["cli_nro_doc","=",int(self.fac_documento)]])
        vals = {}
        vals["cli_razon_social"] = self.cliente_nombre
        vals["cli_celular"] = self.trans_telefono
        vals["cli_mail"] = self.trans_email
        vals["cli_tipo_documento"] = self.cli_doc_tipo.id
        vals["cli_es_cliente"] = True
        vals["cli_es_proveedor"] = False
        vals["cli_responsabilidad"] = self.cli_resp.id
        if len(cliente) == 0:
            vals["cli_nro_doc"] = str(int(self.fac_documento))
            cliente = self.env["asw.cliente"].sudo().create(vals)
        if len(cliente) == 1:
            cliente.write(vals)
        self.cliente_fac = cliente.id

    def publicar(self):
        if self.trans_categoria == "np":
            raise exceptions.Warning("No se puede publicar si no es un abonado")
        if (self.url_img == False) or (self.url_img == ""):
            raise exceptions.Warning("Primero deve previsualizar la imagen de manera correcta")
        self.url_img_publica = self.url_img
        self.publicada_img = "a"

    def quitar_imagen(self):
        self.url_img_publica  = False
        self.publicada_img = "sa"

    def url_logo_trans(self):
        #print("Inafsdf")
        if self.publicada_img == "a":
            return(self.url_img_publica)
        else:
            return("http://hgtarg.com/logo.jpg")

    def Confirmacion(self):
        self.trans_categoria = "p"