"""PLAN 536-1 — E06 암반 평사투영 · Markland · Hoek-Bray 평면 · 쐐기 (요구 345 · 351).

기준 예제(문헌 값 · Rocscience 검증서가 옮긴 값):
- 평면 = Hoek(Sau Mau Ping, 『Practical Rock Engineering』 7장 · RocPlane 검증 #1) 균열 없음 0.8184254 ·
  임계 균열 + 수위 0.9z 1.0654738 / Sharma 외(1995) 윗면 0~30° 무게(RocPlane 검증 #2)
- 쐐기 = Hoek & Bray 쐐기 계수(대칭 쐐기 마찰만 · 해석해) · Kovári & Fritz · Kumsar 외(2000) 실험 ·
  Priest(1993) 두 예제(SWedge 검증 #1~#7 값)
- Markland 경계 · 투영 왕복 · 위험 영역 = 판정 부등식
"""

import math

import numpy as np
import pytest

from E06_StabRock import E06_StabRock_Engine as eng
from E06_StabRock import E06_StabRock_Model as model
from E06_StabRock import E06_StabRock_Stereonet as net

TOL = 0.02  # 완료 기준 ±2 %


def close(value, expect, tol=TOL):
    assert value == pytest.approx(expect, rel=tol), (value, expect)


# ---- 평면 (Hoek-Bray) -------------------------------------------------------------
SAU_MAU = dict(
    H=60, slope_dip=50, plane_dip=35, c=100, phi=35, gamma=27, kh=0.08, gamma_w=10
)  # MN → kN · 0.1 MPa = 100 kPa


def test_plane_hoek_no_crack():
    r = eng.plane_fs(**SAU_MAU, water_fill=1.0)
    close(r["F"], 0.8184254, 1e-4)
    close(r["W"], 28627.8, 1e-4)
    close(r["A"], 104.6068, 1e-5)
    close(r["U"], 15691.0, 1e-4)


def test_plane_hoek_tension_crack():
    z = eng.plane_critical_depth_hoek(60, 50, 35)
    close(z, 14.0092, 1e-5)
    r = eng.plane_fs(**SAU_MAU, water_fill=0.9, crack={"mode": "depth", "z": z})
    close(r["F"], 1.0654738, 1e-4)
    close(r["W"], 24843.9, 1e-4)
    close(r["A"], 80.1826, 1e-5)
    close(r["crack_b"], 15.3357, 1e-4)  # 마루 뒤 거리(RocPlane 검증 #1)


def test_wet_default_kds_half_depth():
    """KDS 11 70 05 표 4.3-3 암반 우기 = 균열 · 활동면 높이 ½ 심도 포화 · 기준 1.2."""
    import json
    from pathlib import Path

    fill = model.DEFAULT_SETTINGS["water_fill_wet"]
    assert fill == 0.5
    z = 10.0
    r = eng.plane_fs(**SAU_MAU, water_fill=fill, crack={"mode": "depth", "z": z})
    close(r["V"], 0.5 * 10 * (z / 2) ** 2, 1e-9)  # 균열 안 수위 = z/2
    dry = eng.plane_fs(**SAU_MAU)  # 균열 없음 = 활동면 오름 60 · 가운데 수두 = (½ · 60)/2
    close(eng.plane_fs(**SAU_MAU, water_fill=fill)["U"], 0.5 * 10 * 15 * dry["A"], 1e-9)
    root = Path(__file__).resolve().parents[2]
    ground = json.loads(
        (root / "resources/master_template/stability/ground_defaults.json").read_text("utf-8")
    )
    assert ground["safety_factors"]["wet"]["cut"] == 1.2


def test_plane_critical_crack_search_matches_hoek():
    """건조 · 윗면 수평 — 수치 탐색 임계 자리 = Hoek-Bray 식 z · b."""
    r = eng.plane_fs(
        H=60, slope_dip=50, plane_dip=35, c=20, phi=35, gamma=27, crack={"mode": "critical"}
    )
    close(r["z"], eng.plane_critical_depth_hoek(60, 50, 35), 1e-4)
    close(r["crack_b"], 15.3357, 1e-4)


@pytest.mark.parametrize(
    "upper,weight,fs,fill",
    [
        (0, 2392.38, 1.58612, 1.00),
        (10, 2446.29, 1.58148, 0.84),
        (20, 2503.66, 1.58382, 0.71),
        (30, 2568.90, 1.57849, 0.61),
    ],
)
def test_plane_upper_slope_sharma(upper, weight, fs, fill):
    """윗면 기운 사면 · 연직 균열 마루 뒤 15.336 m · 균열 수위(RocPlane 정수 %)."""
    kw = dict(
        H=60, slope_dip=50, plane_dip=35, c=12, phi=45, gamma=2.6, gamma_w=1.0, upper_dip=upper
    )
    r = eng.plane_fs(**kw, crack={"mode": "x", "b": 15.33576}, water_fill=fill)
    close(r["W"], weight, 1e-4)
    close(r["F"], fs)


def test_plane_bolt_vector():
    """수동 볼트 — 저항 += T cos(θ+ψp) + T sin(θ+ψp) tanφ (힘 벡터 풀이)."""
    base = dict(H=10, slope_dip=60, plane_dip=35, c=10, phi=30, gamma=25)
    r0 = eng.plane_fs(**base)
    r1 = eng.plane_fs(**base, bolt_t=100, bolt_plunge=15)
    a = math.radians(50)
    expect = (
        r0["resist"] + 100 * math.cos(a) + 100 * math.sin(a) * math.tan(math.radians(30))
    ) / r0["drive"]
    close(r1["F"], expect, 1e-9)


def test_plane_not_formed():
    assert eng.plane_fs(H=10, slope_dip=40, plane_dip=45, c=0, phi=30, gamma=25) is None
    # 윗면이 활동면보다 가파르면 덩이 안 생김(균열 없음)
    assert (
        eng.plane_fs(H=10, slope_dip=60, plane_dip=30, c=0, phi=20, gamma=25, upper_dip=35) is None
    )


# ---- 쐐기 (Hoek-Bray · SWedge 꼴) ------------------------------------------------
FLAT = {"dip_direction": 180, "dip": 0}


def _wedge(j1, j2, slope, phi, H=10, upper=FLAT, **kw):
    return eng.wedge_fs(
        j1={"dip_direction": j1[0], "dip": j1[1], "c": 0, "phi": phi},
        j2={"dip_direction": j2[0], "dip": j2[1], "c": 0, "phi": phi},
        slope={"dip_direction": slope[0], "dip": slope[1]},
        upper=upper,
        H=H,
        gamma=26,
        **kw,
    )


@pytest.mark.parametrize(
    "j1,j2", [((141, 45), (219, 45)), ((119, 50), (241, 50)), ((150, 60), (230, 55))]
)
def test_wedge_hoek_bray_wedge_factor(j1, j2):
    """마찰만 · 같은 φ — Hoek & Bray FS = K tanφ / tanψi · K = sinβ / sin(ξ/2)
    (ξ = 두 면 사이 각(교선에 수직 단면) · β = 그 단면에서 쐐기 이등분선의 기울기)."""
    phi = 35
    r = _wedge(j1, j2, (180, 70), phi)
    n1 = eng.plane_normal(*j1)
    n2 = eng.plane_normal(*j2)
    i = eng.line_vector(*r["line"])
    # 교선에 수직인 면 안에서 두 면 안쪽 법선(위쪽) 사이 각 → 쐐기 사이 각 ξ = 180 − 그 각
    xi = math.pi - math.acos(float(n1 @ n2))
    bis = (n1 + n2) / np.linalg.norm(n1 + n2)  # 쐐기 이등분선(교선에 수직 단면 안)
    h = np.cross(i, [0.0, 0.0, 1.0])
    h /= np.linalg.norm(h)  # 그 단면의 수평
    beta = math.acos(abs(float(bis @ h)))
    K = math.sin(beta) / math.sin(xi / 2)
    expect = K * math.tan(math.radians(phi)) / math.tan(math.radians(r["line"][1]))
    close(r["F"], expect, 1e-3)


@pytest.mark.parametrize(
    "j1,j2,slope,phi,plunge,fs",
    [
        ((141, 45), (219, 45), (180, 70), 35, 37.85, 1.0),  # Kovári & Fritz · SWedge #1
        ((119, 50), (241, 50), (180, 70), 35, 30.02, 1.6325),  # SWedge #2
        ((195, 45), (105, 70), (160, 70), 30, None, 0.73),  # Kumsar Case 3(Ankara) · SWedge 0.7123
        ((33.5, 75), (248, 75), (337.5, 75), 40.8, None, 2.02),  # Kumsar Case 4(Dinar)
    ],
)
def test_wedge_kumsar_kovari(j1, j2, slope, phi, plunge, fs):
    r = _wedge(j1, j2, slope, phi)
    assert r["mode"] == "12"
    close(r["F"], fs, 0.03 if fs == 0.73 else 0.01)  # 실험값 0.73 = 판독(SWedge 0.7123)
    if plunge:
        close(r["line"][1], plunge, 1e-3)


def test_wedge_kumsar_seismic():
    r = _wedge((33.5, 75), (248, 75), (337.5, 75), 40.8, kh=0.3303)
    close(r["F"], 0.99)  # Kumsar 0.99 · SWedge 0.9872


def test_wedge_priest_double_plane():
    """Priest(1993) 예제 1 — 두 면 미끄럼 · 수압 5 · 15 kPa · 철탑 180 kN(168/70)."""
    r = eng.wedge_fs(
        j1={"dip_direction": 203, "dip": 47, "c": 10, "phi": 40},
        j2={"dip_direction": 287, "dip": 52, "c": 20, "phi": 35},
        slope={"dip_direction": 230, "dip": 60},
        upper={"dip_direction": 225, "dip": 5},
        H=6.7978,
        gamma=26,
        water={"pressure": [5, 15]},
        external=[{"force": 180, "trend": 168, "plunge": 70}],
    )
    assert r["mode"] == "12"
    close(r["F"], 1.4966, 1e-3)  # Priest ≈ 1.5
    close(r["volume"], 45.201, 1e-3)
    close(r["areas"][0], 41.147, 1e-3)
    close(r["areas"][1], 20.428, 1e-3)
    close(r["face_area"], 38.955, 1e-3)
    close(r["N"][0], 407, 3e-3)
    close(r["N"][1], 251, 3e-3)


def test_wedge_priest_single_plane():
    """Priest(1993) 예제 2 — 면 2 하나로 미끄럼(면 1 떨어짐) · 수압 25 · 15 kPa."""
    r = eng.wedge_fs(
        j1={"dip_direction": 65, "dip": 74, "c": 15, "phi": 32},
        j2={"dip_direction": 186, "dip": 41, "c": 5, "phi": 40},
        slope={"dip_direction": 134, "dip": 65},
        upper={"dip_direction": 122, "dip": 11},
        H=6.8471,
        gamma=25,
        water={"pressure": [25, 15]},
    )
    assert r["mode"] == "2"
    close(r["F"], 0.8493, 1e-3)  # Priest ≈ 0.86 · SWedge 0.8493
    close(r["volume"], 81.741, 1e-3)
    assert r["N"][0] == 0.0


def test_wedge_gravity_water_and_bolt():
    """중력 수압 U = p³ γw Hw a / 6(SWedge · Hoek-Bray) · 볼트는 안전율을 낮추지 않음."""
    dry = _wedge((141, 45), (219, 45), (180, 70), 35)
    wet = _wedge((141, 45), (219, 45), (180, 70), 35, water={"fill": 1.0})
    expect = eng.GAMMA_W * wet["Hw"] / 6 * wet["areas"][0]
    close(wet["water_force"][0], expect, 1e-9)
    assert wet["F"] < dry["F"]
    bolted = _wedge(
        (141, 45), (219, 45), (180, 70), 35, bolt={"force": 50, "trend": 0, "plunge": 15}
    )
    assert bolted["F"] > dry["F"]


def test_fmt_negative_zero():
    assert str(model._fmt(-0.0)) == "0.0"  # 들림 · 볼트 없음 = 0(「-0.0」 아님)
    assert model._fmt(math.inf) is None


def test_wedge_not_formed():
    # 교선이 사면보다 가파름 → 사면으로 안 나옴
    assert _wedge((141, 75), (219, 75), (180, 50), 35) is None


# ---- Markland 경계 -------------------------------------------------------------
SLOPE = {"dip_direction": 90.0, "dip": 70.0}


def _j(dd, dip, phi=30.0, jid="J"):
    return {"id": jid, "dip_direction": dd, "dip": dip, "phi": phi}


@pytest.mark.parametrize(
    "dd,dip,hit",
    [
        (109.9, 45, True),
        (110.1, 45, False),
        (70.1, 45, True),
        (90, 30.1, True),
        (90, 29.9, False),
        (90, 69.9, True),
        (90, 70.1, False),
    ],
)
def test_markland_planar(dd, dip, hit):
    assert (eng.kinematic(SLOPE, [_j(dd, dip)])["planar"] == ["J"]) is hit


def test_markland_planar_apparent_daylight():
    """측방 15° — 겉보기 사면 경사(tanψf cos15°)를 넘는 절리는 안 나옴."""
    app = eng.apparent_dip(70, 90, 105)
    assert eng.kinematic(SLOPE, [_j(105, app - 0.1)])["planar"] == ["J"]
    assert eng.kinematic(SLOPE, [_j(105, app + 0.1)])["planar"] == []


@pytest.mark.parametrize(
    "dd,dip,hit", [(270, 50.1, True), (270, 49.9, False), (289.9, 80, True), (290.1, 80, False)]
)
def test_markland_toppling(dd, dip, hit):
    """ψp > 90 − ψf + φ = 50 · 역방향 ±20."""
    assert (eng.kinematic(SLOPE, [_j(dd, dip)])["toppling"] == ["J"]) is hit


def test_markland_wedge_plunge_bounds():
    a, b = _j(50, 60, jid="A"), _j(130, 60, jid="B")
    trend, plunge = eng.intersection(a, b)
    assert trend == pytest.approx(90.0, abs=1e-6)
    hit = eng.kinematic(SLOPE, [a, b])["wedge"]
    assert hit and hit[0]["ids"] == ["A", "B"]
    # φ 를 선주각 위로 올리면 사라짐
    hi = [dict(a, phi=plunge + 0.1), dict(b, phi=plunge + 0.1)]
    assert eng.kinematic(SLOPE, hi)["wedge"] == []
    # 사면을 교선보다 완만하게 하면 안 나옴
    assert eng.kinematic({"dip_direction": 90, "dip": plunge - 0.1}, [a, b])["wedge"] == []


# ---- 투영 ----------------------------------------------------------------------
@pytest.mark.parametrize("kind", net.PROJECTIONS)
def test_projection_round_trip(kind):
    rng = np.random.default_rng(536)
    for trend, plunge in zip(rng.uniform(0, 360, 200), rng.uniform(0, 89.9, 200)):
        x, y = net.project(trend, plunge, kind)
        t2, p2 = net.inverse(x, y, kind)
        assert p2 == pytest.approx(plunge, abs=2e-3)
        # 좌표는 소수 다섯째 자리 — 중심 가까이는 추향 오차가 1e-5 / r rad 까지
        assert eng.ang_diff(t2, trend) <= math.degrees(1e-5 / math.hypot(x, y)) + 1e-6


def test_projection_known_radii():
    assert net.radius(0, "equal_angle") == pytest.approx(1.0)
    assert net.radius(0, "equal_area") == pytest.approx(1.0)
    assert net.radius(90, "equal_angle") == pytest.approx(0.0)
    assert net.radius(45, "equal_angle") == pytest.approx(math.tan(math.radians(22.5)))
    assert net.radius(45, "equal_area") == pytest.approx(
        math.sqrt(2) * math.sin(math.radians(22.5))
    )
    # 동쪽 수평선 = (1, 0) · 북쪽 = (0, 1)
    assert net.project(90, 0, "equal_angle") == pytest.approx([1.0, 0.0], abs=1e-5)
    assert net.project(0, 0, "equal_area") == pytest.approx([0.0, 1.0], abs=1e-5)


def _inside(pt, poly):
    x, y = pt
    hit = False
    for (x1, y1), (x2, y2) in zip(poly, poly[1:] + poly[:1]):
        if (y1 > y) != (y2 > y) and x < x1 + (y - y1) * (x2 - x1) / (y2 - y1):
            hit = not hit
    return hit


@pytest.mark.parametrize("kind", net.PROJECTIONS)
def test_zones_match_kinematic(kind):
    """위험 영역 다각형 안 극점 · 교선 = Markland 판정(경계 1° 띠 밖 표본)."""
    rng = np.random.default_rng(7)
    phi = 30.0
    data = net.stereonet(SLOPE, [], phi, kind)
    checked = 0
    for dd, dip in zip(rng.uniform(0, 360, 1500), rng.uniform(1, 89, 1500)):
        kin = eng.kinematic(SLOPE, [_j(dd, dip, phi)])
        near = (
            abs(eng.ang_diff(dd, 90) - 20) < 1
            or abs(eng.ang_diff(dd, 270) - 20) < 1
            or abs(dip - phi) < 1
            or abs(dip - eng.apparent_dip(70, 90, dd)) < 1
            or abs(dip - 50) < 1
        )
        if near:
            continue
        pole = net.project(*eng.pole(dd, dip), kind)
        assert _inside(pole, data["zones"]["planar"]) == bool(kin["planar"]), (dd, dip)
        assert _inside(pole, data["zones"]["toppling"]) == bool(kin["toppling"]), (dd, dip)
        checked += 1
    assert checked > 1000


# ---- 정본 · 측점 사면 ------------------------------------------------------------
def _doc():
    doc = model.build_initial()
    doc["sets"] = [
        {
            "id": "J1",
            "name": "J1",
            "from_m": 0,
            "to_m": 100,
            "dip_direction": 90,
            "dip": 45,
            "phi": 30,
            "c": 5,
            "persistence_m": None,
        }
    ]
    return doc


def test_check_and_clean():
    assert model.check_joints(_doc()) == []
    bad = _doc()
    bad["sets"][0].update(dip=95, to_m=-1, name=" ")
    bad["sets"].append(dict(bad["sets"][0]))
    bad["settings"]["crack"] = {"mode": "depth", "z": None}
    paths = {e["path"] for e in model.check_joints(bad)}
    assert {"sets.0.dip", "sets.0.to_m", "sets.0.name", "sets.1.id", "settings.crack.z"} <= paths
    clean = model.clean(dict(_doc(), extra=1))
    assert set(clean) == {"version", "sets", "settings"}
    assert clean["sets"][0]["dip"] == 45.0


def _cross(side_cut: str):
    """좌(+offset) 또는 우 깎기 — 노선 북쪽 진행(left = 서쪽 −x) · 원지반 깎기 쪽으로 0.6 오름 ·
    노면 99 · 깎기 1:0.4 · 쌓기 1:1.5."""
    sign = 1.0 if side_cut == "left" else -1.0
    offs = np.arange(-20, 20.5, 0.5)
    ground = [[float(o), 100 + 0.6 * sign * o] for o in offs]
    design = []
    for o, z in ground:
        d = sign * o
        if abs(o) <= 2:
            z = 99.0
        elif d > 2:
            z = min(z, 99 + 2.5 * (d - 2))
        else:
            z = max(z, 99 - (abs(d) - 2) / 1.5)
        design.append([o, z])
    return (
        {
            "frame": {"left_xy": [-1.0, 0.0]},
            "samples": [{"offset_m": o, "elevation_m": z} for o, z in ground],
        },
        {
            "section_mode": f"{side_cut}_cut",
            "cut_slope_ratio": 0.4,
            "road_edges": {"left": {"offset_m": 2.0}, "right": {"offset_m": -2.0}},
            "design_line": [{"offset_m": o, "elevation_m": z} for o, z in design],
        },
    )


@pytest.mark.parametrize("side,dd", [("left", 90.0), ("right", 270.0)])
def test_station_slope_orientation(side, dd):
    """좌 = 서쪽 산 · 사면이 동(노면)으로 기욺 = 경사방향 90 · 우는 270 · 경사 = atan(1/0.4)."""
    cross, design = _cross(side)
    slopes = model.station_slopes(cross, design)
    assert len(slopes) == 1 and slopes[0]["side"] == side
    assert slopes[0]["dip_direction"] == pytest.approx(dd)
    assert slopes[0]["dip"] == pytest.approx(math.degrees(math.atan(2.5)), abs=0.01)
    assert slopes[0]["height_m"] > 1
    assert slopes[0]["upper_dip"] == pytest.approx(math.degrees(math.atan(0.6)), abs=0.5)


def test_analyze_station(monkeypatch):
    cross, design = _cross("left")
    monkeypatch.setattr(
        model,
        "rock_stations",
        lambda _s: [{"chainage_m": 20.0, "label": "STA", "ground_type": "ripping_rock"}],
    )
    monkeypatch.setattr(model.src, "cross_section", lambda _s, _c: {**cross, "design": design})
    ground = {
        "materials": [],
        "stations": [],
        "safety_factors": {"dry": {"cut": 1.5}, "wet": {"cut": 1.2}},
        "seismic": {"enabled": False},
    }
    out = model.analyze(None, _doc(), ground)
    assert len(out) == 1
    e = out[0]
    assert e["kinematic"]["planar"] == ["J1"]
    assert {c["condition"] for c in e["cases"]} == {"dry", "wet"}
    dry = next(c for c in e["cases"] if c["condition"] == "dry")
    assert dry["required"] == 1.5 and dry["ok"] == (dry["F"] >= 1.5)
    assert e["verdict"] in ("OK", "NG")
    assert e["gamma_r"] == model.DEFAULT_GAMMA_R
    nets = model.station_net(e, _doc()["settings"])
    assert set(nets) == {"equal_angle", "equal_area", "phi"}
    assert nets["equal_area"]["zones"]["planar"]


def test_e05_rock_sheet(monkeypatch):
    """E05 암반검토 s11 — 조건 글 · 절리군 줄 · 측점 위험 모드 × 조건 줄 · 판정 서식."""
    from E05_StabReport import E05_StabReport_Build as build
    from E05_StabReport import E05_StabReport_Rock as rock
    from E06_StabRock import E06_StabRock_Router as router

    cross, design = _cross("left")
    monkeypatch.setattr(
        model,
        "rock_stations",
        lambda _s: [{"chainage_m": 20.0, "label": "STA", "ground_type": "ripping_rock"}],
    )
    monkeypatch.setattr(model.src, "cross_section", lambda _s, _c: {**cross, "design": design})
    ground = {
        "materials": [],
        "stations": [],
        "safety_factors": {"dry": {"cut": 1.5}, "wet": {"cut": 1.2}},
        "seismic": {"enabled": False},
    }
    doc = _doc()
    stations = model.analyze(None, doc, ground)
    value = {
        "fingerprint": "fp",
        "settings": doc["settings"],
        "sets": doc["sets"],
        "summary": router._summary(stations),
        "stations": stations,
        "stale": False,
    }
    sheet = next(s for s in build.form()["시트"] if s["id"] == "s11")
    rock.fill_rock(sheet, value, {})
    cells = sheet["칸"]
    assert "기본값 · 사용자 확정 전" in cells["B7"]["값"] and "½" in cells["B7"]["값"]
    assert cells["B9"]["값"].startswith("깎기 비탈 1")
    assert cells["A13"]["값"] == doc["sets"][0]["name"]
    assert sheet["인쇄"]["머리행"] == [16, 16] and cells["A16"]["값"] == "측점"  # 절리 한 줄
    rows = [r for r in range(17, 40) if cells.get(f"A{r}", {}).get("값") == "STA"]
    assert len(rows) == len(stations[0]["cases"]) + len(stations[0]["kinematic"]["toppling"])
    for r, case in zip(rows, stations[0]["cases"]):
        assert cells[f"E{r}"]["값"] == pytest.approx(case["F"])
        assert cells[f"G{r}"]["값"] == ("O.K" if case["ok"] else "N.G")
        assert cells[f"G{r}"]["서식"] == (build.ST_OK if case["ok"] else build.ST_NG)
    old = {k: v for k, v in value.items() if k != "sets"}  # 옛 저장본 = 측점에 실린 절리
    sheet = next(s for s in build.form()["시트"] if s["id"] == "s11")
    rock.fill_rock(sheet, old, {})
    assert sheet["칸"]["A13"]["값"] == doc["sets"][0]["name"]
    assert sheet["칸"]["G13"]["값"] == "-"  # 구간 모름


# ---- 최소 블록 크기 (요구 351 · 536-1 덧) --------------------------------------------
def _cases_with_volume(monkeypatch, volume: float, min_block: float):
    """엔진을 가짜 부피로 바꿔 경계(< 최소 블록)만 본다 — 평면(W = γ·면적) · 쐐기 둘."""
    gamma = 25.0
    monkeypatch.setattr(
        model.engine,
        "plane_fs",
        lambda **_k: {"F": 0.5, "W": volume * gamma, "A": 5.0, "z": 0.0},
    )
    monkeypatch.setattr(
        model.engine,
        "wedge_fs",
        lambda **_k: {"F": 0.0, "volume": volume, "line_length": 2.0, "mode": "lift", "W": 1.0},
    )
    joints = [
        {"id": "J1", "dip_direction": 90, "dip": 40, "phi": 30, "c": 0},
        {"id": "J2", "dip_direction": 200, "dip": 50, "phi": 30, "c": 0},
    ]
    slope = {"dip_direction": 90, "dip": 68, "upper_dip": 0, "height_m": 5}
    kin = {"planar": ["J1"], "wedge": [{"ids": ["J1", "J2"]}], "toppling": []}
    settings = dict(model.DEFAULT_SETTINGS, min_block_m3=min_block)
    return model._cases_for(slope, joints, kin, settings, gamma, [("dry", 0.0, 0.0)])


def test_min_block_default():
    assert model.DEFAULT_SETTINGS["min_block_m3"] == 0.1
    assert model.upgrade({"sets": [], "settings": {}})["settings"]["min_block_m3"] == 0.1


@pytest.mark.parametrize(
    "volume,small", [(0.0999, True), (0.1, False), (0.3, False), (0.0003, True)]
)
def test_min_block_boundary(monkeypatch, volume, small):
    """최소 블록 0.1 m³ — 미만만 소규모(경계 = 거르지 않음) · 평면 · 쐐기 같은 규칙."""
    cases = _cases_with_volume(monkeypatch, volume, 0.1)
    assert [c["small"] for c in cases] == [small, small]


def test_min_block_zero_keeps_all(monkeypatch):
    cases = _cases_with_volume(monkeypatch, 0.0003, 0.0)
    assert not any(c["small"] for c in cases)


def test_min_block_verdict_and_counts(monkeypatch):
    """얇은 쐐기(들림 Fs 0)가 N.G 를 내던 자리 — 거르면 판정 · 최소 Fs 에서 빠지고 거른 블록 수가 남음."""
    kin = {"planar": ["J1"], "wedge": [{"ids": ["J1", "J2"]}], "toppling": []}
    for min_block, verdict, n_small in ((0.0, "NG", 0), (0.1, "none", 2)):
        cases = _cases_with_volume(monkeypatch, 0.0003, min_block)
        for c in cases:
            c["required"] = 1.2
            c["ok"] = None if c["small"] else c["F"] >= 1.2
        out = model._verdict(kin, cases)
        assert (out["verdict"], out["small_blocks"]) == (verdict, n_small)
        assert out["min_F"] == (0.0 if not n_small else None)
    # 큰 블록 + 작은 블록 섞임 — 작은 것만 빠지고 큰 것으로 판정
    big = dict(_cases_with_volume(monkeypatch, 0.5, 0.1)[0], required=1.2, ok=False)
    tiny = dict(_cases_with_volume(monkeypatch, 0.0003, 0.1)[1], required=1.2, ok=None)
    tiny["F"] = 0.0
    out = model._verdict(kin, [big, tiny])
    assert (out["verdict"], out["min_F"], out["small_blocks"]) == ("NG", 0.5, 1)


def test_min_block_check_range():
    doc = _doc()
    doc["settings"]["min_block_m3"] = -1
    assert {"path": "settings.min_block_m3", "code": "range"} in model.check_joints(doc)
    doc["settings"]["min_block_m3"] = 2.5
    assert model.check_joints(doc) == []
    assert model.clean(doc)["settings"]["min_block_m3"] == 2.5


def test_analyze_min_block_filter(monkeypatch):
    """측점 해석 전체 길 — 최소 블록을 크게 주면 모든 경우 소규모 · ok 없음 · 판정 none."""
    cross, design = _cross("left")
    monkeypatch.setattr(
        model,
        "rock_stations",
        lambda _s: [{"chainage_m": 20.0, "label": "STA", "ground_type": "ripping_rock"}],
    )
    monkeypatch.setattr(model.src, "cross_section", lambda _s, _c: {**cross, "design": design})
    ground = {
        "materials": [],
        "stations": [],
        "safety_factors": {"dry": {"cut": 1.5}, "wet": {"cut": 1.2}},
        "seismic": {"enabled": False},
    }
    base = model.analyze(None, _doc(), ground)[0]
    assert not any(c["small"] for c in base["cases"]) and base["small_blocks"] == 0
    doc = _doc()
    doc["settings"]["min_block_m3"] = 1000.0
    e = model.analyze(None, doc, ground)[0]
    assert all(c["small"] and c["ok"] is None for c in e["cases"])
    assert (e["verdict"], e["min_F"], e["small_blocks"]) == ("none", None, 1)


def test_e05_rock_sheet_small(monkeypatch):
    """E05 s11 — 최소 블록 글 · 소규모 요약 · 줄 비고."""
    from E05_StabReport import E05_StabReport_Build as build
    from E05_StabReport import E05_StabReport_Rock as rock
    from E06_StabRock import E06_StabRock_Router as router

    cross, design = _cross("left")
    monkeypatch.setattr(
        model,
        "rock_stations",
        lambda _s: [{"chainage_m": 20.0, "label": "STA", "ground_type": "ripping_rock"}],
    )
    monkeypatch.setattr(model.src, "cross_section", lambda _s, _c: {**cross, "design": design})
    ground = {
        "materials": [],
        "stations": [],
        "safety_factors": {"dry": {"cut": 1.5}, "wet": {"cut": 1.2}},
        "seismic": {"enabled": False},
    }
    doc = _doc()
    doc["settings"]["min_block_m3"] = 1000.0
    stations = model.analyze(None, doc, ground)
    value = {
        "settings": doc["settings"],
        "sets": doc["sets"],
        "summary": router._summary(stations),
        "stations": stations,
        "stale": False,
    }
    sheet = next(s for s in build.form()["시트"] if s["id"] == "s11")
    rock.fill_rock(sheet, value, {})
    cells = sheet["칸"]
    assert "최소 블록 1000 m³" in cells["B8"]["값"] and "사용자 입력" in cells["B8"]["값"]
    assert "소규모 블록 1" in cells["B9"]["값"]
    assert any("소규모 · 낙석 관리" in str(c.get("값")) for c in cells.values())