# -*- coding: utf-8 -*-
"""품셈재료 단가 — 연결을 따라 자재품목 줄의 값 열 다섯 가운데 낮은 값 (`_틀.md` 4장 재료 값).

⚠ 낮은 값 고르기는 **시험 계산용**. 최저가·견적 고르기는 프로젝트 몫 — 마스터는 값을 모으기만 함.

`master_formula` 가 요소 값을 풀 때 부름. 서로 부르는 모듈이라 `master_formula` 는 끝에서 읽음.
"""

from __future__ import annotations

import re
import unicodedata
from decimal import Decimal

LINKED = "MP"  # 품셈재료 테이블ID
MARKET = "MT"  # 자재품목 테이블ID
PRICED = "MO"  # 유가전력 테이블ID — 값 한 칸
SLOTS = ("물가자료", "유통물가", "물가정보", "거래가격", "관급")  # 자재품목 값 열
PICK_KEYS = ("구분", "상세구분", "규격", "대표")  # 재료 고르기 조건 칸 (`_틀.md` 7장)
REGION = "자재지역"  # 로직 입력 — 「지역」 은 유가 고르기가 씀
TARIFF = "전력 계약종별"  # 로직 입력 — 품셈·계약예규에 계약종별 규정 없음
_UNITS = {"ea": "개", "ton": "톤", "t": "톤", "l": "ℓ", "리터": "ℓ", "set": "조", "세트": "조"}


def plain(s) -> str:
    """이름 맞대기 — NFKC · 소문자 · 빈칸 없앰 · 지름 기호 하나로."""
    s = unicodedata.normalize("NFKC", str(s or "")).lower()
    return re.sub(r"\s+", "", re.sub(r"[φΦ∅⌀]", "ø", s))


def plain_spec(s) -> str:
    return plain(s).replace("×", "x").replace("*", "x")


def plain_unit(s) -> str:
    s = plain(s).replace("ℓ", "l")
    return _UNITS.get(s, s)


def _offers(master: mf.Master, key: str) -> list[tuple[Decimal, str]]:
    """줄 하나의 (값, 출처) — 자재품목은 값이 있는 열마다 하나 · 그 밖(유가전력)은 「값」 한 칸."""
    row = master.get(key)
    if key[:2] != MARKET:
        return [(row["값"], f"{row['키']}.값")] if row.get("값") is not None else []
    return [(row[slot], f"{row['키']}.{slot}") for slot in SLOTS if row.get(slot) is not None]


def _lowest(master: mf.Master, key: str) -> tuple[object, str | None]:
    """자재품목 줄의 낮은 값 — ⚠ 시험 계산용."""
    offers = _offers(master, key)
    return min(offers, key=lambda x: x[0]) if offers else (None, None)


def _market_index(master: mf.Master) -> list[tuple[str, str, str, str, str]]:
    """(품명 뿌리, 이름, 규격, 단위, 키) — 「레미콘(관급)-경상북도(울진군)」 뿌리 = 레미콘."""
    if not hasattr(master, "_market"):
        master._market = []
        for key, row in master.index.get("MT", {}).items():
            name = plain(row.get("이름"))
            root = re.sub(r"\(.*?\)", "", name.split(",")[0]).split("-")[0]
            master._market.append(
                (root, name, plain_spec(row.get("규격")), plain_unit(row.get("단위")), key)
            )
    return master._market


def _tariff(master: mf.Master, ref: str, row: dict, env: dict) -> list[str]:
    """후보 조건{이름 · 계약종별: 입력} — 유가전력 전력 줄 가운데 그 계약종별·이름으로 시작하는 줄."""
    cond = row["연결"]
    if TARIFF not in env:
        raise mf.FormulaError(f"「{master.label(ref)}」 입력 「{TARIFF}」 없음")
    want, kind = plain(cond["이름"]), plain(env[TARIFF])
    hits = [
        key
        for key, one in master.index.get(PRICED, {}).items()
        if one.get("구분") == "전력"
        and plain(one.get("상세구분")) == kind
        and plain(one.get("이름")).startswith(want)
        and one.get("값") is not None
    ]
    if not hits:
        raise mf.FormulaError(f"「{master.label(ref)}」 계약종별 값 없음 — {env[TARIFF]}")
    return hits


def _candidates(master: mf.Master, ref: str, row: dict, env: dict) -> list[str]:
    """후보 조건{이름 · 규격 · 지역: 입력} — 뿌리가 이름으로 끝나고 이름에 지역 글자 · 단위 같음."""
    cond = row["연결"]
    if cond.get("계약종별") == "입력":
        return _tariff(master, ref, row, env)
    if cond.get("지역") == "입력" and REGION not in env:
        raise mf.FormulaError(f"「{master.label(ref)}」 입력 「{REGION}」 없음")
    region = plain(env.get(REGION, "")) if cond.get("지역") == "입력" else ""
    want, spec, unit = plain(cond["이름"]), plain_spec(cond.get("규격")), plain_unit(row["단위"])
    hits = [
        (s, key)
        for root, name, s, u, key in _market_index(master)
        if root.endswith(want) and region in name and u == unit and (not spec or s == spec)
    ]
    hits = [(s, key) for s, key in hits if _offers(master, key)]
    if not hits:
        raise mf.FormulaError(f"「{master.label(ref)}」 지역 값 없음 — {env.get(REGION)}")
    if len({s for s, _ in hits}) > 1:
        raise mf.FormulaError(f"「{master.label(ref)}」 후보 여럿 — 규격 선택 필요 ({len(hits)}줄)")
    return [key for _, key in hits]


# ── 재료 고르기 ────────────────────────────────────────────────────────
def static(cond: dict) -> dict:
    """검사용 조건 — 값에 `{입력}` 이 든 칸은 뺌(계산 때 채워짐)."""
    return {k: v for k, v in cond.items() if not (isinstance(v, str) and "{" in v)}


def cond_text(cond: dict) -> str:
    """고르기 조건 한 글자 열쇠 — 「구분|상세구분|규격|대표」 · 화면 단가 미리보기가 줄을 찾는 이름."""
    return "|".join(str(cond.get(k) or "") for k in PICK_KEYS)


def candidates(
    master: mf.Master, cond: dict, env: dict | None = None, unit: str | None = None
) -> list[str]:
    """고르기 조건 안 자재품목 키 — 구분 · 상세구분 · 규격 낱말이 모두 든 줄 · 파일 차례대로.
    `unit` 을 주면 그 단위(호표 줄 단위)와 같은 줄만 — 단위가 다르면 다른 물건.
    입력 `자재지역` 이 있으면 이름에 그 지역이 든 줄만(그런 줄이 없으면 조건 안 전부)."""
    want = [plain_spec(w) for w in str(cond.get("규격") or "").split()]
    detail = cond.get("상세구분")
    need = plain_unit(unit) if unit else ""
    hits = [
        key
        for key, row in master.index.get(MARKET, {}).items()
        if row.get("구분") == cond.get("구분")
        and (not detail or row.get("상세구분") == detail)
        and all(w in plain_spec(row.get("규격")) for w in want)
        and (not need or plain_unit(row.get("단위")) == need)
    ]
    region = plain((env or {}).get(REGION, ""))
    near = [k for k in hits if region in plain(master.get(k).get("이름"))] if region else []
    return near or hits


def pick(master: mf.Master, cond: dict, env: dict, unit: str | None = None) -> str:
    """시험 계산이 쓸 줄 — 관리자가 정한 `대표`, 없으면 조건 안 값 있는 첫 줄(단위 같은 줄만)."""
    if cond.get("대표"):
        return str(cond["대표"])
    keys = candidates(master, cond, env, unit)
    keys = [k for k in keys if _offers(master, k)] or keys
    if not keys:
        raise mf.FormulaError(f"재료 고르기 후보 없음 — {cond}")
    return keys[0]


def check_unit(master: mf.Master, where: str, cond: dict, unit: str | None) -> list[str]:
    """단위 경고 — 호표 줄·품셈재료 줄 단위와 맞는 후보가 없거나 대표 줄 단위가 다름.
    틀린 데이터가 아니라 좁혀야 할 조건이라 `check_pick` 과 따로 봄(`check_master 단위`)."""
    cond = static(cond)
    rows = master.index.get(MARKET, {})
    rep = str(cond.get("대표") or "")
    if not unit or set(cond) - set(PICK_KEYS) or not cond.get("구분"):
        return []  # 구분·규격이 `{입력}` 이면 좁힐 것이 없어 여기서 뺌
    if rep in rows:
        if plain_unit(rows[rep].get("단위")) != plain_unit(unit):
            return [
                f"{where} · 대표 줄 단위 「{rows[rep].get('단위')}」 이 줄 단위 「{unit}」 과 다름"
            ]
        return []
    if candidates(master, cond) and not candidates(master, cond, None, unit):
        return [f"{where} · 단위 「{unit}」 후보 0 — 조건 안 줄은 모두 다른 단위"]
    return []


def check_pick(master: mf.Master, where: str, cond: dict, unit: str | None = None) -> list[str]:
    """고르기 조건 검사 — 칸 이름 · 구분·상세구분이 자재품목에 있는지 · 대표 줄 · 후보 0.
    값에 `{입력}` 이 든 칸(관경 등)은 계산 때 채워지므로 검사에서 뺌."""
    if set(cond) - set(PICK_KEYS) or not cond.get("구분"):
        return [f"{where} · 재료 고르기 조건 모양 「{cond}」 — {' · '.join(PICK_KEYS)}"]
    cond = static(cond)
    if not cond.get("구분"):  # 구분 자체가 `{입력}` — 계산 때 채워져 여기서 좁힐 것이 없음
        return []
    out, rows = [], master.index.get(MARKET, {})
    for slot in ("구분", "상세구분"):
        if cond.get(slot) and not any(r.get(slot) == cond[slot] for r in rows.values()):
            out.append(f"{where} · 자재품목에 없는 {slot} 「{cond[slot]}」")
    rep = cond.get("대표")
    if rep and str(rep) not in rows:
        out.append(f"{where} · 대표 줄 「{rep}」 이 자재품목에 없음")
    elif rep and str(rep) not in candidates(master, cond):
        out.append(f"{where} · 대표 줄 「{rep}」 이 고르기 조건 밖")
    if not out and not candidates(master, cond):
        out.append(f"{where} · 재료 고르기 후보 0")
    return out


def element(
    master: mf.Master, ref, env: dict, unit: str | None = None
) -> tuple[object, str | None]:
    """요소 값과 출처 — 자재품목은 제 줄, 품셈재료는 연결을 따라가 낮은 값 · 그 밖은 줄의 `값`.
    `ref` 가 고르기 조건 묶음이면 대표 줄(없으면 단위 같은 조건 안 첫 줄)로 풂."""
    if isinstance(ref, dict):
        ref = pick(master, ref, env, unit)
    row = master.get(ref)
    if ref[:2] == MARKET:  # 자재품목을 바로 가리키는 호표 줄
        return _lowest(master, ref)
    if ref[:2] != LINKED:
        return master.value(ref)
    link = row.get("연결")
    if not link:
        return None, None
    keys = [link] if isinstance(link, str) else _candidates(master, ref, row, env)
    offers = [x for key in keys for x in _offers(master, key)]
    return min(offers, key=lambda x: x[0]) if offers else (None, None)


import master_formula as mf  # noqa: E402 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음