import json
import logging
import os
import time
import urllib.parse
import urllib.request
from datetime import date

from legex.models.base import Case
from legex.scrapers.base import BaseScraper

log = logging.getLogger(__name__)

API = "https://www.law.go.kr/DRF/lawSearch.do"
USER_AGENT = "LegEx/1.0 South Korea precedent API"
DEFAULT_QUERY = "손해배상"
DEFAULT_DISPLAY = 100
MAX_RESULTS = 130
DELAY_SECONDS = 0.2


def _request_json(params: dict[str, str]) -> dict:
    query = urllib.parse.urlencode(params)
    req = urllib.request.Request(
        f"{API}?{query}",
        headers={"User-Agent": USER_AGENT},
    )
    with urllib.request.urlopen(req, timeout=60) as response:
        return json.loads(response.read().decode("utf-8"))


def _normalize_date(raw: str) -> str:
    if len(raw) == 8 and raw.isdigit():
        return f"{raw[:4]}-{raw[4:6]}-{raw[6:]}"
    return raw


class KRScraper(BaseScraper):
    country = "Südkorea"

    def __init__(self) -> None:
        self._oc = os.environ.get("LAW_GO_KR_OC", "").strip()
        if not self._oc:
            raise ValueError("LAW_GO_KR_OC is required. Set a registered law.go.kr Open API OC value.")
        self._query = os.environ.get("LAW_GO_KR_QUERY", DEFAULT_QUERY)

    def scrape(
        self,
        start_date: date | None = None,
        end_date: date | None = None,
    ) -> list[Case]:
        cases: list[Case] = []
        page = 1
        while len(cases) < MAX_RESULTS:
            params = {
                "OC": self._oc,
                "target": "prec",
                "type": "JSON",
                "query": self._query,
                "display": str(DEFAULT_DISPLAY),
                "page": str(page),
            }
            data = _request_json(params)
            if "result" in data and "실패" in str(data.get("result")):
                raise RuntimeError(json.dumps(data, ensure_ascii=False))

            prec = data.get("PrecSearch") or data.get("precSearch") or data
            items = prec.get("prec") or prec.get("items") or []
            if isinstance(items, dict):
                items = [items]
            if not items:
                break

            for item in items:
                court = str(item.get("법원명") or item.get("courtName") or "")
                if court and "대법원" not in court:
                    continue

                raw_date = str(item.get("선고일자") or item.get("decisionDate") or "")
                iso_date = _normalize_date(raw_date)
                decision_date: date | None = None
                if iso_date:
                    try:
                        decision_date = date.fromisoformat(iso_date)
                    except ValueError:
                        decision_date = None

                if start_date and decision_date and decision_date < start_date:
                    continue
                if end_date and decision_date and decision_date > end_date:
                    continue

                case_no = str(item.get("사건번호") or item.get("caseNo") or item.get("판례일련번호") or "")
                title = str(item.get("사건명") or item.get("caseName") or item.get("판례명") or "")
                serial = str(item.get("판례일련번호") or item.get("ID") or "")
                link = f"https://www.law.go.kr/precInfoP.do?precSeq={serial}" if serial else ""

                cases.append(Case(
                    case_id=case_no or serial or None,
                    link=link or None,
                    decision_date=decision_date,
                    jurisdiction="kr",
                    language="ko",
                    full_text=None,
                    metadata={"case_title": title} if title else {},
                ))
                if len(cases) >= MAX_RESULTS:
                    break

            page += 1
            time.sleep(DELAY_SECONDS)

        cases.sort(key=lambda c: c.decision_date or date.min, reverse=True)
        log.info("Collected %d South Korea Supreme Court cases", len(cases))
        return cases