# Clases: PascalCase
class ProductService:
    pass

# Funciones y variables: snake_case
def create_product():
    user_name = "example"

# Constantes: UPPER_CASE
MAX_ITEMS_PER_PAGE = 100

# Archivos: snake_case.py
product_service.py
inventory_repository.py

# Directorios: lowercase
src/domain/services/

# Longitud de línea: 88 caracteres
# Indentación: 4 espacios
# Strings: Comillas dobles preferidas
# Imports: Organizados con isort

# Ejemplo de función bien formateada
def process_inventory_movement(
    product_id: int,
    quantity: Decimal,
    movement_type: MovementType,
    user_id: int,
) -> InventoryMovement:
    """
    Procesa un movimiento de inventario con validaciones completas.
    
    Args:
        product_id: Identificador único del producto
        quantity: Cantidad del movimiento (positiva o negativa)
        movement_type: Tipo de movimiento (entrada/salida)
        user_id: Usuario que ejecuta el movimiento
        
    Returns:
        InventoryMovement: Objeto del movimiento creado
        
    Raises:
        ValidationError: Si los datos son inválidos
        BusinessRuleException: Si viola reglas de negocio
    """
    # Implementación...
    pass

# 1. RED: Escribir test que falle
def test_create_product_with_valid_data():
    # Given
    product_data = {
        "code": "P001",
        "name": "Laptop HP",
        "price": Decimal("1500.00"),
        "stock_min": 5,
        "stock_max": 100
    }
    
    # When
    product = ProductService.create_product(product_data)
    
    # Then
    assert product.code == "P001"
    assert product.name == "Laptop HP"
    assert product.price == Decimal("1500.00")

# 2. GREEN: Implementación mínima para pasar test
class ProductService:
    @staticmethod
    def create_product(product_data):
        return Product(
            code=product_data["code"],
            name=product_data["name"],
            price=product_data["price"]
        )

# 3. REFACTOR: Mejorar sin romper tests

# PROHIBIDO: Código duplicado
def validate_product_code_format(code):
    if not code or len(code) < 3:
        raise ValidationError("Invalid code")

def validate_supplier_code_format(code):
    if not code or len(code) < 3:
        raise ValidationError("Invalid code")

# CORRECTO: Código reutilizable
def validate_code_format(code: str, entity_type: str) -> None:
    """Valida formato de código para cualquier entidad."""
    if not code or len(code) < 3:
        raise ValidationError(f"Invalid {entity_type} code format")

# Uso
validate_code_format(product_code, "product")
validate_code_format(supplier_code, "supplier")

# Ejemplo: Validación automática de prohibiciones
def validate_methodology_compliance(change_request):
    """Validar cumplimiento de metodología antes de implementar."""
    violations = []
    
    # Verificar secuencia de trabajo
    if not change_request.follows_required_sequence:
        violations.append("Violación: Secuencia obligatoria no seguida")
    
    # Verificar tests primero
    if not change_request.has_tests_before_code:
        violations.append("Violación: Código implementado sin tests")
    
    # Verificar nombres consistentes
    if not change_request.follows_naming_conventions:
        violations.append("Violación: Nomenclatura PEP8 no respetada")
    
    # Verificar documentación
    if not change_request.has_documentation:
        violations.append("Violación: Cambios sin documentar")
    
    if violations:
        raise MethodologyViolationException(violations)
    
    return True

# Jerarquía de excepciones del sistema
class InventorySystemException(Exception):
    """Excepción base del sistema de inventario."""
    pass

class ValidationException(InventorySystemException):
    """Excepción para errores de validación."""
    pass

class BusinessRuleException(InventorySystemException):
    """Excepción para violaciones de reglas de negocio."""
    pass

class InfrastructureException(InventorySystemException):
    """Excepción para errores de infraestructura."""
    pass

class SecurityException(InventorySystemException):
    """Excepción para violaciones de seguridad."""
    pass

class MethodologyViolationException(InventorySystemException):
    """Excepción para violaciones de metodología."""
    pass

def handle_ui_errors(func):
    """Decorador para manejo de errores en UI."""
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except ValidationException as e:
            show_validation_error_dialog(str(e))
        except BusinessRuleException as e:
            show_business_error_dialog(str(e))
        except Exception as e:
            log_unexpected_error(e)
            show_generic_error_dialog()
    return wrapper

def handle_service_errors(func):
    """Decorador para manejo de errores en servicios."""
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except ValidationException:
            raise  # Re-lanzar para manejo en UI
        except InfrastructureException as e:
            logger.error(f"Infrastructure error: {e}")
            raise BusinessRuleException("Servicio temporalmente no disponible")
        except Exception as e:
            logger.error(f"Unexpected error in service: {e}")
            raise BusinessRuleException("Error interno del sistema")
    return wrapper

# Configuración de logging para errores
import logging
from pathlib import Path

def setup_error_logging():
    """Configurar logging específico para errores."""
    log_dir = Path("logs")
    log_dir.mkdir(exist_ok=True)
    
    error_logger = logging.getLogger("inventory.errors")
    error_logger.setLevel(logging.ERROR)
    
    # Handler para archivo de errores
    error_handler = logging.FileHandler(log_dir / "errors.log")
    error_handler.setLevel(logging.ERROR)
    
    # Formato detallado para errores
    error_formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - '
        '%(filename)s:%(lineno)d - %(funcName)s - %(message)s'
    )
    error_handler.setFormatter(error_formatter)
    
    error_logger.addHandler(error_handler)
    return error_logger

# Script de validación pre-commit
def validate_commit_message(message):
    """Validar formato de mensaje de commit."""
    pattern = r'^(feat|fix|docs|style|refactor|test|chore)(\(.+\))?: .{1,50}'
    
    if not re.match(pattern, message):
        raise CommitValidationException(
            f"Formato de commit inválido: {message}\n"
            f"Usar: <tipo>(<ámbito>): <descripción>"
        )
    
    return True

def validate_commit_atomicity(changed_files):
    """Validar que el commit sea atómico."""
    # Un commit debe abordar un solo concepto
    if len(changed_files) > 10:
        raise CommitValidationException(
            "Commit muy grande. Dividir en commits más pequeños."
        )
    
    # Verificar que los archivos estén relacionados
    file_categories = categorize_files(changed_files)
    if len(file_categories) > 2:
        raise CommitValidationException(
            "Commit aborda múltiples conceptos. Crear commits separados."
        )
    
    return True

import hashlib
import ast
from typing import Dict, List, Set

class RedundancyDetector:
    """Detector de código duplicado y redundancias."""
    
    def __init__(self):
        self.function_hashes: Dict[str, List[str]] = {}
        self.class_hashes: Dict[str, List[str]] = {}
    
    def analyze_file(self, file_path: str) -> Dict[str, List[str]]:
        """Analizar archivo para detectar redundancias."""
        with open(file_path, 'r', encoding='utf-8') as f:
            content = f.read()
        
        tree = ast.parse(content)
        redundancies = {
            'duplicate_functions': [],
            'duplicate_classes': [],
            'similar_logic': []
        }
        
        for node in ast.walk(tree):
            if isinstance(node, ast.FunctionDef):
                func_hash = self._hash_function(node)
                if func_hash in self.function_hashes:
                    redundancies['duplicate_functions'].append(node.name)
                else:
                    self.function_hashes[func_hash] = [node.name]
            
            elif isinstance(node, ast.ClassDef):
                class_hash = self._hash_class(node)
                if class_hash in self.class_hashes:
                    redundancies['duplicate_classes'].append(node.name)
                else:
                    self.class_hashes[class_hash] = [node.name]
        
        return redundancies
    
    def _hash_function(self, func_node: ast.FunctionDef) -> str:
        """Generar hash de función para comparación."""
        # Extraer estructura de la función sin nombres específicos
        structure = self._extract_function_structure(func_node)
        return hashlib.md5(structure.encode()).hexdigest()
    
    def _extract_function_structure(self, func_node: ast.FunctionDef) -> str:
        """Extraer estructura de función para comparación."""
        structure_parts = []
        
        # Argumentos (tipos, no nombres)
        args_types = []
        for arg in func_node.args.args:
            if arg.annotation:
                args_types.append(ast.dump(arg.annotation))
        structure_parts.append("args:" + ",".join(args_types))
        
        # Estructura del cuerpo (sin literales específicos)
        body_structure = []
        for stmt in func_node.body:
            body_structure.append(type(stmt).__name__)
        structure_parts.append("body:" + ",".join(body_structure))
        
        return "|".join(structure_parts)
    
    def suggest_refactoring(self, redundancies: Dict[str, List[str]]) -> List[str]:
        """Sugerir refactorizaciones para eliminar redundancias."""
        suggestions = []
        
        if redundancies['duplicate_functions']:
            suggestions.append(
                f"Funciones duplicadas detectadas: {redundancies['duplicate_functions']}. "
                f"Considerar extraer a función común."
            )
        
        if redundancies['duplicate_classes']:
            suggestions.append(
                f"Clases duplicadas detectadas: {redundancies['duplicate_classes']}. "
                f"Considerar herencia o composición."
            )
        
        return suggestions

def check_redundancies_before_commit():
    """Verificar redundancias antes de hacer commit."""
    detector = RedundancyDetector()
    changed_files = get_changed_files_from_git()
    
    total_redundancies = 0
    for file_path in changed_files:
        if file_path.endswith('.py'):
            redundancies = detector.analyze_file(file_path)
            total_redundancies += sum(len(v) for v in redundancies.values())
            
            if any(redundancies.values()):
                suggestions = detector.suggest_refactoring(redundancies)
                print(f"⚠️  Redundancias en {file_path}:")
                for suggestion in suggestions:
                    print(f"   - {suggestion}")
    
    if total_redundancies > 0:
        response = input("¿Continuar con commit a pesar de redundancias? (y/N): ")
        if response.lower() != 'y':
            raise RedundancyException("Commit cancelado por redundancias detectadas")

class SessionManager:
    """Gestor de continuidad entre sesiones de desarrollo."""
    
    def save_session_state(self, session_data: dict) -> str:
        """Guardar estado de sesión para continuidad."""
        state = {
            'timestamp': datetime.now().isoformat(),
            'completed_phase': session_data['current_phase'],
            'objective': session_data['objective'],
            'files_modified': session_data['files_modified'],
            'tests_status': session_data['tests_status'],
            'next_steps': session_data['next_steps'],
            'context_hash': self._generate_context_hash()
        }
        
        state_file = f"session_state_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
        with open(f"temp/{state_file}", 'w') as f:
            json.dump(state, f, indent=2)
        
        return self._generate_continuation_prompt(state)
    
    def _generate_continuation_prompt(self, state: dict) -> str:
        """Generar prompt para continuar en nueva sesión."""
        return f"""
Continuar desarrollo del Sistema de Inventario desde sesión anterior.

ESTADO ANTERIOR:
- Fase completada: {state['completed_phase']}
- Objetivo: {state['objective']}
- Archivos modificados: {', '.join(state['files_modified'])}
- Estado de tests: {state['tests_status']}

PRÓXIMOS PASOS:
{chr(10).join('- ' + step for step in state['next_steps'])}

INSTRUCCIÓN: 
Cargar contexto de documentos, validar estado actual y continuar 
desde la fase {state['completed_phase']} siguiendo la secuencia 
obligatoria del flujo de trabajo. Mantener metodología TDD y 
cumplimiento de Clean Architecture.
"""
    
    def load_session_state(self, state_file: str) -> dict:
        """Cargar estado de sesión anterior."""
        with open(f"temp/{state_file}", 'r') as f:
            return json.load(f)

def compress_context_for_tokens(full_context: dict) -> dict:
    """Comprimir contexto para optimizar uso de tokens."""
    compressed = {
        'sequence': full_context['obligatory_sequence'],  # Siempre incluir
        'prohibitions': full_context['specific_prohibitions'],  # Crítico
        'current_objective': full_context['session_objective'],  # Esencial
        'architecture_summary': summarize_clean_architecture(),
        'test_status': get_test_status_summary(),
        'modified_files': full_context['recent_changes'][-10:],  # Solo recientes
    }
    
    # Incluir documentación crítica solo por referencia
    compressed['doc_references'] = {
        'instructions': 'claude_instructions_v2.md',
        'architecture': 'architecture.md', 
        'requirements': 'Requerimientos_Sistema_Inventario_v6_0.md'
    }
    
    return compressed

def generate_continuation_summary(session_progress: dict) -> str:
    """Generar resumen para continuación en nueva sesión."""
    return f"""
## RESUMEN DE PROGRESO

**Completado:**
{chr(10).join('✅ ' + item for item in session_progress['completed'])}

**En Progreso:**
{chr(10).join('🔄 ' + item for item in session_progress['in_progress'])}

**Pendiente:**
{chr(10).join('⏳ ' + item for item in session_progress['pending'][:5])}  # Solo top 5

**Estado de Tests:** {session_progress['test_coverage']}% cobertura
**Cumplimiento:** {session_progress['compliance_status']}

**PROMPT PARA CONTINUAR:**
Implementar siguiente item: {session_progress['next_item']}
Seguir secuencia obligatoria desde paso {session_progress['current_step']}
Mantener metodología TDD + Clean Architecture
"""