from __future__ import annotations

import json
import re
from typing import Any

from src.domain import Family, InventoryInstance


def extract_json(text: str) -> dict[str, Any] | None:
    if not text or not str(text).strip():
        return None
    raw = str(text).strip()
    candidates = [raw]
    fenced = re.findall(r"```(?:json)?\s*(\{.*?\})\s*```", raw, flags=re.S)
    candidates.extend(fenced)
    start = raw.find("{")
    end = raw.rfind("}")
    if start >= 0 and end > start:
        candidates.append(raw[start : end + 1])
    for item in candidates:
        try:
            payload = json.loads(item)
        except json.JSONDecodeError:
            continue
        if isinstance(payload, dict) and payload:
            if "schema_payload" in payload and isinstance(payload["schema_payload"], dict):
                return payload["schema_payload"]
            return payload
    return None


def extract_template(text: str, family: Family | str) -> dict[str, Any] | None:
    family = Family(family)
    if not text:
        return None
    labeled = _extract_labeled_blocks(text)
    if labeled:
        return labeled
    if family == Family.INVENTORY:
        return _extract_inventory_prose(text)
    return None


def _extract_labeled_blocks(text: str) -> dict[str, Any] | None:
    blocks = re.findall(r"SCHEMA_BEGIN\s*(\{.*?\})\s*SCHEMA_END", text, flags=re.S)
    for block in blocks:
        try:
            payload = json.loads(block)
        except json.JSONDecodeError:
            continue
        if isinstance(payload, dict):
            return payload
    return None


def _extract_inventory_prose(text: str) -> dict[str, Any] | None:
    budget = _first_int(text, r"(?:BUDGET|budget|بودجه)\s*[:=]?\s*(\d+)")
    capacity = _first_int(text, r"(?:CAPACITY|capacity|ظرفیت انبار)\s*[:=]?\s*(\d+)")
    periods = _first_int(text, r"(?:PERIODS|periods|دوره)\s*[:=]?\s*(\d+)")
    cover = bool(re.search(r"COVER_REQUIRED:\s*1|cover is required|پوشش کامل الزامی", text, flags=re.I))
    sku_lines = re.findall(
        r"SKU\s+([A-Za-z0-9_-]+).*?demand=([0-9,]+).*?pack=(\d+).*?cost=(\d+).*?hold=(\d+).*?short=(\d+).*?stock=(\d+)",
        text,
        flags=re.I,
    )
    if budget is None or not sku_lines:
        return None
    skus = []
    for sku_id, demand, pack, cost, hold, short, stock in sku_lines:
        values = [int(item) for item in demand.split(",") if item.strip().isdigit()]
        skus.append(
            {
                "sku_id": sku_id,
                "name": sku_id,
                "demand": values,
                "initial_stock": int(stock),
                "unit_cost": int(cost),
                "holding_cost": int(hold),
                "shortage_cost": int(short),
                "pack_size": int(pack),
                "lead_time": 0,
            }
        )
    periods = periods or (len(skus[0]["demand"]) if skus else 0)
    try:
        InventoryInstance.model_validate(
            {
                "periods": periods,
                "budget": budget,
                "warehouse_capacity": capacity if capacity is not None else 10**6,
                "cover_required": cover,
                "lost_sales": True,
                "skus": skus,
            }
        )
    except Exception:
        return None
    return {
        "periods": periods,
        "budget": budget,
        "warehouse_capacity": capacity if capacity is not None else 10**6,
        "cover_required": cover,
        "lost_sales": True,
        "skus": skus,
    }


def _first_int(text: str, pattern: str) -> int | None:
    match = re.search(pattern, text, flags=re.I)
    if not match:
        return None
    return int(match.group(1))


def flatten_facts(family: Family | str, payload: dict) -> dict[str, str]:
    family = Family(family)
    facts: dict[str, str] = {}
    if family == Family.INVENTORY:
        facts["periods"] = str(payload.get("periods"))
        facts["budget"] = str(payload.get("budget"))
        facts["warehouse_capacity"] = str(payload.get("warehouse_capacity"))
        facts["cover_required"] = str(bool(payload.get("cover_required")))
        for sku in payload.get("skus") or []:
            key = sku.get("sku_id")
            facts[f"{key}.demand"] = ",".join(str(int(v)) for v in sku.get("demand") or [])
            facts[f"{key}.pack"] = str(sku.get("pack_size"))
            facts[f"{key}.cost"] = str(sku.get("unit_cost"))
            facts[f"{key}.stock"] = str(sku.get("initial_stock"))
            facts[f"{key}.hold"] = str(sku.get("holding_cost"))
            facts[f"{key}.short"] = str(sku.get("shortage_cost"))
    elif family == Family.ASSIGNMENT:
        facts["n_tasks"] = str(len(payload.get("tasks") or []))
        facts["n_agents"] = str(len(payload.get("agents") or []))
        for task in payload.get("tasks") or []:
            facts[f"task.{task.get('task_id')}.size"] = str(task.get("size"))
            facts[f"task.{task.get('task_id')}.required"] = str(bool(task.get("required")))
            facts[f"task.{task.get('task_id')}.skills"] = ",".join(sorted(task.get("skills") or []))
        for agent in payload.get("agents") or []:
            facts[f"agent.{agent.get('agent_id')}.cap"] = str(agent.get("capacity"))
            facts[f"agent.{agent.get('agent_id')}.skills"] = ",".join(sorted(agent.get("skills") or []))
        for row in payload.get("costs") or []:
            facts[f"cost.{row.get('task_id')}.{row.get('agent_id')}"] = str(row.get("cost"))
    else:
        facts["machines"] = ",".join(payload.get("machines") or [])
        for job in payload.get("jobs") or []:
            jid = job.get("job_id")
            facts[f"job.{jid}.dur"] = str(job.get("duration"))
            facts[f"job.{jid}.rel"] = str(job.get("release"))
            facts[f"job.{jid}.due"] = str(job.get("due"))
            facts[f"job.{jid}.w"] = str(job.get("weight"))
            facts[f"job.{jid}.hard"] = str(bool(job.get("hard_due")))
            facts[f"job.{jid}.m"] = ",".join(sorted(job.get("machine_eligible") or []))
        for idx, edge in enumerate(payload.get("precedences") or []):
            facts[f"pred.{idx}"] = f"{edge.get('before')}->{edge.get('after')}"
    return facts


def constraint_fidelity(family: Family | str, gold: dict, extracted: dict | None) -> float | None:
    if extracted is None:
        return 0.0
    gold_facts = flatten_facts(family, gold)
    got = flatten_facts(family, extracted)
    if not gold_facts:
        return 1.0
    hits = sum(1 for key, value in gold_facts.items() if got.get(key) == value)
    return hits / len(gold_facts)


def drop_constraint(family: Family | str, payload: dict, prompt: str) -> tuple[dict, str]:
    family = Family(family)
    clone = json.loads(json.dumps(payload))
    if family == Family.INVENTORY:
        clone["budget"] = 10**9
        stripped = re.sub(r"(BUDGET|budget|بودجه)\s*[:=]?\s*\d+", "BUDGET omitted", prompt)
        return clone, stripped
    if family == Family.ASSIGNMENT:
        for agent in clone.get("agents") or []:
            agent["capacity"] = 10**6
        stripped = re.sub(r"(capacity|ظرفیت)\s*[:=]?\s*\d+", "capacity omitted", prompt, flags=re.I)
        return clone, stripped
    for job in clone.get("jobs") or []:
        job["hard_due"] = False
        job["due"] = job.get("due", 0) + 10**4
    stripped = re.sub(r"(hard due|موعد سخت)", "due relaxed", prompt, flags=re.I)
    return clone, stripped