# -*- coding: utf-8 -*-
"""
Tests para el modelo lims.analysis.parameter
"""
from odoo.tests import TransactionCase
from odoo.exceptions import ValidationError


class TestAnalysisParameter(TransactionCase):
    """Tests para el catálogo de parámetros de análisis"""
    
    def setUp(self):
        super().setUp()
        self.Parameter = self.env['lims.analysis.parameter']
        
    def test_create_numeric_parameter(self):
        """Test crear parámetro numérico con validaciones"""
        # Crear parámetro numérico válido
        param = self.Parameter.create({
            'code': 'TEST001',
            'name': 'Test Parameter',
            'value_type': 'numeric',
            'unit': 'mg/dL',
            'description': 'Test numeric parameter'
        })
        
        self.assertEqual(param.code, 'TEST001')
        self.assertEqual(param.value_type, 'numeric')
        self.assertEqual(param.unit, 'mg/dL')
        
    def test_numeric_parameter_requires_unit(self):
        """Test que parámetros numéricos requieren unidad"""
        with self.assertRaises(ValidationError) as e:
            self.Parameter.create({
                'code': 'TEST002',
                'name': 'Test Parameter No Unit',
                'value_type': 'numeric',
                # Sin unit - debe fallar
            })
        self.assertIn('unidad de medida', str(e.exception))
        
    def test_create_selection_parameter(self):
        """Test crear parámetro de selección con opciones"""
        param = self.Parameter.create({
            'code': 'TEST003',
            'name': 'Test Selection',
            'value_type': 'selection',
            'selection_values': 'Positivo,Negativo,Indeterminado'
        })
        
        self.assertEqual(param.value_type, 'selection')
        self.assertEqual(param.selection_values, 'Positivo,Negativo,Indeterminado')
        
    def test_selection_parameter_requires_values(self):
        """Test que parámetros de selección requieren valores"""
        with self.assertRaises(ValidationError) as e:
            self.Parameter.create({
                'code': 'TEST004',
                'name': 'Test Selection No Values',
                'value_type': 'selection',
                # Sin selection_values - debe fallar
            })
        self.assertIn('valores de selección', str(e.exception))
        
    def test_duplicate_code_not_allowed(self):
        """Test que no se permiten códigos duplicados"""
        # Crear primer parámetro
        self.Parameter.create({
            'code': 'DUP001',
            'name': 'Original Parameter',
            'value_type': 'text'
        })
        
        # Intentar crear duplicado
        with self.assertRaises(ValidationError) as e:
            self.Parameter.create({
                'code': 'DUP001',
                'name': 'Duplicate Parameter',
                'value_type': 'text'
            })
        self.assertIn('ya existe', str(e.exception))
        
    def test_boolean_parameter(self):
        """Test crear parámetro booleano"""
        param = self.Parameter.create({
            'code': 'BOOL001',
            'name': 'Test Boolean',
            'value_type': 'boolean',
            'description': 'Boolean parameter'
        })
        
        self.assertEqual(param.value_type, 'boolean')
        self.assertFalse(param.unit)  # Boolean no debe tener unidad
        
    def test_text_parameter(self):
        """Test crear parámetro de texto"""
        param = self.Parameter.create({
            'code': 'TEXT001',
            'name': 'Test Text',
            'value_type': 'text',
            'description': 'Text parameter'
        })
        
        self.assertEqual(param.value_type, 'text')
        self.assertFalse(param.unit)  # Text no debe tener unidad
        self.assertFalse(param.selection_values)  # Text no debe tener valores de selección
        
    def test_parameter_name_display(self):
        """Test nombre mostrado del parámetro"""
        # Con unidad
        param1 = self.Parameter.create({
            'code': 'DISP001',
            'name': 'Glucosa',
            'value_type': 'numeric',
            'unit': 'mg/dL'
        })
        self.assertEqual(param1.display_name, 'Glucosa (mg/dL)')
        
        # Sin unidad
        param2 = self.Parameter.create({
            'code': 'DISP002',
            'name': 'Cultivo',
            'value_type': 'text'
        })
        self.assertEqual(param2.display_name, 'Cultivo')
        
    def test_parameter_ranges_relationship(self):
        """Test relación con rangos de referencia"""
        param = self.Parameter.create({
            'code': 'RANGE001',
            'name': 'Test with Ranges',
            'value_type': 'numeric',
            'unit': 'U/L'
        })
        
        # Crear rango para este parámetro
        range1 = self.env['lims.parameter.range'].create({
            'parameter_id': param.id,
            'name': 'Adult Male',
            'gender': 'male',
            'age_min': 18,
            'age_max': 65,
            'normal_min': 10.0,
            'normal_max': 50.0
        })
        
        self.assertEqual(len(param.range_ids), 1)
        self.assertEqual(param.range_ids[0], range1)
        
    def test_parameter_analysis_relationship(self):
        """Test relación con análisis a través de product.template.parameter"""
        param = self.Parameter.create({
            'code': 'ANAL001',
            'name': 'Test Analysis Link',
            'value_type': 'numeric',
            'unit': 'mmol/L'
        })
        
        # Crear producto análisis
        analysis = self.env['product.template'].create({
            'name': 'Test Analysis',
            'type': 'service',
            'is_analysis': True,
            'categ_id': self.env.ref('lims_management.product_category_clinical_analysis').id,
        })
        
        # Crear configuración parámetro-análisis
        config = self.env['product.template.parameter'].create({
            'product_tmpl_id': analysis.id,
            'parameter_id': param.id,
            'sequence': 10
        })
        
        self.assertEqual(len(param.analysis_config_ids), 1)
        self.assertEqual(param.analysis_config_ids[0], config)