# -*- coding: utf-8 -*-
from odoo.exceptions import UserError
from odoo import models, fields, api
import datetime
from datetime import datetime
import requests, json, random

headers = {'Content-Type': 'application/json'}
TokensValidos = [
    "dadsaf.tghrth,tre433325456,34fgevdsñQWEERFcwqe445VSDasfGrew4vsdfgljk456gf4we8wfg4g4e8r4",
    "retbgv,opervbtolsdfhgtr,wfrrwegf,te,hthrjyqwwqefwer57e74fwtgreñloewwefcd,{sdafsdasdffw6",
    "asdASFefcECWÑlfweñ324dcfwcfdwefcñfdwqecwedfñfc43fd.dfqwe,dfweqf3cvbtr.LDSFsdfsaewfvresf",
    "dsfrvvcmopñ{ds {frew}ferfcv-43wef765ÑFDGg34g3bafGFDhgfHTRvvdsDFFSdfghhfghtVCSdr345Fesdf",
]
HgtUrlBase = """https://hgt.hgt.com.ar/"""
#HgtUrlBase = """https://validacion.hgtsa.com.ar/"""

class hgt_soporte_incidencia(models.Model):
    _name = 'hgt.soporte_incidencia'
    _order = "id desc"
    _rec_name = "si_name"

    #si_numero = fields.Char(string='Numero de ticket')

    si_cerrada = fields.Boolean(
       string=u'Cerrada', 
       default=False,
    )

    si_fecha = fields.Datetime(
        string = 'Fecha de creación',
        default=lambda self:  datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    )

    si_responsable = fields.Many2one(
        string = 'Responsable',
        comodel_name = 'res.users',
        ondelete = 'set null',
        default = lambda self: self.env.user.id
    )

    si_name = fields.Char(
        string=u'Codigo Insidencia',
        readonly=True
    )

    si_descripcion = fields.Text(
        string=u'Descripción',
        required=True
    )

    si_estado = fields.Char(
        string="Estado",
    )

    si_responsabilidad = fields.Selection(
        string=u'Responsabilidad',
        selection=[
            ('pro', 'Propia'),
            ('ter', 'Tercero'),
            ('cli', 'Cliente'),
            ('cat', 'Catástrofe')]
    )
    
    si_historico_mensajes = fields.Text(string='Mensajes')

    si_texto_mensaje = fields.Char(string='Mensaje')

    si_si_interno = fields.Boolean(
        string="Nota Interna?",
        default=False
    )

    si_mensajes = fields.Many2many('hgt.soporte_mensaje', 
        string=u'Mensajes',
        relation='hgt_soporte_incidencia_mensaje_rel',
        column1='hgt_soporte_incidencia_id',
        column2='hgt_soporte_mensaje_id')

    si_id_in = fields.Char(
        string=u'Id Incidencia',
    )

    subida = fields.Boolean(
        string="Subida a Incidencias?",
        default=False
    )

    estado = fields.Selection(string='Estado', selection=[
        ('borrador', 'Borrador'), 
        ('abierta', 'Abierta'), 
        ('proceso', 'En Proceso'), 
        ('resuelto', 'Resuelto'), 
        ('cerrada', 'Cerrada'), 
        ],
        required=True,
        default="borrador",
        readonly=True)
    
    usuario = fields.Char(string='Usuario',
        default=lambda self: self.env.user.display_name,
        readonly=True)

    horas = fields.Float(string='Horas insumida por soporte',
        readonly=True)

    para_operacion = fields.Boolean(string='URGENTE (Detiene la empresa)')
    
    file_name = fields.Char(string='Nombre', default='')

    file = fields.Binary(string='Capturas')

    archivos = fields.Html(string='Archivos',
        default="")

    telefonos = fields.Char(string='Telefonos de aviso',
        default="")

    adjunto = fields.One2many(
        comodel_name='hgt.soporte_adjunto',
        inverse_name='incidencia', 
        string='Adjuntos')

    conclucion = fields.Text(string='Informe Final',
        readonly = True)
    
    urgencia = fields.Selection(string='Urgencia', 
        selection=[
            ('urgente', 'Urgente'), 
            ('no_urgente', 'No Urgente'),],
            default="no_urgente",
            required=True)
    
    
    def AgregarTelefonoAviso(self):
        """Agregar telefono a la lista de telefonos de aviso"""
        if self.telefonos == False:
            listado = []
        else:
            listado = self.telefonos.split(",")
        try:
            telefono = self.env.user.CelularRecuperacion
        except Exception as e:
            print(e)
            telefono = False
        if telefono == False:
            return(None)
        if not telefono in listado:
            listado.append(telefono)
        rta = ""
        for tel in listado:
            if len(tel)>5:#Para que no me ponga comas al pedo
                rta = f"{tel},{rta}"
        self.telefonos = rta

            




    @api.onchange('file', "archivos")
    def _onchange_file(self):
        if self.file == False:
            return()
        val = {"file": self.file,
        "filename":self.file_name}
        r = requests.post("http://192.168.15.121:8536/upload", json=val)
        rta = r.json()
        img_url = rta["url"]
        #html = f"""<div><img src="{img_url}&w=500&h=350" alt="" width="500px" height="350px" /> \n<a>{img_url}</a></div> \n{self.archivos}"""
        html = f"""<div>
                    <a download="custom-filename.jpg" href="{img_url}" title="ImageName">
                        <img src="{img_url}&w=500&h=350" alt="" width="500px" height="350px" />
                    </a>
                    </div>\n{self.archivos}"""
        #print(html)
        self.file = False
        self.archivos = html
        self.ActualizadorGereal()

    def registrar_mensaje(self, mens):
        text = mens.si_mensaje
        envia = mens.si_creador
        envia = envia.name
        fecha = mens.si_mens_fecha
        text_orig = self.si_historico_mensajes
        if text_orig:
            texto_nuevo = """\n{} - {} \n\n{}\n\n ______________________________________________________\n""".format(fecha,envia,text)
            Texto = """{}\n{}""".format(texto_nuevo,text_orig)
            self.si_historico_mensajes = Texto
            return(True)
        else:
            texto_nuevo = """\n{} - {} \n\n{}\n\n ______________________________________________________\n""".format(fecha,envia,text)
            Texto = """{}""".format(texto_nuevo)
            self.si_historico_mensajes = Texto
            return(True)

    def enviar_mensaje(self, mens):
        #funcion para mandar el mensaje al modulo de incidencias
        datos = {
            'params': { 'token':"""a2354mtrgrerxswertyhj76543edfghoiuhEDSfvwerd-5644-fgdh34ergdf""",
                        'in_mensaje': mens.si_mensaje,
                        'in_creador_nombre': mens.si_creador.name,
                        'in_mens_fecha': mens.si_mens_fecha,
                        'in_id_si': self.id,
                        'in_fecha': self.si_fecha,
                        'name': self.si_name, 
                        'descripcion': self.si_descripcion,     
                        'telefonos':self.telefonos,
            }
        }

        datos_json = json.dumps(datos)

        URL = self.env['ir.config_parameter'].sudo().search([('key','=','web.base.url')])
        URL = str(URL.value)

        f = requests.post(URL+'/incidencia/mensaje', data=datos_json, headers=headers)
        frespuesta = f.json()
        #print(frespuesta)

    def NotificarAlRepresentanteTecnico(self):
        users = self.env["res.users"].sudo().search([])
        tels = []
        telegrams = []
        mensaje = f"Se ha generado un ticket nuevo ID {self.id}"
        for user in users:
            if self.env.user.has_group('hgt_soporte.group_soporte_configurador'):
                if user.CelularRecuperacion != False:
                    try:
                        self.enviar_mensaje_ws(
                            telefono=user.CelularRecuperacion,
                            mensaje=mensaje)
                    except:
                        pass    
                try:
                    self.env["hgt.telegram"].sudo().NotificarUsuario(mensaje, user.id)
                except:
                    pass
    def enviar_mensaje_ws(self, tipo='Whatsapp', mensaje="mensaje", titulo="Titulo",email="",telefono=""):#Crea mensaje y lo envia
            #Hay que agregar al modelo la relacion con los mensajes para tener trazavilidad
        vals = {"mensaje_nombre":titulo,
        "mensaje_descripcion":mensaje,
        "mensaje_numero_whatsapp":telefono,
        "mensaje_direccion_mail":email,
        "identidad":1
        }
        mensaje = self.env['asw.mensaje'].sudo().create(vals)
        mensaje.tipo = tipo
        mensaje.enviar()
    

    def enviarIncidencia(self):
        self.NotificarAlRepresentanteTecnico()
        #funcion para la creacion de incidencias en modulo incidencias
        if not self.env.user.has_group('hgt_soporte.group_soporte_configurador'):
            raise UserError("Usted no tiene permisos para generar tickets de soporte externos, genere un incidente interno y avise a su Referente Técnico interno o solicite permisos en su empresa para interactuar directamente con el proveedor.")
        
        self.estado = "abierta"
        self.subida = True 
        self.AgregarTelefonoAviso()

        URL = self.env['ir.config_parameter'].sudo().search([('key','=','web.base.url')])
        URL_local = str(URL.value)

        database = self.env.cr.dbname

        datos = {
            'params': { 'token':self.GenerarToken(),
                        'si_fecha': self.si_fecha,
                        'si_name': self.si_name,  
                        'si_descripcion': self.si_descripcion, 
                        'in_id_si': self.id, 
                        'cliente_URL': URL_local,
                        'database': database,       
                        'estado':"abierta",
                        'usuario': self.si_responsable.display_name,
                        'archivos':self.archivos,
                        'UID':self.env.user.id,
                        'telefonos':self.telefonos,
                        'urgencia':self.urgencia

            }
        }

        datos_json = json.dumps(datos)
        #print(datos_json)


        f = requests.post(f"{HgtUrlBase}soporteIncidencias/crear", data=datos_json, headers=headers)
        frespuesta = f.json()
        if frespuesta["result"]["estado"] != "ok":
            raise UserError(str(frespuesta))

        self.InformarAdjuntos()
        #en frespuesta tengo el id de la incidencia creada en el otro modulo
        #self.si_id_in = frespuesta

        #("entro a enviar incidencia y ahora el valor de ella es " + str(self.subida))
        #print(frespuesta)
    def AbrirLocal(self):
        self.estado = "abierta"
        self.NotificarAlRepresentanteTecnico()


    def GenerarToken(self):
        return(random.choice(TokensValidos))
    
    def ChequearToken(self,token):
        return(token in TokensValidos)

    def GetUrlBase(self):
        return(HgtUrlBase)
    
    @api.model
    def create(self, values):
        rta = super(hgt_soporte_incidencia, self).create(values)
        empresa = self.GenerarNombreEmpresa()
        rta.si_name = f"{empresa.display_name} {str(rta.id).zfill(5)}"
        return(rta)
    
    def GenerarNombreEmpresa(self):
        return(self.env['res.company']._company_default_get())

    def AgregarMensaje(self):
        msj = self.env['soporte.mensaje_wiz'].create({"incidencia":self.id})
        return {
            'name': "Mensaje",
            'type': 'ir.actions.act_window',
            'res_model': 'soporte.mensaje_wiz',
            'view_mode': 'form',
            'view_type': 'form',
            'res_id': msj.id,
            'target': 'new',
        }

    def CerrarIncidencia(self):
        self.estado = "cerrada"
        if self.subida:
            self.CerradoRemoto()

    def CerradoRemoto(self):
        """En caso de cerrar la incidencia y es remota si informa al
        server, en el otro extremo se sobreeescribe para cierre 
        en cliente"""
        database = self.env.cr.dbname

        datos = {
            'params': { 'token':self.GenerarToken(),
                        'si_fecha': self.si_fecha,
                        'si_name': self.si_name,  
                        'si_descripcion': self.si_descripcion, 
                        'in_id_si': self.id, 
                        'database': database,       
                        'usuario': self.si_responsable.display_name,
                        'estado':"cerrada",
                        'archivos':self.archivos,
                        'telefonos':self.telefonos,
            }
        }

        datos_json = json.dumps(datos)
        f = requests.post(f"{HgtUrlBase}soporteIncidencias/crear", data=datos_json, headers=headers)
        frespuesta = f.json()
        if frespuesta["result"]["estado"] != "ok":
            raise UserError(str(frespuesta))
        #print(datos_json)

    def ActualizadorGereal(self):
        #if type(self.id) != int:
        #    return()
        if self.subida == False:
            return()
        self.AgregarTelefonoAviso()
        database = self.env.cr.dbname

        datos = {
            'params': { 'token':self.GenerarToken(),
                        'si_fecha': self.si_fecha,
                        'si_name': self.si_name,  
                        'si_descripcion': self.si_descripcion, 
                        'database': database,       
                        'usuario': self.si_responsable.display_name,
                        'estado':self.estado,
                        'archivos':self.archivos,
                        'telefonos':self.telefonos,
            }
        }

        datos_json = json.dumps(datos)
        #print(datos_json)


        f = requests.post(f"{HgtUrlBase}soporteIncidencias/crear", data=datos_json, headers=headers)
        frespuesta = f.json()
        if frespuesta["result"]["estado"] != "ok":
            raise UserError(str(frespuesta))

    def LaikaSoporte(self, opt):
        incidencia = self.search([["si_name","=",opt["si_name"]]])
        #print(opt,incidencia)
        incidencia.estado = opt["estado"]
        incidencia.horas = opt["horas"]
        if opt["archivos"] != False:
            incidencia.archivos = opt["archivos"]
        if opt["mensaje"] == False:
            return()
        incidencia.Generarmensaje(opt["mensaje"],opt["usuario"],opt["fecha"])
        self.NotificarMensajeNuevo(incidencia)
        self.EnviarAvisoTelegram()

    def EnviarAvisoTelegram(self):
        model = self.env["hgt.telegram"].sudo()
        try:
            model = NotificarUsuario(self, 
            f"Se ha actualizado la incidencia {self.name}",
            self.si_responsable.id)
        except Exception as E:
            print(E)
        #raise UserError(str(opt))

    def Generarmensaje(self,texto,usuario,fecha):
        if texto == False:
            raise UserError("No puso ningun mensaje")
        mensaje = self.env["hgt.soporte_mensaje"].create({})
        mensaje.si_incidencias = [self.id]
        mensaje.si_mensaje = texto
        mensaje.usuario = usuario
        mensaje.si_mens_fecha = fecha
        mensaje.remoto = True

    def AgregarAdjunto(self):
        msj = self.env['soporte.adjunto_wiz'].create({"incidencia":self.id})
        return {
            'name': "Mensaje",
            'type': 'ir.actions.act_window',
            'res_model': 'soporte.adjunto_wiz',
            'view_mode': 'form',
            'view_type': 'form',
            'res_id': msj.id,
            'target': 'new',
        }

    def InformarAdjuntos(self):
        """Esta funcion informa al server HGT de los 
        adjuntos subidos por los clientes"""
        if self.subida == False:
            return(None)
        if len(self.adjunto) == 0:
            return(None)
        lista = []
        for adj in self.adjunto:
            if adj.remoto == False:
                val = {
                    "usuario":adj.usuario,
                    "file_name":adj.file_name,
                    "name":adj.name,
                    "fecha":adj.fecha,
                }
                lista.append(val)
        database = self.env.cr.dbname

        datos = {
            'params': { 'token':self.GenerarToken(),
                        'archivos':lista,
                        'database': database,
                        'codigo': self.si_name,  
                        }
            }

        datos_json = json.dumps(datos)


        f = requests.post(f"{HgtUrlBase}soporteIncidencias/soporteAdjunto", data=datos_json, headers=headers)
        frespuesta = f.json()
        if frespuesta["result"]["estado"] != "ok":
            raise UserError(str(frespuesta))
        
    def LaikaSoporteAdjunto(self, opt):
        incidencia = self.search([["si_name","=",opt["si_name"]]])
        #print(opt)
        for adjunto in opt["adjuntos"]:
            self.AgregarAdjuntosSoporte(adjunto,incidencia)



    
    def AgregarAdjuntosSoporte(self, adjunto,incidencia):
        """Chequeo si el adjunto existe sino lo creo"""
        dom = [
            ["incidencia","=",incidencia.id],
            ["name","=",adjunto["name"]]
            ]
        test = self.env["hgt.soporte_adjunto"].search(dom)
        #print(dom, test)
        if len(test) != 0:
            return(None)
        #Sino existe la creo
        val = {}
        val["remoto"] = True
        val["incidencia"] = incidencia.id #Relacion inversa cxon la incidencia
        val["usuario"] = adjunto["usuario"]
        val["file_name"] = adjunto["file_name"] 
        val["fecha"] = adjunto["fecha"]
        val["name"] = adjunto["name"]
        #print(val)
        self.env["hgt.soporte_adjunto"].create(val)

    def UrlBaseHGT(self):
        return(HgtUrlBase)

    def ActualizarVista(self):
        pass    

    def NotificarMensajeNuevo(self,incidencia):
        print("Notificador de incidencia")
        try:
            notif_push = incidencia.env['ext.notificador'].sudo()
        except Exception as e:
            return()
        try:
            self._NotificarMensajeNuevo(incidencia,notif_push)
        except Exception as e:
            print(e)
        
    def _NotificarMensajeNuevo(self,incidencia,notif_push):
        uids = []
        #print(incidencia.si_mensajes)
        for mensaje in incidencia.si_mensajes:
            #print(mensaje.si_creador.id)
            if not mensaje.si_creador.id in uids:
                uids.append(mensaje.si_creador.id)
        msm = f"""Se a recivido un mensaje en el incidente {incidencia.si_descripcion}"""
        pak = notif_push.GenerarMensajeMasivo(mensaje=msm,titulo="",users=uids)