#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Script simplificado para probar el catálogo de parámetros
"""

import odoo
import logging

_logger = logging.getLogger(__name__)

def test_parameter_catalog(cr):
    """Prueba el funcionamiento del catálogo de parámetros"""
    env = odoo.api.Environment(cr, odoo.SUPERUSER_ID, {})
    
    # Limpiar parámetros de test anteriores
    test_params = env['lims.analysis.parameter'].search([
        ('code', 'like', 'TEST_%')
    ])
    if test_params:
        print(f"Limpiando {len(test_params)} parámetros de test anteriores...")
        test_params.unlink()
    
    print("\n" + "="*60)
    print("TEST: CATÁLOGO DE PARÁMETROS")
    print("="*60 + "\n")
    
    # Test 1: Crear parámetro numérico
    print("1. Creando parámetro numérico...")
    try:
        param_numeric = env['lims.analysis.parameter'].create({
            'code': 'TEST_NUM_001',
            'name': 'Test Numérico',
            'value_type': 'numeric',
            'unit': 'mg/dL',
            'description': 'Parámetro de prueba numérico'
        })
        print(f"   ✓ Parámetro creado: {param_numeric.name} ({param_numeric.code})")
    except Exception as e:
        print(f"   ✗ Error: {e}")
        return False
    
    # Test 2: Validación - parámetro numérico sin unidad
    print("\n2. Validando requerimiento de unidad...")
    try:
        env['lims.analysis.parameter'].create({
            'code': 'TEST_NUM_002',
            'name': 'Test Sin Unidad',
            'value_type': 'numeric',
            # Sin unit - debe fallar
        })
        print("   ✗ Error: Se permitió crear parámetro numérico sin unidad")
        return False
    except Exception as e:
        if 'unidad de medida' in str(e):
            print("   ✓ Validación correcta: Se requiere unidad para parámetros numéricos")
        else:
            print(f"   ✗ Error inesperado: {e}")
            return False
    
    # Test 3: Crear parámetro de selección
    print("\n3. Creando parámetro de selección...")
    try:
        param_selection = env['lims.analysis.parameter'].create({
            'code': 'TEST_SEL_001',
            'name': 'Test Selección',
            'value_type': 'selection',
            'selection_values': 'Positivo,Negativo,Indeterminado'
        })
        print(f"   ✓ Parámetro de selección creado con valores: {param_selection.selection_values}")
    except Exception as e:
        print(f"   ✗ Error: {e}")
        return False
    
    # Test 4: Crear rango de referencia
    print("\n4. Creando rangos de referencia...")
    try:
        range_general = env['lims.parameter.range'].create({
            'parameter_id': param_numeric.id,
            'name': 'Rango General',
            'normal_min': 70.0,
            'normal_max': 100.0,
            'critical_min': 50.0,
            'critical_max': 200.0
        })
        print(f"   ✓ Rango general creado: {range_general.normal_min} - {range_general.normal_max}")
        
        range_male = env['lims.parameter.range'].create({
            'parameter_id': param_numeric.id,
            'name': 'Hombre Adulto',
            'gender': 'male',
            'age_min': 18,
            'age_max': 65,
            'normal_min': 75.0,
            'normal_max': 105.0
        })
        print(f"   ✓ Rango específico creado: Hombre {range_male.age_min}-{range_male.age_max} años")
    except Exception as e:
        print(f"   ✗ Error: {e}")
        return False
    
    # Test 5: Configurar parámetro en análisis
    print("\n5. Configurando parámetros en análisis...")
    try:
        # Obtener un análisis existente
        analysis = env['product.template'].search([
            ('is_analysis', '=', True)
        ], limit=1)
        
        if not analysis:
            print("   ⚠️  No se encontraron análisis para configurar")
        else:
            config = env['product.template.parameter'].create({
                'product_tmpl_id': analysis.id,
                'parameter_id': param_numeric.id,
                'sequence': 999
            })
            print(f"   ✓ Parámetro configurado en análisis: {analysis.name}")
    except Exception as e:
        print(f"   ✗ Error: {e}")
        return False
    
    # Test 6: Generación automática de resultados
    print("\n6. Probando generación automática de resultados...")
    try:
        # Buscar una prueba existente
        test = env['lims.test'].search([
            ('state', '=', 'draft')
        ], limit=1)
        
        if test and analysis:
            # Cambiar el producto de la prueba para trigger la regeneración
            original_product = test.product_id
            test.product_id = analysis.product_variant_id.id
            
            # Verificar que se generó el resultado
            result = test.result_ids.filtered(lambda r: r.parameter_id == param_numeric)
            if result:
                print(f"   ✓ Resultado generado automáticamente para parámetro: {param_numeric.name}")
            else:
                print("   ⚠️  No se generó resultado automático")
            
            # Restaurar producto original
            test.product_id = original_product.id
        else:
            print("   ⚠️  No se encontraron pruebas en borrador para probar")
    except Exception as e:
        print(f"   ✗ Error: {e}")
        return False
    
    # Test 7: Verificar datos demo cargados
    print("\n7. Verificando datos demo del catálogo...")
    try:
        param_count = env['lims.analysis.parameter'].search_count([])
        range_count = env['lims.parameter.range'].search_count([])
        config_count = env['product.template.parameter'].search_count([])
        
        print(f"   - Parámetros totales: {param_count}")
        print(f"   - Rangos de referencia: {range_count}")
        print(f"   - Configuraciones parámetro-análisis: {config_count}")
        
        # Verificar algunos parámetros específicos
        hemoglobin = env.ref('lims_management.param_hemoglobin', raise_if_not_found=False)
        if hemoglobin:
            print(f"   ✓ Parámetro demo encontrado: {hemoglobin.display_name}")
            print(f"     - Rangos asociados: {len(hemoglobin.range_ids)}")
    except Exception as e:
        print(f"   ✗ Error: {e}")
        return False
    
    # Test 8: Buscar rango aplicable
    print("\n8. Probando búsqueda de rango aplicable...")
    try:
        # Crear paciente de prueba
        patient = env['res.partner'].create({
            'name': 'Paciente Test Rango',
            'is_patient': True,
            'gender': 'male',
            'birthdate_date': '1990-01-01'  # 34 años aprox
        })
        
        # Buscar rango aplicable
        Range = env['lims.parameter.range']
        applicable = Range._find_applicable_range(
            param_numeric.id,
            gender='male',
            age=34,
            is_pregnant=False
        )
        
        if applicable:
            print(f"   ✓ Rango aplicable encontrado: {applicable.name}")
            print(f"     - Valores normales: {applicable.normal_min} - {applicable.normal_max}")
        else:
            print("   ⚠️  No se encontró rango aplicable")
            
        # Limpiar
        patient.unlink()
    except Exception as e:
        print(f"   ✗ Error: {e}")
        return False
    
    print("\n" + "="*60)
    print("✅ TODOS LOS TESTS PASARON EXITOSAMENTE")
    print("="*60)
    return True


if __name__ == '__main__':
    db_name = 'lims_demo'
    registry = odoo.registry(db_name)
    
    with registry.cursor() as cr:
        try:
            success = test_parameter_catalog(cr)
            if not success:
                print("\n⚠️  ALGUNOS TESTS FALLARON")
        except Exception as e:
            print(f"\n✗ Error crítico: {e}")
            import traceback
            traceback.print_exc()