# -*- coding: utf-8 -*-
###############################################################################
#    License, author and contributors information in:                         #
#    __manifest__.py file at the root folder of this module.                  #
###############################################################################

from odoo import models, fields, api, _
from odoo.exceptions import UserError, ValidationError, Warning
import datetime

class hgt_cobro_multiple(models.Model):
    _name = 'hgt.pago_multiple_avanzado'
    _description = 'Pago multiple avanzado'
    _inherit = ['asw.action.manager']
    _order = "id desc"

    name = fields.Char(string='Codigo',
        default="Pago en borrador")

    estado = fields.Selection(string='Estado', selection=[('borrador', 'Borrador'), 
        ('aprobado', 'Aprobado'),
        ('pagado', 'Pagado'),
        ('cancelado', 'Cancelado'),
        ], default="borrador")
    

    # Informacion pago
    pcw_cliente = fields.Many2one(
        comodel_name='asw.cliente', 
        string='Cliente',
        readonly=True,
        compute='_compute_cliente',
        required=True
    )

    caja_efectivo = fields.Many2one(
        comodel_name='asw.caja', 
        string='Caja Efectivo',
    )

    caja_cheque = fields.Many2one(
        comodel_name='asw.caja', 
        string='Caja Cheques',
    )

    caja_cheque_terceros = fields.Many2one(
        comodel_name='asw.caja', 
        string='Caja Cheques',
    )

    nota = fields.Text(string='nota',readonly=True,
        compute='_compute_nota')
    
    pcw_referencia = fields.Char(
        string=u'Referencia',
    )    

    pcw_efectivo = fields.Monetary(
        string='Efectivo', 
        currency_field='cli_moneda_empresa'
    )

    pcw_retencion_emitida = fields.Monetary(
        string='Retención', 
        currency_field='cli_moneda_empresa'
    )
    
    pcw_cli_razon_social = fields.Char(
        string='Razon Social',
        related='pcw_cliente.cli_razon_social'
    )

    # Currency field
    cli_moneda_empresa = fields.Many2one(
        string=u'Moneda del saldo',
        comodel_name='res.currency',
        ondelete='set null', 
        related='pcw_cliente.create_uid.company_id.currency_id',        
    )

    # Formas de pago
    pcw_chq_emitidos = fields.Many2many(
        comodel_name='asw.cheque', 
        relation='pago_discriminado_chq_emitido', #ya lo edite
        column1='asw_cheque_id', 
        column2='asw_cliente_id', 
        string='Cheques Propios'
    )
    
    multicheques = fields.Boolean(string='Interno')
    
    buscador_cheque = fields.Many2one(comodel_name='asw.cheque', string='Buscador de cheques en mano')
    

    pcw_chq_terceros = fields.Many2many(
        comodel_name='asw.cheque', 
        relation='pago_discriminado_chq_terceros', #ya lo edite
        column1='asw_cheque_id', 
        column2='asw_cliente_id', 
        string='Cheques Propios',
    )

    pcw_transferencias_emitidas = fields.Many2many(
        comodel_name='asw.valores', 
        relation='pago_discriminado_transferencia_emitida', #Ya lo edite
        column1='pago_cliente_id', 
        column2='asw_valores_id', 
        string='Transferencias Emitidas'
    )

    pcw_tarjetas = fields.Many2many(
        comodel_name='asw.valores', 
        relation='hgt_pago_discriminado_tarjeta', #ya lo edite
        column1='pago_cliente_id', 
        column2='asw_valores_id', 
        string='Tarjetas'
    )

    pcw_retenciones = fields.Many2many(
        comodel_name='asw.valores', 
        relation='pago_discriminado_retencion',#ya lo edite 
        column1='pago_cliente_id', 
        column2='asw_valores_id', 
        string='Retenciones'
    )
    # Total de pago
    pcw_total = fields.Monetary(
        string='Total a entregar',
        compute='_calcular_total',
        currency_field='cli_moneda_empresa'
    )

    pcw_recibo = fields.Many2one(
        string='Recibo',
        comodel_name='asw.comprobante'
    )
    
    comprobantes = fields.Many2many(comodel_name='asw.comprobante', string='Comprobantes')
    
    pcw_total_balance = fields.Monetary(
        string='Diferencia',
        compute='_calcular_diferencia',
        currency_field='cli_moneda_empresa'
    )

    pcw_total_pagar = fields.Monetary(
        string='Total deuda',
        compute='_calcular_pago',
        currency_field='cli_moneda_empresa'
    )
###########################################Validaciones y calculos ######################################

    @api.depends('pcw_total')
    def _compute_cliente(self):
        for record in self:
            record.correccion_compute_cliente()
        
    def correccion_compute_cliente(self,raiser=False):
        if not len(self.pcw_cliente) == 0:
            return(None)
        context = self.env.context
        if len(self.comprobantes) == 0:
            active_ids = context.get('active_ids')
            facturas = self.env['asw.comprobante'].search([('id', 'in', active_ids)])
            self.comprobantes = facturas.ids
        else:
            facturas = self.comprobantes
        idc = []
        arroz = []
        for factura in facturas:
            if not factura.comp_cliente.id in idc:
                idc.append(factura.comp_cliente.id)
            if not factura.comp_adeudado > 0:
                arroz.append(f"Factura {factura.display_name} ya esta pagada o valor nulo\n")
            if factura.comp_estado in ["b","c"]:
                arroz.append(f"Factura {factura.display_name} en estado invalido para pagar\n")
            if (factura.comp_talonario.tal_tipo == "e"):
                arroz.append(f"El comprobante {factura.display_name}  es de venta\n")          
        if not len(idc) == 1:
            arroz.append(f"Solo se puede cobrar a un cliente a la vez, cierre la ventana y seleccione de vuelta los comprobantes a operar")
        if (arroz != []) and (raiser == True):
            mensaje_error = ""
            for text_arr in arroz:
                mensaje_error = f"{mensaje_error}{text_arr}"
            raise Warning(mensaje_error)
        try:
            self.pcw_cliente = idc[0]
        except :
            pass

    @api.depends('comprobantes')
    def _compute_nota(self):
        for record in self:
            #print(record)
            record.compute_nota()
    
    def compute_nota(self):
        context = self.env.context
        Texto = "Facturas de proveedores a pagar:"
        Total = 0
        for factura in self.comprobantes:        
            Total = Total + factura.comp_adeudado
            Texto = f"{Texto}\n{factura.display_name}    {factura.comp_adeudado}"
        Texto = f"{Texto}\nTotal {Total}".replace(".",self.PuntoDecimal())
        self.nota = Texto
        #print(self.nota)
    

    @api.depends('pcw_efectivo','pcw_tarjetas','pcw_transferencias_emitidas','pcw_retenciones','pcw_chq_emitidos','pcw_chq_terceros')
    def _calcular_total(self):
        total = 0
        for record in self.pcw_chq_emitidos:
            total = total + record.che_monto
        for record in self.pcw_chq_terceros:
            total = total + record.che_monto
        for record in self.pcw_transferencias_emitidas:
            total = total + record.val_monto
        for record in self.pcw_tarjetas:
            total = total + record.val_monto
        for record in self.pcw_retenciones:
            total = total + record.val_monto
        self.pcw_total = total + self.pcw_efectivo #+ self.pcw_retencion_recibida

    @api.depends('pcw_total')
    def _calcular_diferencia(self):
        total = self.pcw_total_pagar - self.pcw_total  #+ self.pcw_retencion_recibida
        self.pcw_total_balance = total
    @api.depends('comprobantes')
    def _calcular_pago(self):
        total = 0
        for fac in self.comprobantes:
            total = total + fac.comp_total
        self.pcw_total_pagar = total

    #################################              LOGICA DE PAGO                            #################

    @api.multi
    def pago_facturas_masivo(self):
        context = self.env.context
        active_ids = context.get('active_ids')
        facturas = self.env['asw.comprobante'].search([('id', 'in', active_ids)],order="id asc")
        if len(facturas) == 0:#no hay facturas seleccionadas
            raise Warning("No se seleccionaron facturas")
        resivo = self.CrearValidarResivoMultiple()
        if self.pcw_total != resivo.comp_total:
            raise Warning("Error al procesar el pago informar a soporte")
        total = self.pcw_total
        for factura in facturas:
            if factura.comp_estado in ["c","b"]:
                raise Warning(f"Factura {factura.display_name} esta cancelada o sin validar no se puede Cobrar")
            if not factura.comp_adeudado > 0:
                raise Warning(f"Factura {factura.display_name} en cero revisar")
            if(not factura.comp_talonario.tal_genera_cta_cte):
                raise Warning(f"Factura {factura.display_name} no mueve cuenta corriente no puedo manejarla")
            total = self.LogicaFacturas(factura,resivo,total)
            #obserbacion = f"""{obserbacion}\n{factura.display_name}"""
        resivo.aumentar_numeracion_talonario()
        resivo.comp_fecha_validacion = fields.Datetime.now()
        resivo.generar_monto_adeudado()
        resivo.validar_nro_comprobante()
        self.ArmarObservaciones(facturas,resivo)
        resivo.generar_monto_adeudado()#a prueba
        return(resivo)

    def ArmarObservaciones(self,facturas,resivo):
        obserbacion = "\nFacturas Afectadas     | Total | Saldo"  
        for factura in facturas:
            obserbacion = f"""{obserbacion}\n{factura.display_name} | {factura.comp_total} | {factura.comp_adeudado}""".replace(".",self.PuntoDecimal())
        resivo.comp_observaciones = obserbacion 


    @api.multi
    def generar_recibo(self):
        resivo = self.pago_facturas_masivo()
        self.ValoresEnCajas(resivo)
        return {
                'view_type': 'form',
                'view_mode': 'form',
                'res_model': 'asw.comprobante',
                'type': 'ir.actions.act_window',
                'target': 'self',
                'res_id': resivo.id,
            }

    def LogicaFacturas(self,factura,resivo,total):
        tmp = total
        total = total - factura.comp_adeudado
        if tmp >= 0.0:
            self.MovimientoCuentaCorriente(factura,resivo,tmp)
        return(total)

    #Nombre heredado no me gusto pero bue....
    def MovimientoCuentaCorriente(self,factura,resivo,total):
        #Total = total
        #diff = total - factura.comp_adeudado
        movimiento = factura.comp_adeudado
        if factura.comp_adeudado >= total: #diff < 0.0:
            movimiento = total
        #print( movimiento, factura.display_name)
        if movimiento < 0.0: 
            raise Warning("debug")
        cta_cte = self.env['asw.cta_cte'].create({
            'cc_cliente' : resivo.comp_cliente.id,
            'cc_comprobante' : resivo.id,
            'cc_moneda' : resivo.comp_moneda.id,
            'cc_monto' : movimiento
        })
        cta_cte.afectar(factura.id)
        resivo.generar_monto_adeudado()
        #print()


    def CrearValidarResivoMultiple(self,tipo="r"):
        talonario = self.env['asw.talonario'].search([('tal_menu','=','rec'),('tal_tipo','=',tipo),('tal_mov_caja', '!=', 'sn')], limit=1)
        self.pcw_recibo = self.env['asw.comprobante'].generar_comprobante(
            talonario,
            self.pcw_cliente, 
            self.pcw_total, 
            self.pcw_referencia
        )
        self.agregar_efectivo()
        self.agregar_retencion()
        self.agregar_cheques()
        self.agregar_transferencias_recibidas()
        self.agregar_tarjetas()
        self.pcw_recibo._onchange_comp_linea_facturas()
        self.pcw_recibo.realizar_validaciones()
        self.pcw_recibo._onchange_talonario()
        return(self.pcw_recibo)

    #################################################LOGICA CREACION RESIVO##################################################
    def agregar_efectivo(self):
        if self.pcw_efectivo != 0:
            efectivo = self.env['asw.tipos_valores'].search([('tv_tipo', '=', 'ef')])
            self.pcw_recibo.agregar_valor(self.pcw_efectivo, efectivo, self.caja_efectivo.id)

    def agregar_retencion(self):
        if(len(self.pcw_retenciones) == 0):
            return(None)#Si no hay alguna retencion
        for linea in self.pcw_retenciones:
            self.pcw_recibo.agregar_valor(linea.val_monto, linea.val_tipo, False)

    def agregar_cheques(self):# aca cambia la cosa, lo voy a usar como cheque propio
        if(len(self.pcw_chq_emitidos) > 0):
            cheque_recibido = self.env['asw.tipos_valores'].search([('tv_tipo', '=', 'che')])
            for cheque in self.pcw_chq_emitidos: 
                self.pcw_recibo.agregar_cheque(cheque, cheque_recibido, self.caja_cheque.id)

    def agregar_transferencias_recibidas(self):
        transferencia_recibida = self.env['asw.tipos_valores'].search([('tv_tipo','=','trr')])
        
        self.pcw_transferencias_recibidas.write({'val_comprobante' : self.pcw_recibo.id, 'val_tipo' : transferencia_recibida.id})

    def agregar_tarjetas(self):
        tarjeta_credito = self.env['asw.tipos_valores'].search([('tv_tipo','=','ta'),('tv_descripcion','ilike','credito')])
        tarjeta_debito = self.env['asw.tipos_valores'].search([('tv_tipo','=','ta'),('tv_descripcion','ilike','débito')])

        for record in self.pcw_tarjetas:
            if(record.val_tipo.tv_descripcion == 'Tarjeta de Credito'):
                record.write({'val_comprobante' : self.pcw_recibo.id, 'val_tipo' : tarjeta_credito.id})
            if(record.val_tipo.tv_descripcion == 'Tarjeta de Débito'):
                record.write({'val_comprobante' : self.pcw_recibo.id, 'val_tipo' : tarjeta_debito.id})


    ########################################LOGICA GESTION DE VALORES Y CAJAS ######################################################

    #Buscar cheques y desvincular de la caja
    #los cheques propios no impactan en las cajas
    #las tarjetas de credito no0 impactan en las cajas luego se creare un modelo de convenios de pagos

    


    def ValoresEnCajas(self,resivo):
        #Clasifico el tipo de valor
        efectivo = []
        cheques = []
        transferencias = []
        tarjetas = []
        for valor in resivo.comp_valores:
            if valor.val_tipo.tv_tipo == "ef":
                efectivo.append(valor)
            if valor.val_tipo.tv_tipo == "chr":
                cheques.append(valor)
            if valor.val_tipo.tv_tipo == "trr":
                transferencias.append(valor)
            if valor.val_tipo.tv_tipo == "ta":
                tarjetas.append(valor)
        #Asocio segun el tipo de valor
        self.MoverValores(efectivo, self.caja_efectivo.id)
        self.MoverValores(cheques, self.caja_cheque.id)
        self.MoverValores(transferencias)
        self.MoverValores(tarjetas)
        

    def MoverValores(self, valores, caja_destino_id=True):
        """mueve los valores de los recivos segun se configure"""
        for valor in valores:
            if caja_destino_id == True:
                caja_destino_id = valor.valor_caja_id.id
            if  caja_destino_id == False:
                raise Warning("No esta definida una de las cajas, todos los valores deven tener cajas asignadas") 
            valor.valor_caja_id.caja_valor_ids = [(3,valor.id,)]#elimino el valor de la caja actual
            valor.valor_caja_id = caja_destino_id #cambio la caja en el valor
            valor.valor_caja_id.caja_valor_ids = [(4,valor.id,)]#agrego el valor a la caja destino







############################################Asistente##################################################################
    def PuntoDecimal(self):
        """devuelve si es coma o punto segun la configuracion del sistema"""
        idioma = self.env.user.lang
        res_lang = self.env["res.lang"].sudo().search([["code","=",idioma]])
        decimal = res_lang.decimal_point
        #print(decimal)
        return(decimal)

    #@api.depends('buscador_cheque','pcw_chq_terceros')
    @api.onchange('buscador_cheque','pcw_chq_terceros')
    def _compute_cheques_terceros(self):
        for record in self:
            if record.buscador_cheque.id == False:
                return(None)
            origen = self._origin
            #rec = self.env["hgt.pago_multiple_avanzado"].browse(origen)
            ids = record.pcw_chq_terceros.ids
            ids.append(record.buscador_cheque.id)
            record.buscador_cheque = False
            record.pcw_chq_terceros = ids
            #print(record, record)

    def AgregarChequesMultiples(self):
        self.multicheques = True
        #self.comprobantes = context.get('active_ids')
        #print(self)
        return {
        'context': self.env.context,
        'view_type': 'form',
        'view_mode': 'form',
        'res_model': 'hgt.pago_multiple',
        'res_id': self.id,
        'view_id': False,
        'type': 'ir.actions.act_window',
        'target': 'new',
    }

    def LimpiarChequesTerceros(self):
        cheques = self.pcw_chq_terceros.ids
        cheques.pop
        self.pcw_chq_terceros = False
        self.env.cr.commit()
    
    @api.multi
    def write(self, values):
        name = f"ERO {str(self.id).zfill(5)}"#Genero el codigo del pago
        values["name"] = name
        return super(hgt_cobro_multiple, self).write(values)