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

class vnt_cobros(models.Model):
    _name = 'vnt.cobros'
    _inherit = ['asw.generador_comprobante', 'asw.action.manager']

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

    co_lin_deuda = fields.One2many(
        string=u"Línea Deuda",
        comodel_name='vnt.linea_deuda',
        inverse_name='ld_cobros',
    )

    co_resumen = fields.Text(
        string="Resumen",
    )

    co_total_deuda = fields.Float(
        string="Total Deuda",
        compute="_compute_co_total_deuda",

    )

    co_total_interes = fields.Float(
        string=u"Total Interés",
        compute="_compute_co_total_interes",
    )

    co_total = fields.Float(
        string="Total",
        compute="_compute_co_total",
    )

    co_deucarg = fields.Boolean(
        string="Deudas cargadas",
        default=False,
    )

    co_estado = fields.Selection(
        string=u'Estado Cobro',
        selection=[('b', 'Borrador'),('a', 'Confirmado'),('pr', 'Procesado'),('p', 'Cobrado'),('c', 'Cancelado')],
        readonly= True,
        default= 'b',
        store= True
    )

    co_modo_elegido = fields.Boolean(
        string=u"Fue elegido el modo de pago?",
        default=False,
        compute="_compute_co_modo_elegido",
    )

    co_facturas = fields.Many2many(
        string='Facturas',
        comodel_name='asw.comprobante',
        ondelete='restrict',
    )

    co_notasdeb = fields.Many2many(
        string=u'Notas Débito',
        comodel_name='asw.comprobante',
        ondelete='restrict',
    )

    co_notascred = fields.Many2many(
        string=u'Notas Crédito',
        comodel_name='asw.comprobante',
        ondelete='restrict',
    )

    co_recibos = fields.Many2many(
        string='Recibos de Cobro',
        comodel_name='asw.comprobante',
        ondelete='restrict',
    )

    co_usuario_cancelacion = fields.Many2one(
        string=u'Cancelado por',
        comodel_name='res.users',
        ondelete='set null',
        copy=False
    )

    def seleccionar_todo(self):
        for lin in self.co_lin_deuda:
            lin.ld_select = True
        return (True)

    @api.onchange('co_lin_deuda')
    def _compute_co_modo_elegido(self):
        for lin in self.co_lin_deuda:
            if lin.ld_cobro in ['todo','negociado','perdido']:
                self.co_modo_elegido = True
    

    #Calculos de totales 
    @api.depends('co_lin_deuda')
    def _compute_co_total_deuda(self):
        sumita = 0
        for record in self:
            for lin in record.co_lin_deuda:
                if lin.ld_select == True: 
                    sumita += lin.ld_comp_adeudado
            record.co_total_deuda = sumita 
    
    @api.depends('co_lin_deuda')
    def _compute_co_total_interes(self):
        sumita = 0
        for record in self:
            for lin in record.co_lin_deuda:
                if lin.ld_select == True: 
                    sumita += lin.ld_interes
            record.co_total_interes = sumita 

    @api.depends('co_total_deuda', 'co_total_interes')
    def _compute_co_total(self):
        sumita = 0
        for record in self:
            record.co_total = record.co_total_deuda + record.co_total_interes

    def traer_ld(self):
        self.co_deucarg = True
        #recupero comprobantes de venta, adeudados, con el cliente seleccionado
        comp_venta_adeud = self.env['asw.comprobante'].search([('comp_talonario.tal_menu','=','fac'),('comp_tipo_comp','=','e'),('comp_estado', '=', 'a'),('comp_cliente', '=', self.co_cliente.id)])
        lista = []
        if comp_venta_adeud:
            for comp in comp_venta_adeud:
                nva_linea = self.env['vnt.linea_deuda'].create({'ld_factura': comp.id, 'ld_cobros': self.id})
                lista.append(comp.id)
            self.co_facturas = lista
        else: 
            raise UserError("No hay deudas registradas del cliente seleccionado")

    def volver_borrador(self):
        if (self.co_estado == 'pr'):
            for lin in self.co_lin_deuda:
                nota = lin.ld_nd.id
                nota = self.env['asw.comprobante'].search([('id', '=', nota)])
                nota.comp_fecha_cancelacion = datetime.today()
        self.co_estado = 'b'
        

    def procesar_deuda(self):
        if self.co_total == 0:
            raise UserError('No hay valores seleccionados a confirmar')
        if self.co_total_interes == 0:
            raise UserError('No hay intereses a cobrar, proceda al cobro de la factura en el modo habitual')
        else:
            for li in self.co_lin_deuda:
                if li.ld_select:
                    if li.ld_cobro not in ['todo', 'negociado', 'perdido']:
                      raise UserError('Debe elegir un modo de cobro para cada línea seleccionada')  
            self.co_estado = 'a'

    def procesar_notas(self):
        lista = []
        for li in self.co_lin_deuda:
            if li.ld_select:
                #obtener total. si hay interes se hace nota de debito
                total_int = li.ld_interes
                if (total_int != 0.0): 
                    #crear notas de debito que queden en pendientes de pago

                    #talonario
                    fac_id = li.ld_factura.id
                    fac = self.env['asw.comprobante'].search([('id', '=', fac_id)])
                    tal_original = fac.comp_talonario 
                    tal_letra = tal_original.tal_letra
                    tal_pto = tal_original.tal_pto_vta
                    talonario = self.env['asw.talonario'].search([('tal_pto_vta','=',tal_pto),('tal_letra','=', tal_letra),('tal_codigo','=','NDEB')])
                    
                    if talonario:
                        referencia = 'Nota de débito del comprobante : ' + fac.comp_talonario.tal_codigo + "/" +fac.comp_nro_letras

                        nota_debito = self.generar_comprobante(
                            talonario        = talonario,
                            cliente          = fac.comp_cliente,
                            total            = total_int,
                            referencia       = referencia,
                            comp_estado      = fac.comp_estado,
                            comp_nro_letras  = fac.comp_nro_letras,
                            comp_moneda      = fac.comp_moneda.id,
                            #comp_nota_credito = fac.id,
                        )

                        nota_debito.write({
                            'referencia_orig_ptv': tal_pto,
                            'referencia_orig_numero': fac.comp_nro,
                            'referencia_orig_letra': tal_letra,
                            'referencia_orig_fact': fac.id,
                        })

                        #crear lineas nd
                        inter_prod = self.env['asw.producto'].search([('prod_descripcion','=','INTERES')])
                        linea_comp = self.env['asw.linea_comprobante'].create({
                            'lcp_producto': inter_prod.id,
                            'lcp_comprobante': nota_debito.id,
                            'lcp_precio': total_int,
                            'lcp_importe': total_int,
                        })
                        #asociar nd a linea deuda tb
                        li.ld_nd = nota_debito.id
                        lista.append(nota_debito.id)
                    else:
                        raise UserError('No existe talonario para la Nota de Débito correspondiente. Créelo o diríjase a soporte para que lo haga, y vuelva a este menú') 
                self.co_notasdeb = lista 
        self.co_estado = 'pr'

    
    def pagar_deuda(self):
        #wizard primero para validar cada nota y luego wizard pago 
        lista = []
        for li in self.co_lin_deuda:
            if li.ld_select:
                #lista tiene todas las nd 
                lista.append(li.ld_nd.id)

        datos = {'vnd_cliente': self.co_cliente.id, 
        'vnd_total': self.co_total,
        'vnd_cobro': self.id}
        nvo_w = self.env['vnt.validar_nd'].create(datos)
        nvo_w.vnd_notas = lista

        return {
            'type': 'ir.actions.act_window',
            'res_model': 'vnt.validar_nd',
            'view_mode': 'form',
            'view_type': 'form',
            'res_id': nvo_w.id,
            'target': 'new',
        }

    def cancelar(self):
        lista = []
        lista_f = []
        for li in self.co_lin_deuda:
            if li.ld_select:
                #lista tiene todas las nd 
                lista.append(li.ld_nd.id)
                lista_f.append(li.ld_factura.id)

        datos = {'cc_cliente': self.co_cliente.id, 
        'cc_total': self.co_total,
        'cc_cobro': self.id}
        nvo_w = self.env['vnt.confirmar_cancelacion'].create(datos)
        nvo_w.cc_notas = lista
        nvo_w.cc_facturas = lista_f

        return {
            'type': 'ir.actions.act_window',
            'res_model': 'vnt.confirmar_cancelacion',
            'view_mode': 'form',
            'view_type': 'form',
            'res_id': nvo_w.id,
            'target': 'new',
        }

    def cancelar_cobro(self):
        self.co_estado = 'c'
        self.co_usuario_cancelacion = self.env.uid
        #cancelar recibo
        recibo = self.co_recibos.filtered(lambda t: t.comp_talonario.tal_menu == 'rec')
        recibo.comp_fecha_cancelacion = datetime.today()
        #hay que crear NC

    def cobrar_todo(self):
        for lin in self.co_lin_deuda:
            if lin.ld_select:
                lin.ld_cobro = 'todo'
        return (True)

    def cobrar_negociado(self):
        lista =[]
        for lin in self.co_lin_deuda:
            if lin.ld_select:
                lista.append(lin.id)
        #abrir wizard con in_ld self id 
        datos = {'in_interes':0.0,
        'in_intotal': self.co_total_interes,
        'in_deutotal': self.co_total_deuda,
        'in_cant_comp': len(lista),
        'in_tottot': self.co_total}

        nvo_w = self.env['vnt.interes_negociado'].create(datos)
        nvo_w.in_ld2 = lista 
        return {
            'type': 'ir.actions.act_window',
            'res_model': 'vnt.interes_negociado',
            'view_mode': 'form',
            'view_type': 'form',
            'res_id': nvo_w.id,
            'target': 'new',
        }
       
    
    def interes_perdido(self):
        for lin in self.co_lin_deuda:
            if lin.ld_select:
                lin.ld_cobro = 'perdido'
                lin.ld_interes = 0 
        return (True)