"""PLAN 349-0q sub7 — 되돌린 뒤 B05 누가토량이 열기 값(B06 안 다녀와도).

· 소수 자리 구조물 측점 · 저장 상세에 없는 세월교 측점 — 묶음 저장 노선 측점 ≠ 상세 측점(saved-diff)
· 열기 → 끌기 → 되돌리기 → 목록 다시 맞춤(가게 구조물 · 관을 같은 목록 다른 꼴로 다시 씀) = 열기 값 ·
  상세 = 열 때 객체 그대로 · 갈아끼움 없음 · 다시 셈 0
· 되돌리기 · 다시 하기 = 진짜 페이지 사진첩(세션 되씀 → 종단도 편집 가게 다시 읽음 → 다리 알림)
· 다시 하기 · 되돌리기 · 횡단 보기 · 종단 보기도 = 349-0o 값
짝: `helper_349_0q_undo_echo.cjs`(실제 TS 를 Node 로 · 화면 부품 · 서버 창구만 가짜).
"""

from __future__ import annotations

import csv
import json
import subprocess
import sys
import tempfile
from pathlib import Path

import pytest

HERE = Path(__file__).resolve().parent
ROOT = HERE.parents[1]
if str(ROOT) not in sys.path:
    sys.path.insert(0, str(ROOT))

from B05_Profile.B05_Profile_Structures_Schema import structure_type_map  # noqa: E402
from common_util.common_util_surface_sampler import dtm_grid_bytes  # noqa: E402
from config.config_system_design import STANDARD_CROSS_SECTION  # noqa: E402

pytestmark = pytest.mark.skipif(
    not (ROOT / "config" / "node_modules" / "typescript").is_dir(),
    reason="프론트엔드 의존성 미설치",
)

PROJECT = ROOT / "storage/1/3/6d3b2812-6d5a-4168-a932-40e4ae303d5a"  # 검증_sub7
ROUTE = PROJECT / "B05_Profile/route"
SECTION = PROJECT / "B06_Section"
GRID = PROJECT / "B04_PreProcess/models/dtm_classification_smooth.npz"
ONES = {g: {"loose": 1.0, "compacted": 1.0} for g in ("soil", "ripping_rock", "blasting_rock")}


def _csv(path: Path) -> list[list[float]]:
    with path.open(encoding="utf-8") as handle:
        return [[float(r["x"]), float(r["y"])] for r in csv.DictReader(handle)]


def _json(path: Path):
    return json.loads(path.read_text(encoding="utf-8"))


def _between(sections: list[dict], index: int) -> dict:
    """두 측점 사이 한 점(0.37) — 누가거리 · 좌표."""
    a, b = sections[index], sections[index + 1]
    k = 0.37
    return {
        "chainage_m": round(a["chainage_m"] + k * (b["chainage_m"] - a["chainage_m"]), 2),
        "x": a["center_x"] + k * (b["center_x"] - a["center_x"]),
        "y": a["center_y"] + k * (b["center_y"] - a["center_y"]),
    }


def build_job() -> dict:
    """입력 한 벌 — 356-4 시험도 빌림."""
    if not (GRID.is_file() and (SECTION / "longitudinal/longitudinal.json").is_file()):
        pytest.skip("검증_sub7 없음")
    curves = _json(ROUTE / "planned_route_curves.json")
    sections = sorted(
        (_json(p) for p in (SECTION / "cross_sections").glob("cross_*.json")),
        key=lambda s: s["chainage_m"],
    )
    pipes = _json(PROJECT / "B04_PreProcess/drainage/edits/pipe_points.json")["points"]
    # 세월교 하나 더(측점 사이) — 저장 상세엔 그 측점이 없음 = 묶음 저장 노선 측점과 다름(검증_sub7 세월교 2 + 1)
    pipes = [*pipes, {"source": "manual", "facility": "ford_bridge", **_between(sections, -6)}]
    # 저장 횡단 면적 = 서버가 상세를 낼 때 셈(파일엔 없음) — 정본 대신 정한 값
    for i, section in enumerate(sections):
        section["design"] = {
            "ground_type": "soil",
            "design_elevation_m": section["center_z"],
            "cut_area_m2": 4.0 + (i % 5),
            "fill_area_m2": 1.5 + (i % 3),
        }
    job = {
        "line": _csv(ROUTE / "planned_route.csv"),
        "nodes": _csv(ROUTE / "planned_route_nodes.csv"),
        "curves": [
            {k: c[k] for k in ("start", "apex", "end", "radius_m")} for c in curves["curves"]
        ],
        "stationSnap": bool(curves.get("station_snap")),
        "minRadius": curves["min_radius_m"],
        "interval": 20.0,
        "types": [
            {"type_id": t.type_id, "group": t.group, "placement": t.placement}
            for t in structure_type_map().values()
        ],
        "pipes": pipes,
        "standard": STANDARD_CROSS_SECTION,
        "conversion": ONES,
        # 구조물 하나 — 첫 관 자리 횡단배수(같은 측점을 덮음)
        "structures": [
            {
                "structure_id": "s-349o",
                "type_id": "cross_drain_exposed",
                "chainage_m": pipes[0]["chainage_m"],
                "x": pipes[0]["x"],
                "y": pipes[0]["y"],
            },
            # 소수 자리 측점 구조물(측점 사이 · 저장 상세엔 없음)
            {"structure_id": "s-349q", "type_id": "cross_drain_exposed", **_between(sections, 8)},
        ],
        # 열기 전에 고친 카드 선택 — 끌면 밀리는 측점(뒤쪽) · 단면 유형은 노선이 바뀌면 안 넘기는 칸
        "touched": {
            str(sections[-3]["chainage_m"]): {
                "ground_type": "blasting_rock",
                "section_mode": "right_cut",
            }
        },
        "detail": {
            "longitudinal": _json(SECTION / "longitudinal/longitudinal.json"),
            "cross_sections": sections,
        },
    }
    return job


@pytest.fixture(scope="module")
def r() -> dict:
    job = build_job()
    with tempfile.TemporaryDirectory() as folder:
        path = Path(folder) / "job.json"
        path.write_text(json.dumps(job), encoding="utf-8")
        grid = Path(folder) / "grid.bin"
        grid.write_bytes(dtm_grid_bytes(GRID))
        proc = subprocess.run(  # noqa: S603 — 고정 실행 파일
            ["node", str(HERE / "helper_349_0q_undo_echo.cjs"), str(path), str(grid)],
            capture_output=True,
            text=True,
            encoding="utf-8",
            timeout=300,
        )
    assert proc.returncode == 0, proc.stderr
    return json.loads(proc.stdout)


def _same(a: dict, b: dict) -> None:
    assert a["final"] == b["final"]
    assert a["cross"] == b["cross"]
    assert a["stations"] == b["stations"]


def test_되돌리기_열기_객체_그대로(r):
    o, u = r["open"], r["back1"]
    assert u["undone"]  # 진짜 사진첩 되돌리기(종단도 편집 가게 다시 읽음)
    assert [(x["restored"], x["why"]) for x in u["runs"]] == [(True, "saved-diff")], u["runs"]
    assert r["back1Same"]  # 열 때 상세 객체(횡단 초안 측점 장부가 묶인 것)
    assert u["refresh"] == 0 and u["lastKey"] == ""
    _same(u, o)
    d = r["restoreDiffs"][0]
    assert d["pipeline"] > d["saved"] and isinstance(d["pipelineM"], float)


def test_메아리_차례_갈아끼움_없음_열기_값(r):
    o, e = r["open"], r["echo"]
    assert [x["outcome"] for x in e["runs"]], e["runs"]  # 묶음이 실제로 돎
    assert all(x["outcome"] == "done" for x in e["runs"]), e["runs"]
    assert e["sameObject"]  # 같은 측점 목록 — 가게에 다시 안 냄 · 상세 그대로
    assert e["refresh"] == 0 and e["lastKey"] == "" and e["drawnSaved"]
    _same(e, o)
    assert e["cells"] == o["cells"]


def test_다시_하기_되돌리기_횡단_보기(r):
    o, f = r["open"], r["first"]
    assert r["redo"]["redone"] and r["back2"]["undone"]
    assert r["redo"]["final"] == f["final"] and r["redo"]["cross"] == f["cross"]
    for step in (r["back2"], r["cross"], r["back"]):
        assert step["refresh"] == 0
        _same(step, o)
    assert r["blocked"] == 0