from dataclasses import dataclass, field
import gzip
import json
from pathlib import Path
import re

import requests


OBF_DUMP_URL = "https://static.openbeautyfacts.org/data/openbeautyfacts-products.jsonl.gz"


@dataclass
class Product:
    barcode: str
    brand: str
    name: str
    ingredients_raw: str
    inci_list: list[str]                # Lista de ingredientes ordenada por concentración
    categories: list[str] = field(default_factory=list)
    country: str = ""
    image_url: str = ""


def download_obf_dump(dest: Path) -> Path:
    """Descarga el volcado JSON de Open Beauty Facts (unos 500 MB en gzip)."""
    dest.parent.mkdir(parents=True, exist_ok=True)
    if dest.exists() and dest.stat().st_size > 100_000_000:
        return dest
    print(f"Descargando... {OBF_DUMP_URL}")
    with requests.get(OBF_DUMP_URL, stream=True, timeout=600) as r:
        r.raise_for_status()
        with open(dest, "wb") as f:
            for chunk in r.iter_content(chunk_size=8192 * 1024):
                f.write(chunk)
    return dest


def parse_inci(ingredients_raw: str) -> list[str]:
    """Analiza el texto INCI sin procesar como una lista ordenada por concentración.

    - Separa por comas, punto y coma y puntos.
    - Los paréntesis contienen alias o números CI (por ejemplo, "WATER" en "AQUA (WATER)").
    - Elimina el contenido entre corchetes (por ejemplo, la notación nano).
    - Conserva las etiquetas con asterisco de ingredientes alergénicos.
    """
    if not ingredients_raw:
        return []
    # Normalización y tratamiento de paréntesis y corchetes
    parts = re.split(r"[,;·]", ingredients_raw)
    cleaned = []
    for p in parts:
        # Elimina corchetes (por ejemplo, "[nano]")
        p = re.sub(r"\[.*?\]", "", p)
        # Trata el alias entre paréntesis (aquí se elimina del nombre principal)
        p = re.sub(r"\(.*?\)", "", p)
        p = p.strip().upper()
        # Decide si conservar etiquetas especiales como asteriscos (**) o virgulillas (~)
        if p and len(p) > 1 and len(p) < 100:
            cleaned.append(p)
    return cleaned


def iter_cosmetics(dump_path: Path, min_ingredients: int = 3):
    """Procesa el volcado OBF en streaming y filtra por número mínimo de ingredientes."""
    with gzip.open(dump_path, "rt", encoding="utf-8") as f:
        for line in f:
            try:
                d = json.loads(line)
            except json.JSONDecodeError:
                continue
            if not d.get("ingredients_text"):
                continue
            inci = parse_inci(d.get("ingredients_text", ""))
            if len(inci) < min_ingredients:
                continue
            yield Product(
                barcode=d.get("code", ""),
                brand=(d.get("brands") or "").split(",")[0].strip(),
                name=d.get("product_name", ""),
                ingredients_raw=d.get("ingredients_text", ""),
                inci_list=inci,
                categories=d.get("categories_tags", []),
                country=d.get("countries", ""),
                image_url=d.get("image_url", ""),
            )

import csv


@dataclass
class CosingEntry:
    inci_name: str
    cas: str
    einecs: str
    function: str            # e.g. "Skin conditioning · Emollient"
    restriction: str          # Regulación de la UE (por ejemplo, "Concentration limit 0.5%")
    allergen_flag: bool = False


def load_cosing_dict(cosing_csv: Path) -> dict[str, CosingEntry]:
    """Convierte el CSV de CosIng en un diccionario {nombre_INCI_en_mayúsculas: CosingEntry}."""
    result: dict[str, CosingEntry] = {}
    with open(cosing_csv, encoding="utf-8", errors="ignore") as f:
        reader = csv.DictReader(f)
        for row in reader:
            key = (row.get("INCI name") or "").upper().strip()
            if not key:
                continue
            result[key] = CosingEntry(
                inci_name=key,
                cas=row.get("CAS #", "").strip(),
                einecs=row.get("EINECS/ELINCS #", "").strip(),
                function=row.get("Function", "").strip(),
                restriction=row.get("Restriction", "").strip(),
                allergen_flag="allergen" in row.get("Restriction", "").lower(),
            )
    return result


def normalize_inci(raw_name: str, cosing_dict: dict[str, CosingEntry]) -> str | None:
    """Normaliza con el diccionario CosIng y usa coincidencia parcial como alternativa."""
    upper = raw_name.upper().strip()
    if upper in cosing_dict:
        return upper
    # Coincidencia parcial (por ejemplo, "AQUA (WATER)" → "AQUA")
    for key in cosing_dict:
        if key in upper or upper in key:
            return key
    # Alternativa: coincidencia difusa (distancia de Levenshtein)
    return None

from rdkit import Chem, RDLogger
from rdkit.Chem import AllChem
import numpy as np

RDLogger.DisableLog("rdApp.*")


def cas_to_smiles(cas_number: str, cache: dict | None = None) -> str | None:
    """CAS → SMILES mediante la API REST de PubChem [8]. Se recomienda usar caché para evitar repeticiones."""
    if not cas_number:
        return None
    if cache and cas_number in cache:
        return cache[cas_number]
    url = f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{cas_number}/property/CanonicalSMILES/JSON"
    try:
        resp = requests.get(url, timeout=15)
        if resp.status_code != 200:
            if cache is not None:
                cache[cas_number] = None
            return None
        data = resp.json()
        smiles = data["PropertyTable"]["Properties"][0]["CanonicalSMILES"]
        if cache is not None:
            cache[cas_number] = smiles
        return smiles
    except (requests.RequestException, KeyError):
        if cache is not None:
            cache[cas_number] = None
        return None


def compute_ecfp(smiles: str, radius: int = 2, n_bits: int = 2048) -> np.ndarray:
    """Calcula ECFP (Extended Connectivity Fingerprint), una huella de Morgan."""
    mol = Chem.MolFromSmiles(smiles)
    if mol is None:
        return np.zeros(n_bits, dtype=np.uint8)
    fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius, nBits=n_bits)
    return np.array(fp, dtype=np.uint8)


def build_ingredient_embeddings(
    cosing_dict: dict[str, CosingEntry],
    cache_path: Path,
    sleep_between: float = 0.2,  # Cortesía con PubChem: como máximo 5 solicitudes por segundo
) -> dict[str, np.ndarray]:
    """Crea un diccionario ingrediente INCI → embedding ECFP usando la caché de PubChem."""
    import time
    if cache_path.exists():
        return np.load(cache_path, allow_pickle=True).item()

    embeddings: dict[str, np.ndarray] = {}
    smiles_cache: dict[str, str | None] = {}
    for i, (inci_name, info) in enumerate(cosing_dict.items()):
        if i % 100 == 0:
            print(f"[{i}/{len(cosing_dict)}] calculando fingerprints")
        smiles = cas_to_smiles(info.cas, cache=smiles_cache)
        if smiles:
            embeddings[inci_name] = compute_ecfp(smiles)
        time.sleep(sleep_between)  # Respeta el límite de solicitudes de PubChem

    np.save(cache_path, embeddings, allow_pickle=True)
    return embeddings

from typing import Literal, NamedTuple


Severity = Literal["info", "warn", "avoid"]


class Rule(NamedTuple):
    kind: str                          # "conflict" · "allergen" · "pregnancy" · "user_avoid"
    ingredient_a: str
    ingredient_b: str | None            # None si la regla afecta a un solo ingrediente
    severity: Severity
    reason: str
    reference: str
    context: dict[str, str] = {}


CONFLICT_RULES: list[Rule] = [
    Rule(
        kind="conflict",
        ingredient_a="RETINOL",
        ingredient_b="GLYCOLIC ACID",
        severity="warn",
        reason="El uso simultáneo de retinoides y AHA puede causar irritación y eritema. Se recomienda separarlos entre la noche y la mañana.",
        reference="AAD (American Academy of Dermatology) retinoid guidelines",
    ),
    Rule(
        kind="conflict",
        ingredient_a="RETINOL",
        ingredient_b="SALICYLIC ACID",
        severity="warn",
        reason="El uso simultáneo de retinoides y BHA puede causar irritación y una exfoliación excesiva.",
        reference="Journal of the American Academy of Dermatology",
    ),
    Rule(
        kind="conflict",
        ingredient_a="RETINOL",
        ingredient_b="ASCORBIC ACID",
        severity="warn",
        reason="El retinol y la vitamina C pura tienen requisitos de pH incompatibles (retinol 5,5; vitamina C 3,5), con posibles problemas de estabilidad e irritación.",
        reference="Skin Therapy Letter, vitamin C stability review",
    ),
    Rule(
        kind="conflict",
        ingredient_a="BENZOYL PEROXIDE",
        ingredient_b="RETINOL",
        severity="avoid",
        reason="El BPO oxida y degrada el retinol, lo que reduce su efecto y puede irritar la piel.",
        reference="Journal of Drugs in Dermatology",
    ),
    Rule(
        kind="conflict",
        ingredient_a="NIACINAMIDE",
        ingredient_b="ASCORBIC ACID",
        severity="info",
        reason="Existe la hipótesis de que su uso conjunto a altas concentraciones genera ácido nicotínico; los estudios recientes no suelen observar problemas, aunque sigue siendo controvertido.",
        reference="Cosmetic Dermatology reviews · 2024 update",
    ),
]


PREGNANCY_AVOID: list[Rule] = [
    Rule(
        kind="pregnancy", ingredient_a=name, ingredient_b=None,
        severity="avoid",
        reason=f"Se recomienda evitar {name} durante el embarazo por evidencia de riesgo teratógeno o como medida preventiva.",
        reference="ACOG (American College of Obstetricians and Gynecologists) guidelines",
    )
    for name in [
        "RETINOL", "RETINALDEHYDE", "RETINYL PALMITATE", "TRETINOIN",
        "ADAPALENE", "TAZAROTENE",  # Familia de retinoides
        "SALICYLIC ACID",             # BHA en alta concentración
        "HYDROQUINONE",               # Despigmentante
    ]
]


EU_ALLERGENS_26 = [
    "LIMONENE", "LINALOOL", "CITRAL", "GERANIOL", "EUGENOL", "COUMARIN",
    "CITRONELLOL", "FARNESOL", "BENZYL ALCOHOL", "BENZYL BENZOATE",
    "BENZYL SALICYLATE", "BENZYL CINNAMATE", "CINNAMAL", "CINNAMYL ALCOHOL",
    "AMYLCINNAMAL", "AMYLCINNAMYL ALCOHOL", "HEXYL CINNAMAL",
    "HYDROXYCITRONELLAL", "HYDROXYISOHEXYL 3-CYCLOHEXENE CARBOXALDEHYDE",
    "ISOEUGENOL", "METHYL 2-OCTYNOATE", "ANISYL ALCOHOL", "ALPHA-ISOMETHYL IONONE",
    "EVERNIA PRUNASTRI EXTRACT", "EVERNIA FURFURACEA EXTRACT",
    "3-P-CUMENYL-2-METHYLPROPIONALDEHYDE",
]


def check_all_rules(
    inci_list: list[str],
    user_profile: dict,
) -> list[Rule]:
    """Compara los ingredientes del producto con las reglas y devuelve las aplicables."""
    triggered = []
    upper_set = {name.upper() for name in inci_list}

    # 1. Combinaciones incompatibles
    for rule in CONFLICT_RULES:
        if rule.ingredient_a in upper_set and (rule.ingredient_b or "") in upper_set:
            triggered.append(rule)

    # 2. Planificación del embarazo
    if user_profile.get("pregnancy_planning", False):
        for rule in PREGNANCY_AVOID:
            if rule.ingredient_a in upper_set:
                triggered.append(rule)

    # 3. Alergias e ingredientes que el usuario evita
    for avoid in user_profile.get("allergies", []) + user_profile.get("avoid_ingredients", []):
        if avoid.upper() in upper_set:
            triggered.append(Rule(
                kind="user_avoid",
                ingredient_a=avoid.upper(),
                ingredient_b=None,
                severity="avoid",
                reason=f"Indicación del usuario: evitar {avoid} o alergia declarada.",
                reference="user profile",
            ))

    # 4. Los 26 alérgenos de la UE (nivel informativo)
    for allergen in EU_ALLERGENS_26:
        if allergen in upper_set:
            triggered.append(Rule(
                kind="allergen",
                ingredient_a=allergen,
                ingredient_b=None,
                severity="info",
                reason="Incluido en la lista de 26 alérgenos de la UE; su presencia no implica necesariamente una reacción alérgica.",
                reference="EU Regulation (EC) 1223/2009 Annex III",
            ))

    return triggered

import torch
from transformers import SegformerImageProcessor, SegformerForSemanticSegmentation


class FacialLesionSegmenter:
    """Segmentación conceptual de lesiones faciales basada en SegFormer.

    En producción se recomienda un modelo ajustado para afecciones cutáneas, por ejemplo con un benchmark dermatológico ISIC.
    Este ejemplo es una referencia entrenada con imágenes naturales; para un servicio real es imprescindible volver a entrenarlo.
    """

    MODEL_ID = "nvidia/segformer-b0-finetuned-ade-512-512"  # Ejemplo; en producción debe ser específico para la piel

    def __init__(self, device: str = "cuda"):
        self.device = device
        self.processor = SegformerImageProcessor.from_pretrained(self.MODEL_ID)
        self.model = SegformerForSemanticSegmentation.from_pretrained(self.MODEL_ID).to(device).eval()

    @torch.no_grad()
    def segment(self, image: np.ndarray) -> dict:
        """Convierte una imagen RGB en un diccionario de máscaras de lesiones."""
        inputs = self.processor(images=image, return_tensors="pt").to(self.device)
        outputs = self.model(**inputs)
        logits = outputs.logits
        upsampled = torch.nn.functional.interpolate(
            logits, size=image.shape[:2], mode="bilinear", align_corners=False
        )
        pred_mask = upsampled.argmax(dim=1).squeeze().cpu().numpy()
        return {
            "mask": pred_mask,
            "class_ratios": {
                int(cls): float((pred_mask == cls).mean())
                for cls in np.unique(pred_mask)
            },
        }


LESION_TO_INGREDIENT_HINTS = {
    "acne": ["SALICYLIC ACID", "BENZOYL PEROXIDE", "NIACINAMIDE", "ZINC PCA"],
    "erythema": ["CENTELLA ASIATICA EXTRACT", "MADECASSOSIDE", "PANTHENOL"],
    "dryness": ["HYALURONIC ACID", "GLYCERIN", "CERAMIDE NP", "SQUALANE"],
    "hyperpigmentation": ["NIACINAMIDE", "ALPHA-ARBUTIN", "TRANEXAMIC ACID", "AZELAIC ACID"],
}

import anthropic


RECOMMEND_PROMPT = """Eres un asistente experto en ingredientes cosméticos y regulación.
Revisa el perfil del usuario y los productos candidatos y recomienda los tres mejores en lenguaje natural.

Perfil del usuario:
- Tipo de piel: {skin_type}
- Ingredientes de interés: {preferred}
- Ingredientes que evita y alergias: {avoid}
- Planificación del embarazo: {pregnancy}
- Historial de uso: {history}

Productos candidatos (cinco primeros ingredientes INCI):
{products_formatted}

Reglas detectadas (incompatibilidades, alergias y exclusiones durante el embarazo):
{rules_formatted}

Principios:
1. No favorezcas ni desacredites marcas concretas. Basa la respuesta únicamente en ingredientes, propiedades y reglas.
2. Justifica brevemente cada recomendación (3–5 frases): qué ingredientes principales responden al objetivo del usuario y cómo se gestionaron las reglas detectadas.
3. Incluye siempre al final: "Esta información es solo de referencia y no constituye asesoramiento médico. Para problemas de piel, consulta a un dermatólogo".
4. Si el usuario planea un embarazo y hay productos con retinoides entre los candidatos, recomienda evitarlos y sugiere alternativas como el bakuchiol.

Formato de respuesta: Markdown.
"""


def format_products(products: list[dict]) -> str:
    lines = []
    for i, p in enumerate(products, 1):
        top5 = ", ".join(p["inci_list"][:5])
        lines.append(f"{i}. {p['brand']} / {p['name']}\n   Cinco ingredientes principales: {top5}")
    return "\n".join(lines)


def format_rules(rules: list[Rule]) -> str:
    if not rules:
        return "No se detectaron reglas."
    lines = []
    for r in rules:
        if r.ingredient_b:
            pair = f"{r.ingredient_a} × {r.ingredient_b}"
        else:
            pair = r.ingredient_a
        lines.append(f"- [{r.severity}] {pair}: {r.reason} (fuente: {r.reference})")
    return "\n".join(lines)


def generate_recommendation(
    user_profile: dict,
    top_products: list[dict],
    all_rules: list[Rule],
    model: str = "claude-sonnet-4-5",
) -> str:
    """Genera con Claude el resumen final de recomendaciones en lenguaje natural."""
    client = anthropic.Anthropic()
    prompt = RECOMMEND_PROMPT.format(
        skin_type=user_profile.get("skin_type", ""),
        preferred=", ".join(user_profile.get("preferred", [])),
        avoid=", ".join(user_profile.get("avoid_ingredients", []) + user_profile.get("allergies", [])),
        pregnancy="sí" if user_profile.get("pregnancy_planning", False) else "no",
        history="; ".join(user_profile.get("history", [])),
        products_formatted=format_products(top_products),
        rules_formatted=format_rules(all_rules),
    )
    resp = client.messages.create(
        model=model,
        max_tokens=2048,
        messages=[{"role": "user", "content": prompt}],
    )
    return resp.content[0].text

def full_advisor_pipeline(
    user_profile: dict,
    face_image: np.ndarray | None,
    product_db: list[Product],
    ingredient_embeddings: dict[str, np.ndarray],
    top_k: int = 10,
) -> dict:
    """Perfil del usuario e imagen facial → productos recomendados, explicación y reporte de reglas."""
    # 1. Promedio de embeddings de los ingredientes preferidos por el usuario
    preferred = [p.upper() for p in user_profile.get("preferred", [])]
    pref_embs = [ingredient_embeddings[p] for p in preferred if p in ingredient_embeddings]
    user_emb = np.mean(pref_embs, axis=0) if pref_embs else None

    # 2. Combina ingredientes evitados, alergias y exclusiones durante el embarazo
    hard_avoid = {a.upper() for a in user_profile.get("avoid_ingredients", []) + user_profile.get("allergies", [])}
    if user_profile.get("pregnancy_planning", False):
        for rule in PREGNANCY_AVOID:
            hard_avoid.add(rule.ingredient_a)

    # 3. Puntuación de candidatos
    scored = []
    for prod in product_db:
        top5 = {i.upper() for i in prod.inci_list[:10]}
        # Excluye de inmediato si contiene un ingrediente estrictamente evitado
        if hard_avoid & top5:
            continue
        top5_embs = [
            ingredient_embeddings[i] for i in prod.inci_list[:5]
            if i in ingredient_embeddings
        ]
        if not top5_embs:
            continue
        prod_emb = np.mean(top5_embs, axis=0)
        if user_emb is not None:
            similarity = float(np.dot(prod_emb, user_emb) / (
                np.linalg.norm(prod_emb) * np.linalg.norm(user_emb) + 1e-8
            ))
        else:
            similarity = 0.5
        scored.append({
            "brand": prod.brand, "name": prod.name,
            "inci_list": prod.inci_list, "score": similarity,
            "categories": prod.categories, "image_url": prod.image_url,
        })

    # 4. Ordena los K mejores
    scored.sort(key=lambda x: -x["score"])
    top_products = scored[:top_k]

    # 5. Comprueba las reglas
    all_rules = []
    for prod in top_products:
        all_rules.extend(check_all_rules(prod["inci_list"], user_profile))

    # 6. Analiza las lesiones faciales si hay una imagen
    lesion_info = None
    if face_image is not None:
        segmenter = FacialLesionSegmenter()
        lesion_info = segmenter.segment(face_image)

    # 7. Recomendación en lenguaje natural con Claude
    recommendation = generate_recommendation(user_profile, top_products, all_rules)

    return {
        "recommended_products": top_products,
        "triggered_rules": [r._asdict() for r in all_rules],
        "lesion_analysis": lesion_info,
        "recommendation_text": recommendation,
        "disclaimer": "Esta información es solo de referencia y no constituye asesoramiento médico. Para problemas de piel, consulta a un dermatólogo.",
    }


# Ejemplo de ejecución (escenario de persona)
# user = {
#     "skin_type": "oily · acne-prone",
#     "preferred": ["NIACINAMIDE", "BAKUCHIOL", "ZINC PCA"],
#     "avoid_ingredients": ["ALCOHOL DENAT"],
#     "allergies": ["SALICYLIC ACID"],
#     "pregnancy_planning": True,
#     "history": ["La niacinamida funcionó durante 3 meses", "El BHA causó irritación durante 1 mes"],
# }
# result = full_advisor_pipeline(user, face_image=None, product_db=[...], ingredient_embeddings={...})
# print(result["recommendation_text"])