import threading
from typing import Any, Dict

class ConfigurationManager:
    """Singleton thread-safe para gestión de configuración"""
    _instance = None
    _lock = threading.Lock()
    
    def __new__(cls):
        if cls._instance is None:
            with cls._lock:
                # Double-check locking
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
                    cls._instance._initialized = False
        return cls._instance
    
    def __init__(self):
        # Inicializar solo una vez
        if not self._initialized:
            self._config: Dict[str, Any] = {
                'database': {
                    'host': 'localhost',
                    'port': 5432,
                    'pool_size': 10
                },
                'cache': {
                    'ttl': 300,
                    'max_size': 1000
                },
                'api': {
                    'rate_limit': 100,
                    'timeout': 30
                }
            }
            self._initialized = True
    
    def get(self, key: str, default=None):
        """Obtener valor de configuración con notación dot"""
        keys = key.split('.')
        value = self._config
        
        for k in keys:
            if isinstance(value, dict):
                value = value.get(k)
            else:
                return default
            
            if value is None:
                return default
        
        return value
    
    def set(self, key: str, value: Any):
        """Establecer valor de configuración"""
        keys = key.split('.')
        config = self._config
        
        for k in keys[:-1]:
            config = config.setdefault(k, {})
        
        config[keys[-1]] = value

# Demostración
config1 = ConfigurationManager()
config2 = ConfigurationManager()

print(f"Son la misma instancia: {config1 is config2}")  # True
print(f"ID config1: {id(config1)}")
print(f"ID config2: {id(config2)}")

# Configurar desde cualquier parte
config1.set('database.host', 'production.db.com')
config1.set('api.rate_limit', 500)

# Acceder desde cualquier parte
print(f"
Database host: {config2.get('database.host')}")
print(f"API rate limit: {config2.get('api.rate_limit')}")
print(f"Cache TTL: {config2.get('cache.ttl')}")

# Simular uso en diferentes módulos
def module_a():
    config = ConfigurationManager()
    return config.get('database.pool_size')

def module_b():
    config = ConfigurationManager()
    config.set('database.pool_size', 20)

module_b()
print(f"
Pool size desde module_a: {module_a()}")  # 20

// Kotlin usa 'object' – singleton nativo del lenguaje
object ConfigurationManager {
    private val config: MutableMap<String, Any> = mutableMapOf(
        "database" to mutableMapOf("host" to "localhost", "port" to 5432, "pool_size" to 10),
        "cache"    to mutableMapOf("ttl" to 300, "max_size" to 1000),
        "api"      to mutableMapOf("rate_limit" to 100, "timeout" to 30),
    )

    @Suppress("UNCHECKED_CAST")
    fun get(key: String, default: Any? = null): Any? {
        var current: Any? = config
        for (k in key.split("."))
            current = (current as? Map<String, Any>)?.get(k) ?: return default
        return current
    }

    @Suppress("UNCHECKED_CAST")
    fun set(key: String, value: Any) {
        val keys = key.split(".")
        var node = config
        for (k in keys.dropLast(1))
            node = node.getOrPut(k) { mutableMapOf<String, Any>() } as MutableMap<String, Any>
        node[keys.last()] = value
    }
}

// Acceso desde cualquier parte del código
ConfigurationManager.set("database.host", "production.db.com")
ConfigurationManager.set("api.rate_limit", 500)

println("Database host: ${ConfigurationManager.get("database.host")}")
println("API rate limit: ${ConfigurationManager.get("api.rate_limit")}")
println("Cache TTL: ${ConfigurationManager.get("cache.ttl")}")

fun moduleA() = ConfigurationManager.get("database.pool_size")
fun moduleB() = ConfigurationManager.set("database.pool_size", 20)

moduleB()
println("\nPool size desde moduleA: ${moduleA()}")  // 20

import java.util.*;

// Java Singleton idiomático con enum (thread-safe por la JVM)
enum ConfigurationManager {
    INSTANCE;

    private final Map<String,Object> config = new HashMap<>(Map.of(
        "database", new HashMap<>(Map.of("host","localhost","port",5432,"pool_size",10)),
        "cache",    new HashMap<>(Map.of("ttl",300,"max_size",1000)),
        "api",      new HashMap<>(Map.of("rate_limit",100,"timeout",30))
    ));

    @SuppressWarnings("unchecked")
    public Object get(String key) {
        Object current = config;
        for (String k : key.split("\\."))
            current = current instanceof Map ? ((Map<String,Object>)current).get(k) : null;
        return current;
    }

    @SuppressWarnings("unchecked")
    public void set(String key, Object value) {
        String[] keys = key.split("\\.");
        Map<String,Object> cur = config;
        for (int i = 0; i < keys.length-1; i++)
            cur = (Map<String,Object>) cur.computeIfAbsent(keys[i], k -> new HashMap<>());
        cur.put(keys[keys.length-1], value);
    }
}

ConfigurationManager.INSTANCE.set("database.host", "production.db.com");
ConfigurationManager.INSTANCE.set("api.rate_limit", 500);

System.out.println("Database host: " + ConfigurationManager.INSTANCE.get("database.host"));
System.out.println("API rate limit: " + ConfigurationManager.INSTANCE.get("api.rate_limit"));
System.out.println("Cache TTL: "      + ConfigurationManager.INSTANCE.get("cache.ttl"));

# config.py
class _Config:
    def __init__(self):
        self.database_url = "postgresql://localhost/mydb"
        self.debug = True
        self.secret_key = "dev-secret-123"

# Crear instancia única a nivel de módulo
config = _Config()

# En otros archivos, simplemente:
# from config import config
# print(config.database_url)

// Config.kt  – el objeto es un singleton automático en Kotlin
object Config {
    val databaseUrl = "postgresql://localhost/mydb"
    val debug       = true
    val secretKey   = "dev-secret-123"
}

// En otros archivos, simplemente:
// import Config
// println(Config.databaseUrl)

// Config.java – enum como singleton (idioma Java)
enum Config {
    INSTANCE;

    public final String databaseUrl = "postgresql://localhost/mydb";
    public final boolean debug      = true;
    public final String secretKey   = "dev-secret-123";
}

// En otros archivos:
// Config.INSTANCE.databaseUrl

from abc import ABC, abstractmethod
import json
import yaml
import csv
from io import StringIO

class DataParser(ABC):
    """Interfaz base para parsers"""
    
    @abstractmethod
    def parse(self, data: str) -> dict:
        """Parsear datos al formato estándar"""
        pass
    
    @abstractmethod
    def serialize(self, data: dict) -> str:
        """Serializar datos del formato estándar"""
        pass

class JSONParser(DataParser):
    def parse(self, data: str) -> dict:
        return json.loads(data)
    
    def serialize(self, data: dict) -> str:
        return json.dumps(data, indent=2)

class YAMLParser(DataParser):
    def parse(self, data: str) -> dict:
        return yaml.safe_load(data)
    
    def serialize(self, data: dict) -> str:
        return yaml.dump(data, default_flow_style=False)

class CSVParser(DataParser):
    def parse(self, data: str) -> dict:
        """Convertir CSV a dict con primera fila como keys"""
        reader = csv.DictReader(StringIO(data))
        return {"rows": list(reader)}
    
    def serialize(self, data: dict) -> str:
        """Convertir dict a CSV"""
        if not data.get("rows"):
            return ""
        
        output = StringIO()
        writer = csv.DictWriter(output, fieldnames=data["rows"][0].keys())
        writer.writeheader()
        writer.writerows(data["rows"])
        return output.getvalue()

class ParserFactory:
    """Factory para crear parsers según el tipo"""
    _parsers = {
        'json': JSONParser,
        'yaml': YAMLParser,
        'yml': YAMLParser,
        'csv': CSVParser,
    }
    
    @classmethod
    def create_parser(cls, format_type: str) -> DataParser:
        """Crear parser apropiado"""
        parser_class = cls._parsers.get(format_type.lower())
        
        if not parser_class:
            raise ValueError(f"Formato no soportado: {format_type}")
        
        return parser_class()
    
    @classmethod
    def register_parser(cls, format_type: str, parser_class):
        """Registrar nuevo tipo de parser (extensibilidad)"""
        cls._parsers[format_type] = parser_class

# Uso del factory
def process_data_file(filename: str, content: str):
    """Procesar archivo sin saber su formato de antemano"""
    # Detectar formato por extensión
    extension = filename.split('.')[-1]
    
    # Factory crea el parser apropiado
    parser = ParserFactory.create_parser(extension)
    
    # Usar el parser de forma polimórfica
    data = parser.parse(content)
    print(f"
=== Procesando {filename} ===")
    print(f"Tipo de parser: {parser.__class__.__name__}")
    print(f"Datos parseados: {data}")
    
    # Serializar de vuelta
    serialized = parser.serialize(data)
    print(f"Serializado:
{serialized[:100]}...")

# Ejemplos
json_content = '{"name": "John", "age": 30, "city": "NYC"}'
process_data_file("user.json", json_content)

yaml_content = """
name: Jane
age: 25
city: SF
"""
process_data_file("user.yaml", yaml_content)

csv_content = """name,age,city
Bob,35,LA
Alice,28,Chicago"""
process_data_file("users.csv", csv_content)

# Extensibilidad: Agregar nuevo formato
class XMLParser(DataParser):
    def parse(self, data: str) -> dict:
        # Implementación simplificada
        return {"xml": "parsed data"}
    
    def serialize(self, data: dict) -> str:
        return "<data>serialized</data>"

ParserFactory.register_parser('xml', XMLParser)
process_data_file("data.xml", "<root><item>test</item></root>")

import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import com.fasterxml.jackson.module.kotlin.readValue

interface DataParser {
    fun parse(data: String): Map<String, Any>
    fun serialize(data: Map<String, Any>): String
}

class JSONParser : DataParser {
    private val mapper = jacksonObjectMapper()
    override fun parse(data: String): Map<String, Any> = mapper.readValue(data)
    override fun serialize(data: Map<String, Any>) = mapper.writeValueAsString(data)
}

class CSVParser : DataParser {
    override fun parse(data: String): Map<String, Any> {
        val lines = data.trim().lines()
        val headers = lines.first().split(",")
        return mapOf("rows" to lines.drop(1).map { line -> headers.zip(line.split(",")).toMap() })
    }
    @Suppress("UNCHECKED_CAST")
    override fun serialize(data: Map<String, Any>): String {
        val rows = data["rows"] as? List<Map<String, Any>> ?: return ""
        return (listOf(rows.first().keys.joinToString(",")) +
                rows.map { it.values.joinToString(",") }).joinToString("\n")
    }
}

object ParserFactory {
    private val registry = mutableMapOf<String, () -> DataParser>(
        "json" to ::JSONParser,
        "csv"  to ::CSVParser,
    )

    fun create(format: String): DataParser =
        registry[format.lowercase()]?.invoke()
            ?: throw IllegalArgumentException("Formato no soportado: $format")

    fun register(format: String, factory: () -> DataParser) { registry[format] = factory }
}

fun processDataFile(filename: String, content: String) {
    val ext    = filename.substringAfterLast(".")
    val parser = ParserFactory.create(ext)
    val data   = parser.parse(content)
    println("\n=== Procesando $filename ===")
    println("Tipo: ${parser::class.simpleName}")
    println("Datos: $data")
    println("Serializado: ${parser.serialize(data).take(100)}...")
}

processDataFile("user.json",  """{"name":"John","age":30,"city":"NYC"}""")
processDataFile("users.csv",  "name,age,city\nBob,35,LA\nAlice,28,Chicago")

import java.util.*;
import java.util.function.*;
import com.fasterxml.jackson.databind.ObjectMapper;

interface DataParser {
    Map<String,Object> parse(String data) throws Exception;
    String serialize(Map<String,Object> data) throws Exception;
}

static class JSONParser implements DataParser {
    private final ObjectMapper mapper = new ObjectMapper();
    public Map<String,Object> parse(String data) throws Exception { return mapper.readValue(data, Map.class); }
    public String serialize(Map<String,Object> data) throws Exception { return mapper.writeValueAsString(data); }
}

static class CSVParser implements DataParser {
    public Map<String,Object> parse(String data) {
        var lines = data.strip().split("\n"); var headers = lines[0].split(",");
        var rows = new ArrayList<Map<String,String>>();
        for (int i = 1; i < lines.length; i++) {
            var vals = lines[i].split(","); var row = new LinkedHashMap<String,String>();
            for (int j = 0; j < headers.length; j++) row.put(headers[j], vals[j]);
            rows.add(row);
        }
        return Map.of("rows", rows);
    }
    @SuppressWarnings("unchecked")
    public String serialize(Map<String,Object> data) {
        var rows = (List<Map<String,String>>) data.get("rows");
        if (rows == null || rows.isEmpty()) return "";
        var sb = new StringBuilder(String.join(",", rows.get(0).keySet())).append("\n");
        rows.forEach(r -> sb.append(String.join(",", r.values())).append("\n"));
        return sb.toString();
    }
}

static class ParserFactory {
    private static final Map<String,Supplier<DataParser>> registry = new HashMap<>(Map.of(
        "json", JSONParser::new, "csv", CSVParser::new
    ));
    static DataParser create(String format) throws Exception {
        var f = registry.get(format.toLowerCase());
        if (f == null) throw new IllegalArgumentException("Unsupported: " + format);
        return f.get();
    }
    static void register(String format, Supplier<DataParser> factory) { registry.put(format, factory); }
}

static void processDataFile(String filename, String content) throws Exception {
    var parser = ParserFactory.create(filename.substring(filename.lastIndexOf('.')+1));
    var data = parser.parse(content);
    System.out.printf("%n=== Procesando %s ===%nTipo: %s%nDatos: %s%n",
        filename, parser.getClass().getSimpleName(), data);
}

processDataFile("user.json", "{\"name\":\"John\",\"age\":30}");
processDataFile("users.csv", "name,age\nBob,35\nAlice,28");

# Factory Method: Una familia de productos
class NotificationFactory:
    @staticmethod
    def create(channel: str):
        if channel == 'email':
            return EmailNotification()
        elif channel == 'sms':
            return SMSNotification()
        elif channel == 'push':
            return PushNotification()

# Abstract Factory: Familias completas de productos relacionados
class CloudProviderFactory(ABC):
    @abstractmethod
    def create_compute(self):
        pass
    
    @abstractmethod
    def create_storage(self):
        pass

class AWSFactory(CloudProviderFactory):
    def create_compute(self):
        return EC2Instance()
    
    def create_storage(self):
        return S3Bucket()

class AzureFactory(CloudProviderFactory):
    def create_compute(self):
        return VirtualMachine()
    
    def create_storage(self):
        return BlobStorage()

// Factory Method – una familia de productos
interface Notification { fun send(msg: String) }
class EmailNotification : Notification { override fun send(msg: String) = println("📧 EMAIL: $msg") }
class SMSNotification   : Notification { override fun send(msg: String) = println("📱 SMS: $msg") }
class PushNotification  : Notification { override fun send(msg: String) = println("🔔 PUSH: $msg") }

object NotificationFactory {
    fun create(channel: String): Notification = when (channel) {
        "email" -> EmailNotification()
        "sms"   -> SMSNotification()
        "push"  -> PushNotification()
        else    -> throw IllegalArgumentException("Unknown channel: $channel")
    }
}

// Abstract Factory – familias completas de productos relacionados
interface Compute { fun run() }
interface Storage { fun store() }

abstract class CloudProviderFactory {
    abstract fun createCompute(): Compute
    abstract fun createStorage(): Storage
}

class AWSFactory : CloudProviderFactory() {
    override fun createCompute() = object : Compute { override fun run()   = println("EC2 running") }
    override fun createStorage() = object : Storage { override fun store() = println("S3 storing")  }
}

class AzureFactory : CloudProviderFactory() {
    override fun createCompute() = object : Compute { override fun run()   = println("VM running")   }
    override fun createStorage() = object : Storage { override fun store() = println("Blob storing") }
}

// Factory Method
interface Notification { void send(String msg); }
static class EmailNotification implements Notification { public void send(String m) { System.out.println("📧 EMAIL: " + m); } }
static class SMSNotification   implements Notification { public void send(String m) { System.out.println("📱 SMS: "   + m); } }
static class PushNotification  implements Notification { public void send(String m) { System.out.println("🔔 PUSH: "  + m); } }

static class NotificationFactory {
    static Notification create(String channel) {
        return switch (channel) {
            case "email" -> new EmailNotification();
            case "sms"   -> new SMSNotification();
            case "push"  -> new PushNotification();
            default      -> throw new IllegalArgumentException("Unknown: " + channel);
        };
    }
}

// Abstract Factory – familias completas de productos relacionados
interface Compute { void run(); }
interface Storage { void store(); }

abstract static class CloudProviderFactory {
    abstract Compute createCompute();
    abstract Storage createStorage();
}

static class AWSFactory extends CloudProviderFactory {
    public Compute createCompute() { return () -> System.out.println("EC2 running"); }
    public Storage createStorage() { return () -> System.out.println("S3 storing");  }
}

static class AzureFactory extends CloudProviderFactory {
    public Compute createCompute() { return () -> System.out.println("VM running");   }
    public Storage createStorage() { return () -> System.out.println("Blob storing"); }
}

from abc import ABC, abstractmethod
from typing import List, Any
from datetime import datetime

class Observer(ABC):
    """Interfaz para observadores"""
    
    @abstractmethod
    def update(self, event: str, data: Any):
        """Recibir notificación de cambio"""
        pass

class Subject:
    """Sujeto observable"""
    
    def __init__(self):
        self._observers: List[Observer] = []
    
    def attach(self, observer: Observer):
        """Registrar observador"""
        if observer not in self._observers:
            self._observers.append(observer)
            print(f"✓ {observer.__class__.__name__} attached")
    
    def detach(self, observer: Observer):
        """Eliminar observador"""
        self._observers.remove(observer)
        print(f"✗ {observer.__class__.__name__} detached")
    
    def notify(self, event: str, data: Any = None):
        """Notificar a todos los observadores"""
        print(f"
📢 Notificando evento: {event}")
        for observer in self._observers:
            observer.update(event, data)

class UserAccount(Subject):
    """Cuenta de usuario observable"""
    
    def __init__(self, username: str):
        super().__init__()
        self.username = username
        self.balance = 0
    
    def deposit(self, amount: float):
        """Depositar dinero"""
        self.balance += amount
        self.notify('deposit', {
            'username': self.username,
            'amount': amount,
            'new_balance': self.balance,
            'timestamp': datetime.now()
        })
    
    def withdraw(self, amount: float):
        """Retirar dinero"""
        if amount > self.balance:
            self.notify('insufficient_funds', {
                'username': self.username,
                'attempted': amount,
                'available': self.balance
            })
            return False
        
        self.balance -= amount
        self.notify('withdrawal', {
            'username': self.username,
            'amount': amount,
            'new_balance': self.balance,
            'timestamp': datetime.now()
        })
        return True

# Observadores concretos
class EmailNotifier(Observer):
    """Envía emails en eventos importantes"""
    
    def update(self, event: str, data: Any):
        if event == 'deposit' and data['amount'] >= 1000:
            print(f"📧 EMAIL: Large deposit of ${data['amount']:.2f} detected for {data['username']}")
        elif event == 'insufficient_funds':
            print(f"📧 EMAIL: Insufficient funds alert for {data['username']}")

class SMSNotifier(Observer):
    """Envía SMS para retiros"""
    
    def update(self, event: str, data: Any):
        if event == 'withdrawal':
            print(f"📱 SMS: ${data['amount']:.2f} withdrawn from your account. New balance: ${data['new_balance']:.2f}")

class AuditLogger(Observer):
    """Registra todas las transacciones"""
    
    def __init__(self):
        self.logs = []
    
    def update(self, event: str, data: Any):
        log_entry = {
            'event': event,
            'data': data,
            'logged_at': datetime.now()
        }
        self.logs.append(log_entry)
        print(f"📝 AUDIT: Logged {event} event")

class FraudDetector(Observer):
    """Detecta actividad sospechosa"""
    
    def __init__(self):
        self.transaction_count = {}
    
    def update(self, event: str, data: Any):
        if event in ['deposit', 'withdrawal']:
            username = data['username']
            self.transaction_count[username] = self.transaction_count.get(username, 0) + 1
            
            if self.transaction_count[username] >= 3:
                print(f"🚨 FRAUD ALERT: Multiple transactions ({self.transaction_count[username]}) from {username}")

# Demostración
print("=== Sistema de Observadores ===")
account = UserAccount("john_doe")

# Registrar observadores
email_notifier = EmailNotifier()
sms_notifier = SMSNotifier()
audit_logger = AuditLogger()
fraud_detector = FraudDetector()

account.attach(email_notifier)
account.attach(sms_notifier)
account.attach(audit_logger)
account.attach(fraud_detector)

# Realizar transacciones
account.deposit(500)
account.deposit(1500)  # Triggerea email por cantidad grande
account.withdraw(300)
account.withdraw(100)
account.withdraw(50)   # Triggerea fraud alert
account.withdraw(5000) # Insufficient funds

# Desregistrar un observador
print("
--- Removiendo SMS Notifier ---")
account.detach(sms_notifier)
account.deposit(200)  # Solo los otros observadores se notifican

# Ver logs de auditoría
print(f"
📊 Total de logs de auditoría: {len(audit_logger.logs)}")

interface Observer { fun update(event: String, data: Map<String, Any> = emptyMap()) }

abstract class Subject {
    private val observers = mutableListOf<Observer>()
    fun attach(o: Observer)  { observers.add(o);    println("✓ ${o::class.simpleName} attached") }
    fun detach(o: Observer)  { observers.remove(o); println("✗ ${o::class.simpleName} detached") }
    protected fun notify(event: String, data: Map<String, Any> = emptyMap()) {
        println("\n📢 Notificando evento: $event")
        observers.forEach { it.update(event, data) }
    }
}

class UserAccount(private var balance: Double = 0.0) : Subject() {
    fun deposit(amount: Double) {
        balance += amount
        notify("deposit", mapOf("amount" to amount, "balance" to balance))
    }
    fun withdraw(amount: Double) {
        if (amount > balance) { notify("insufficient_funds", mapOf("amount" to amount)); return }
        balance -= amount
        notify("withdrawal", mapOf("amount" to amount, "balance" to balance))
    }
}

class EmailNotifier : Observer {
    override fun update(event: String, data: Map<String, Any>) = when {
        event == "deposit" && (data["amount"] as Double) >= 1000 ->
            println("📧 EMAIL: Large deposit of $${data["amount"]}")
        event == "insufficient_funds" ->
            println("📧 EMAIL: Insufficient funds alert")
        else -> Unit
    }
}

class SMSNotifier : Observer {
    override fun update(event: String, data: Map<String, Any>) {
        if (event == "withdrawal") println("📱 SMS: $${data["amount"]} withdrawn")
    }
}

class AuditLogger : Observer {
    override fun update(event: String, data: Map<String, Any>) =
        println("📋 AUDIT [$event]: $data")
}

import java.util.*;

interface Observer { void update(String event, Map<String,Object> data); }

abstract static class Subject {
    private final List<Observer> observers = new ArrayList<>();
    void attach(Observer o)  { observers.add(o);    System.out.println("✓ " + o.getClass().getSimpleName() + " attached"); }
    void detach(Observer o)  { observers.remove(o); System.out.println("✗ " + o.getClass().getSimpleName() + " detached"); }
    protected void notify(String event, Map<String,Object> data) {
        System.out.println("\n📢 Notificando evento: " + event);
        observers.forEach(o -> o.update(event, data));
    }
}

static class UserAccount extends Subject {
    private double balance;
    void deposit(double amount) {
        balance += amount; notify("deposit", Map.of("amount", amount, "balance", balance));
    }
    void withdraw(double amount) {
        if (amount > balance) { notify("insufficient_funds", Map.of("amount", amount)); return; }
        balance -= amount; notify("withdrawal", Map.of("amount", amount, "balance", balance));
    }
}

static class EmailNotifier implements Observer {
    public void update(String event, Map<String,Object> data) {
        if ("deposit".equals(event) && (double)data.get("amount") >= 1000)
            System.out.println("📧 EMAIL: Large deposit of $" + data.get("amount"));
        if ("insufficient_funds".equals(event))
            System.out.println("📧 EMAIL: Insufficient funds alert");
    }
}

static class AuditLogger implements Observer {
    public void update(String event, Map<String,Object> data) {
        System.out.println("📋 AUDIT [" + event + "]: " + data);
    }
}

from abc import ABC, abstractmethod
from dataclasses import dataclass
from datetime import datetime, date
from typing import List

@dataclass
class Product:
    name: str
    base_price: float
    category: str

@dataclass
class Customer:
    name: str
    loyalty_level: str  # 'bronze', 'silver', 'gold', 'platinum'
    member_since: date

class PricingStrategy(ABC):
    """Estrategia base de pricing"""
    
    @abstractmethod
    def calculate_price(self, product: Product, customer: Customer, quantity: int) -> float:
        """Calcular precio final"""
        pass
    
    @abstractmethod
    def get_description(self) -> str:
        """Descripción de la estrategia"""
        pass

class RegularPricing(PricingStrategy):
    """Sin descuentos"""
    
    def calculate_price(self, product: Product, customer: Customer, quantity: int) -> float:
        return product.base_price * quantity
    
    def get_description(self) -> str:
        return "Precio regular sin descuentos"

class LoyaltyPricing(PricingStrategy):
    """Descuentos basados en nivel de lealtad"""
    
    DISCOUNTS = {
        'bronze': 0.05,    # 5%
        'silver': 0.10,    # 10%
        'gold': 0.15,      # 15%
        'platinum': 0.20   # 20%
    }
    
    def calculate_price(self, product: Product, customer: Customer, quantity: int) -> float:
        base_total = product.base_price * quantity
        discount = self.DISCOUNTS.get(customer.loyalty_level, 0)
        return base_total * (1 - discount)
    
    def get_description(self) -> str:
        return "Descuento por nivel de lealtad del cliente"

class BulkPricing(PricingStrategy):
    """Descuentos por volumen"""
    
    def calculate_price(self, product: Product, customer: Customer, quantity: int) -> float:
        base_total = product.base_price * quantity
        
        if quantity >= 100:
            discount = 0.20  # 20% para 100+
        elif quantity >= 50:
            discount = 0.15  # 15% para 50+
        elif quantity >= 20:
            discount = 0.10  # 10% para 20+
        else:
            discount = 0
        
        return base_total * (1 - discount)
    
    def get_description(self) -> str:
        return "Descuento por cantidad (20+ items: 10%, 50+: 15%, 100+: 20%)"

class SeasonalPricing(PricingStrategy):
    """Descuentos por temporada"""
    
    def __init__(self):
        self.current_month = datetime.now().month
        # Temporada alta: junio-agosto, temporada baja: diciembre-febrero
        self.high_season = [6, 7, 8]
        self.low_season = [12, 1, 2]
    
    def calculate_price(self, product: Product, customer: Customer, quantity: int) -> float:
        base_total = product.base_price * quantity
        
        if self.current_month in self.high_season:
            # Precio premium en temporada alta
            return base_total * 1.20
        elif self.current_month in self.low_season:
            # Descuento en temporada baja
            return base_total * 0.80
        else:
            return base_total
    
    def get_description(self) -> str:
        return "Ajuste de precios por temporada (+20% alta, -20% baja)"

class ComboStrategy(PricingStrategy):
    """Combina múltiples estrategias tomando el mejor precio"""
    
    def __init__(self, strategies: List[PricingStrategy]):
        self.strategies = strategies
    
    def calculate_price(self, product: Product, customer: Customer, quantity: int) -> float:
        # Aplicar todas las estrategias y tomar el precio más bajo
        prices = [
            strategy.calculate_price(product, customer, quantity)
            for strategy in self.strategies
        ]
        return min(prices)
    
    def get_description(self) -> str:
        strategy_names = [s.__class__.__name__ for s in self.strategies]
        return f"Mejor precio entre: {', '.join(strategy_names)}"

class ShoppingCart:
    """Carrito con estrategia de pricing intercambiable"""
    
    def __init__(self, customer: Customer, pricing_strategy: PricingStrategy):
        self.customer = customer
        self.pricing_strategy = pricing_strategy
        self.items: List[tuple] = []  # (product, quantity)
    
    def add_item(self, product: Product, quantity: int):
        """Agregar producto al carrito"""
        self.items.append((product, quantity))
    
    def set_pricing_strategy(self, strategy: PricingStrategy):
        """Cambiar estrategia de pricing"""
        self.pricing_strategy = strategy
        print(f"
🔄 Estrategia cambiada a: {strategy.get_description()}")
    
    def calculate_total(self) -> float:
        """Calcular total con la estrategia actual"""
        total = 0
        for product, quantity in self.items:
            item_price = self.pricing_strategy.calculate_price(product, self.customer, quantity)
            total += item_price
        return total
    
    def show_receipt(self):
        """Mostrar recibo detallado"""
        print(f"
{'='*60}")
        print(f"Cliente: {self.customer.name} ({self.customer.loyalty_level.upper()})")
        print(f"Estrategia: {self.pricing_strategy.get_description()}")
        print(f"{'='*60}")
        
        total = 0
        for product, quantity in self.items:
            base_total = product.base_price * quantity
            final_price = self.pricing_strategy.calculate_price(product, self.customer, quantity)
            discount = base_total - final_price
            
            print(f"{product.name:30} x{quantity:3}")
            print(f"  Base: ${base_total:8.2f} | Final: ${final_price:8.2f} | Ahorro: ${discount:8.2f}")
            
            total += final_price
        
        print(f"{'='*60}")
        print(f"TOTAL: ${total:.2f}")
        print(f"{'='*60}
")

# Demostración
laptop = Product("Laptop Pro", 1200.00, "electronics")
mouse = Product("Wireless Mouse", 25.00, "accessories")
keyboard = Product("Mechanical Keyboard", 80.00, "accessories")

customer_gold = Customer("Alice", "gold", date(2020, 1, 15))

# Crear carrito con estrategia inicial
cart = ShoppingCart(customer_gold, RegularPricing())
cart.add_item(laptop, 1)
cart.add_item(mouse, 50)
cart.add_item(keyboard, 2)

# Probar diferentes estrategias
cart.show_receipt()

cart.set_pricing_strategy(LoyaltyPricing())
cart.show_receipt()

cart.set_pricing_strategy(BulkPricing())
cart.show_receipt()

# Usar combo strategy para mejor precio
combo = ComboStrategy([
    LoyaltyPricing(),
    BulkPricing(),
    SeasonalPricing()
])
cart.set_pricing_strategy(combo)
cart.show_receipt()

import java.time.LocalDate

data class Product(val name: String, val basePrice: Double, val category: String)
data class Customer(val name: String, val loyaltyLevel: String, val memberSince: LocalDate)

interface PricingStrategy {
    fun calculatePrice(product: Product, customer: Customer, quantity: Int): Double
    fun getDescription(): String
}

class RegularPricing : PricingStrategy {
    override fun calculatePrice(p: Product, c: Customer, qty: Int) = p.basePrice * qty
    override fun getDescription() = "Precio regular"
}

class LoyaltyPricing : PricingStrategy {
    private val discounts = mapOf("bronze" to 0.05, "silver" to 0.10, "gold" to 0.15, "platinum" to 0.20)
    override fun calculatePrice(p: Product, c: Customer, qty: Int) =
        p.basePrice * qty * (1 - (discounts[c.loyaltyLevel] ?: 0.0))
    override fun getDescription() = "Precio por lealtad"
}

class BulkPricing(private val threshold: Int = 10, private val discount: Double = 0.15) : PricingStrategy {
    override fun calculatePrice(p: Product, c: Customer, qty: Int) =
        p.basePrice * qty * (if (qty >= threshold) 1 - discount else 1.0)
    override fun getDescription() = "Precio por volumen"
}

class ShoppingCart(private var strategy: PricingStrategy = RegularPricing()) {
    private val items = mutableListOf<Triple<Product, Customer, Int>>()

    fun setStrategy(s: PricingStrategy) { strategy = s }
    fun addItem(p: Product, c: Customer, qty: Int) { items.add(Triple(p, c, qty)) }
    fun total() = items.sumOf { (p, c, q) -> strategy.calculatePrice(p, c, q) }
    fun printReceipt() = println("Total (${strategy.getDescription()}): $${"%.2f".format(total())}")
}

import java.util.*;

record Product(String name, double basePrice, String category) {}
record Customer(String name, String loyaltyLevel) {}

interface PricingStrategy {
    double calculatePrice(Product p, Customer c, int qty);
    String getDescription();
}

static class RegularPricing implements PricingStrategy {
    public double calculatePrice(Product p, Customer c, int qty) { return p.basePrice() * qty; }
    public String getDescription() { return "Precio regular"; }
}

static class LoyaltyPricing implements PricingStrategy {
    private static final Map<String,Double> DISCOUNTS = Map.of(
        "bronze",0.05, "silver",0.10, "gold",0.15, "platinum",0.20);
    public double calculatePrice(Product p, Customer c, int qty) {
        return p.basePrice() * qty * (1 - DISCOUNTS.getOrDefault(c.loyaltyLevel(), 0.0));
    }
    public String getDescription() { return "Precio por lealtad"; }
}

static class BulkPricing implements PricingStrategy {
    private final int threshold; private final double discount;
    BulkPricing(int t, double d) { threshold=t; discount=d; }
    public double calculatePrice(Product p, Customer c, int qty) {
        return p.basePrice() * qty * (qty >= threshold ? 1-discount : 1.0);
    }
    public String getDescription() { return "Precio por volumen"; }
}

static class ShoppingCart {
    private PricingStrategy strategy;
    private final List<Object[]> items = new ArrayList<>();
    ShoppingCart(PricingStrategy s) { strategy = s; }
    void setStrategy(PricingStrategy s) { strategy = s; }
    void addItem(Product p, Customer c, int qty) { items.add(new Object[]{p,c,qty}); }
    double total() { return items.stream().mapToDouble(i -> strategy.calculatePrice((Product)i[0],(Customer)i[1],(int)i[2])).sum(); }
    void printReceipt() { System.out.printf("Total (%s): $%.2f%n", strategy.getDescription(), total()); }
}

import time
import functools
from typing import Callable, Any
import json

def timer(func: Callable) -> Callable:
    """Medir tiempo de ejecución"""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        duration = time.time() - start
        print(f"⏱️  {func.__name__} took {duration:.4f}s")
        return result
    return wrapper

def logger(func: Callable) -> Callable:
    """Registrar llamadas a función"""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        args_repr = [repr(a) for a in args]
        kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
        signature = ", ".join(args_repr + kwargs_repr)
        print(f"📝 Calling {func.__name__}({signature})")
        result = func(*args, **kwargs)
        print(f"✓ {func.__name__} returned {result!r}")
        return result
    return wrapper

def cache(func: Callable) -> Callable:
    """Cachear resultados de función"""
    cache_dict = {}
    
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # Crear key del cache
        key = str(args) + str(kwargs)
        
        if key in cache_dict:
            print(f"💾 Cache HIT for {func.__name__}")
            return cache_dict[key]
        
        print(f"🔄 Cache MISS for {func.__name__}, computing...")
        result = func(*args, **kwargs)
        cache_dict[key] = result
        return result
    
    wrapper.cache_clear = lambda: cache_dict.clear()
    return wrapper

def retry(max_attempts=3, delay=1):
    """Reintentar función en caso de error"""
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_attempts - 1:
                        print(f"❌ Failed after {max_attempts} attempts")
                        raise
                    print(f"⚠️  Attempt {attempt + 1} failed: {e}. Retrying in {delay}s...")
                    time.sleep(delay)
        return wrapper
    return decorator

def validate_args(**type_checks):
    """Validar tipos de argumentos"""
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            # Validar kwargs
            for arg_name, expected_type in type_checks.items():
                if arg_name in kwargs:
                    value = kwargs[arg_name]
                    if not isinstance(value, expected_type):
                        raise TypeError(
                            f"{func.__name__}: '{arg_name}' debe ser {expected_type.__name__}, "
                            f"recibido {type(value).__name__}"
                        )
            return func(*args, **kwargs)
        return wrapper
    return decorator

# Ejemplo: Combinar múltiples decorators
@timer
@logger
@cache
def fibonacci(n: int) -> int:
    """Calcular fibonacci con decorators"""
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

@timer
@retry(max_attempts=3, delay=0.5)
def unreliable_api_call(fail_count=2):
    """Simular llamada API que falla aleatoriamente"""
    import random
    if random.random() < (fail_count / 3):
        raise ConnectionError("API timeout")
    return {"status": "success", "data": [1, 2, 3]}

@validate_args(amount=float, currency=str)
def process_payment(amount, currency, user_id=None):
    """Procesar pago con validación de tipos"""
    print(f"💳 Processing ${amount} {currency} for user {user_id}")
    return {"status": "completed"}

# Demostración
print("=== Fibonacci con cache ===")
fibonacci(5)
fibonacci(5)  # Segunda llamada usa cache
fibonacci(6)  # Reutiliza cálculos previos

print("
=== API con retry ===")
try:
    result = unreliable_api_call()
    print(f"Result: {result}")
except Exception as e:
    print(f"Final error: {e}")

print("
=== Validación de argumentos ===")
process_payment(amount=99.99, currency="USD", user_id=12345)

try:
    process_payment(amount="99.99", currency="USD")  # Error: amount debe ser float
except TypeError as e:
    print(f"Error: {e}")

import kotlin.system.measureTimeMillis

// Decorators como funciones de orden superior
fun <T> timerDecorator(name: String, block: () -> T): T {
    var result: T
    val ms = measureTimeMillis { result = block() }
    println("⏱️  $name took ${ms}ms")
    return result
}

fun <T> retryDecorator(maxAttempts: Int = 3, delayMs: Long = 1_000, block: () -> T): T {
    repeat(maxAttempts - 1) { attempt ->
        runCatching { return block() }.onFailure {
            println("⚠️  Attempt ${attempt + 1} failed: ${it.message}. Retrying in ${delayMs}ms...")
            Thread.sleep(delayMs)
        }
    }
    return block()   // último intento – lanza si falla
}

// Cache decorator
fun <A, R> memoize(fn: (A) -> R): (A) -> R {
    val cache = mutableMapOf<A, R>()
    return { arg -> cache.getOrPut(arg) {
        println("🔄 Cache MISS for $arg, computing...")
        fn(arg)
    }.also { println("💾 Cache HIT for $arg") } }
}

// Uso combinado
val fibonacci: (Int) -> Int by lazy {
    memoize { n: Int -> if (n <= 1) n else fibonacci(n - 1) + fibonacci(n - 2) }
}

fun main() {
    timerDecorator("fibonacci(10)") { fibonacci(10) }
    timerDecorator("fibonacci(10) again") { fibonacci(10) }   // hit

    retryDecorator(maxAttempts = 3, delayMs = 500) {
        if (Math.random() < 0.66) throw Exception("API timeout")
        mapOf("status" to "success", "data" to listOf(1, 2, 3))
    }
}

import java.util.*;
import java.util.concurrent.Callable;
import java.util.function.*;

// Timer
static <T> T timerDecorator(String name, Callable<T> fn) throws Exception {
    long start = System.nanoTime();
    T result = fn.call();
    System.out.printf("⏱️  %s took %dms%n", name, (System.nanoTime()-start)/1_000_000);
    return result;
}

// Retry
static <T> T retryDecorator(int maxAttempts, long delayMs, Callable<T> fn) throws Exception {
    for (int i = 0; i < maxAttempts-1; i++) {
        try { return fn.call(); }
        catch (Exception e) {
            System.out.printf("⚠️  Attempt %d failed: %s. Retrying...%n", i+1, e.getMessage());
            Thread.sleep(delayMs);
        }
    }
    return fn.call();
}

// Memoize
static <A,R> Function<A,R> memoize(Function<A,R> fn) {
    Map<A,R> cache = new HashMap<>();
    return arg -> {
        if (cache.containsKey(arg)) { System.out.println("💾 Cache HIT for " + arg); return cache.get(arg); }
        System.out.println("🔄 Cache MISS for " + arg);
        R result = fn.apply(arg); cache.put(arg, result); return result;
    };
}

// Uso combinado
var cachedFib = memoize((Integer n) -> {
    long a = 0, b = 1; for (int i = 1; i < n; i++) { long t = b; b = a+b; a = t; } return (int)(n<=1?n:b);
});

timerDecorator("fibonacci(10)",       () -> cachedFib.apply(10));
timerDecorator("fibonacci(10) again", () -> cachedFib.apply(10));  // cache hit

retryDecorator(3, 500, () -> {
    if (Math.random() < 0.66) throw new Exception("API timeout");
    return Map.of("status", "success");
});

class RateLimiter:
    """Limitar tasa de llamadas a función"""
    
    def __init__(self, max_calls: int, time_window: float):
        self.max_calls = max_calls
        self.time_window = time_window
        self.calls = []
    
    def __call__(self, func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            now = time.time()
            
            # Limpiar llamadas antiguas
            self.calls = [call_time for call_time in self.calls 
                         if now - call_time < self.time_window]
            
            if len(self.calls) >= self.max_calls:
                raise Exception(
                    f"Rate limit exceeded: {self.max_calls} calls per {self.time_window}s"
                )
            
            self.calls.append(now)
            return func(*args, **kwargs)
        
        return wrapper

@RateLimiter(max_calls=3, time_window=5.0)
def api_endpoint(request_id):
    print(f"✓ Processing request {request_id}")
    return {"status": "ok"}

# Probar rate limiter
for i in range(5):
    try:
        api_endpoint(i)
        time.sleep(1)
    except Exception as e:
        print(f"❌ Request {i}: {e}")

import java.util.concurrent.ConcurrentLinkedDeque

class RateLimiter(private val maxCalls: Int, private val timeWindowMs: Long) {
    private val calls = ConcurrentLinkedDeque<Long>()

    operator fun <T> invoke(block: () -> T): T {
        val now = System.currentTimeMillis()
        // Limpiar llamadas fuera de la ventana
        calls.removeIf { now - it >= timeWindowMs }
        if (calls.size >= maxCalls)
            throw Exception("Rate limit exceeded: $maxCalls calls per ${timeWindowMs}ms")
        calls.add(now)
        return block()
    }
}

val apiEndpoint = RateLimiter(maxCalls = 3, timeWindowMs = 5_000)

repeat(5) { i ->
    runCatching {
        apiEndpoint { println("✓ Processing request $i") }
        Thread.sleep(1_000)
    }.onFailure { println("❌ Request $i: ${it.message}") }
}

import java.util.*;
import java.util.concurrent.*;

static class RateLimiter {
    private final int maxCalls;
    private final long timeWindowMs;
    private final Deque<Long> calls = new ConcurrentLinkedDeque<>();

    RateLimiter(int maxCalls, long timeWindowMs) {
        this.maxCalls = maxCalls; this.timeWindowMs = timeWindowMs;
    }

    <T> T invoke(Callable<T> block) throws Exception {
        long now = System.currentTimeMillis();
        calls.removeIf(t -> now - t >= timeWindowMs);
        if (calls.size() >= maxCalls)
            throw new Exception(String.format("Rate limit exceeded: %d calls per %dms", maxCalls, timeWindowMs));
        calls.add(now);
        return block.call();
    }
}

var rateLimiter = new RateLimiter(3, 5_000);

for (int i = 0; i < 5; i++) {
    final int idx = i;
    try {
        rateLimiter.invoke(() -> { System.out.println("✓ Processing request " + idx); return null; });
        Thread.sleep(1_000);
    } catch (Exception e) { System.out.println("❌ Request " + idx + ": " + e.getMessage()); }
}