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

from odoo import models, fields, api
from odoo.exceptions import UserError, ValidationError
from psycopg2 import sql, DatabaseError

from werkzeug import utils

class opendons_qualifierCategory(models.Model):
    _name = 'opendons_qualifier.category'
    _description = 'categories pour les qualificatifs'
    
    sql_constraints = [
        ('category_uniq', 'UNIQUE((name))', 'This name already exists.')
    ]
    name = fields.Char('Name', required=True)
    order= fields.Integer()
    description = fields.Text()
    company_id = fields.Many2one(
        "res.company",
        string="Company",
        required=True,
        default=lambda self: self.env.company
        
    )
    @api.constrains('name')
    def _check_name(self):
        
            count=self.search_count([('name','=',self.name),('id', '!=', self.id)])
            if count>0:
                raise UserError('This name already exist')
                
                    
    
    

class opendons_qualifier(models.Model):
    _name = 'opendons_qualifier.qualifier'
    _description = 'qualificatifs de contacts'

    name = fields.Char()
    #type=fields.Selection([('checkbox','checkbox'),('text','text'),('numerical','numerical')], default='checkbox')
    default_value_text = fields.Char(string='Default value')
    default_value_bool = fields.Boolean(string='Default value')
    description = fields.Text()
    actif=fields.Boolean(string='actif',default=False)
    value_type=fields.Selection(string='Value type', selection=[('boolean', 'boolean'), ('text', 'text')], readonly=True)
    category_id = fields.Many2one(
        'opendons_qualifier.category', string='Category', tracking=True,
        required=True)
    company_id = fields.Many2one(
        "res.company",
        string="Company",
        required=True,
        default=lambda self: self.env.company
        
    )
    @api.model
    def create(self,vals):
        
        
        
        res = super(opendons_qualifier, self).create(vals)

        #ajout du qualificatif nouvellement créé pour chaque contact
        for partner in self.env['res.partner'].sudo().search([]):
            vals2={}
            vals2['partner_id']=int(partner.id)
            vals2['qualifier_id']=int(res.id)
            vals2['value_type']=res.value_type
            vals2['actif']=res.actif

            if res.value_type=='boolean':
                vals2['value_bool']=vals['default_value_bool']

            if res.value_type=='text':
                vals2['value_text']=vals['default_value_text']

            create_partner_qualifier=self.env['opendons_qualifier.partnerqualifier'].sudo().create(vals2)
                 
        
        return res

    
    def write(self,vals):
        for val in vals:
            if val=='actif':
                #mise à jour des contact pour le qualificatif
                qualifier_partner=self.env['opendons_qualifier.partnerqualifier'].search([('qualifier_id','=',self.id)])
                for q_p in qualifier_partner:
                    q_p.actif=vals['actif']
                    if vals['actif'] and self.value_type=='text':
                        q_p.value_text=self.default_value_text
                    if vals['actif'] and self.value_type=='boolean':
                        q_p.value_bool=self.default_value_bool
                    if not vals['actif'] and self.value_type=='text':
                        q_p.value_text=''
                    if not vals['actif'] and self.value_type=='boolean':
                        q_p.value_bool=False

        res=super(opendons_qualifier, self).write(vals)
        


    def delete_all_partner_qualifiers(self):
        partnerqualifier=self.env['opendons_qualifier.partnerqualifier'].search([])
        partnerqualifier.unlink()

class opendons_partnerqualifier(models.Model):
    _name = 'opendons_qualifier.partnerqualifier'
    _description = 'qualificatifs pour stocker les valeurs au niveau du contact'
    
    
    value_text=fields.Char(string='value')
    value_bool=fields.Boolean(string='value',default=False)
    
    
    @api.model
    def _compute_value_type(self):
        for q in self:
            qualifier=self.env['opendons_qualifier.qualifier'].search([('id',"=",int(q.qualifier_id))])
            q.value_type=qualifier.value_type

    @api.model
    def _compute_actif(self):
        for q in self:
            qualifier=self.env['opendons_qualifier.qualifier'].search([('id',"=",int(q.qualifier_id))])
            q.actif=qualifier.actif
    
    

    value_type=fields.Selection(string='Value type',selection=[('boolean', 'boolean'), ('text', 'text')], compute=_compute_value_type,store=True, readonly=True)
    actif=fields.Boolean(string='actif',compute=_compute_actif,store=True, readonly=True)
    qualifier_id=fields.Many2one('opendons_qualifier.qualifier',string='qualifier',readonly=True,ondelete='cascade')
    category = fields.Char(related='qualifier_id.category_id.name')
    partner_id = fields.Many2one(
        'res.partner',
        string='partner',
        required=True,
        index=True,
        readonly=True,
        track_visibility='onchange',
        ondelete='cascade'
    )
    
    sql_constraints = [
        ('qualifier_uniq', 'unique (qualifier_id,partner_id)', 'A qualifier could be defined only one time on same partner.')
    ]

   


    @api.constrains('qualifier_id')
    def _check_qualifier_id(self):
        for q in self:
            result=self.search_count([('qualifier_id','=',int(self.qualifier_id)),('id', '!=', self.id),('partner_id','=',int(self.partner_id))])
            if result>0:
                raise UserError('A qualifier could be defined only one time on same partner.')