#!/usr/bin/env python3
"""BLOCK8 DXF에서 평면/종단/단면 영역을 벡터 SVG 참조 이미지로 추출한다."""

from collections import defaultdict
from html import escape
import json
import math
from pathlib import Path
import re
import sys

ROOT = Path(__file__).resolve().parents[1]
sys.dont_write_bytecode = True
sys.path.insert(0, str(ROOT / "scripts"))
import extract_block8_model as dxf

OUTPUT = ROOT / "public/drawing-images"
WIDTH = 1400
VIEWS = {
    "plan": {"title": "평면도", "bounds": (1_195_000, 1_230_000, -90_000, -61_000)},
    "upper-plan": {"title": "상부평면도", "bounds": (1_230_000, 1_267_000, -90_000, -61_000)},
    "longitudinal": {"title": "종단면도", "bounds": (1_213_000, 1_247_000, -108_000, -90_000)},
    "section-a": {"title": "단면 A-A · STA. 0K+319.000", "bounds": (1_280_000, 1_312_000, -83_000, -64_000)},
    "section-b": {"title": "단면 B-B · STA. 0K+339.000", "bounds": (1_280_000, 1_312_000, -102_000, -83_000)},
}
ACI = {
    1: "#d25245", 2: "#b58b32", 3: "#43845c", 4: "#438b9e",
    5: "#5273a6", 6: "#995d96", 7: "#26332b", 8: "#777f78", 9: "#a1aaa2",
}
FALLBACK = {
    "CS-CONC-MAJR": "#26332b", "CS-CONC-MINR": "#3d817e",
    "CS-CNTL": "#c05045", "CS-DIML": "#ad584c", "CS-DIMT": "#43845c",
    "CS-NOTE": "#43845c", "CS-TEXT": "#43845c", "CZ-TEX1": "#995d96",
    "CZ-TEX2": "#43845c", "CS-SYMB": "#43845c", "CS-CUTL": "#5273a6",
}


def compose(a, b):
    return (
        a[0]*b[0] + a[2]*b[1], a[1]*b[0] + a[3]*b[1],
        a[0]*b[2] + a[2]*b[3], a[1]*b[2] + a[3]*b[3],
        a[0]*b[4] + a[2]*b[5] + a[4], a[1]*b[4] + a[3]*b[5] + a[5],
    )


def transform(matrix, point):
    x, y = point
    return matrix[0]*x + matrix[2]*y + matrix[4], matrix[1]*x + matrix[3]*y + matrix[5]


def make_insert_matrix(entity, block):
    p = dxf.props(entity)
    ix, iy = float(dxf.first(p, 10, "0")), float(dxf.first(p, 20, "0"))
    sx, sy = float(dxf.first(p, 41, "1")), float(dxf.first(p, 42, "1"))
    angle = math.radians(float(dxf.first(p, 50, "0")))
    bx, by = block["base"][:2]
    co, si = math.cos(angle), math.sin(angle)
    a, c = co*sx, -si*sy
    b, e = si*sx, co*sy
    return a, b, c, e, ix-a*bx-c*by, iy-b*bx-e*by


def entity_layer(entity, inherited=None):
    name = dxf.layer(entity)
    return inherited if name == "0" and inherited else name


def parse_primitives(entity, blocks, matrix, inherited=None, depth=0, visited=()):
    if depth > 5:
        return []
    kind = entity["type"]
    layer = entity_layer(entity, inherited)
    p = dxf.props(entity)
    if kind == "INSERT":
        name = dxf.first(p, 2, "")
        block = blocks.get(name)
        if not block or name in visited:
            return []
        next_matrix = compose(matrix, make_insert_matrix(entity, block))
        result = []
        for child in block["entities"]:
            result.extend(parse_primitives(child, blocks, next_matrix, layer, depth+1, visited+(name,)))
        return result
    if kind in ("LINE", "LWPOLYLINE", "ARC", "CIRCLE", "SOLID", "TRACE"):
        points = []
        if kind == "LINE":
            points = [(float(dxf.first(p, 10)), float(dxf.first(p, 20))), (float(dxf.first(p, 11)), float(dxf.first(p, 21)))]
        elif kind == "LWPOLYLINE":
            raw_x, raw_y = [float(v) for v in p.get(10, [])], [float(v) for v in p.get(20, [])]
            points = list(zip(raw_x, raw_y))
            if int(dxf.first(p, 70, "0")) & 1 and points:
                points.append(points[0])
        elif kind == "ARC":
            points = dxf.arc_points(entity, 48)
        elif kind == "CIRCLE":
            cx, cy, r = float(dxf.first(p, 10)), float(dxf.first(p, 20)), float(dxf.first(p, 40))
            points = [(cx+r*math.cos(2*math.pi*i/64), cy+r*math.sin(2*math.pi*i/64)) for i in range(65)]
        else:
            points = [(float(dxf.first(p, x)), float(dxf.first(p, y))) for x, y in ((10,20),(11,21),(12,22),(13,23)) if x in p and y in p]
            if points:
                points.append(points[0])
        return [("path", [transform(matrix, point) for point in points], layer)] if len(points) > 1 else []
    if kind in ("TEXT", "MTEXT", "ATTRIB", "ATTDEF"):
        x, y = float(dxf.first(p, 10, "0")), float(dxf.first(p, 20, "0"))
        pos = transform(matrix, (x, y))
        text = "".join(p.get(1, []) + p.get(3, []))
        text = text.replace("\\P", " ").replace("%%d", "°").replace("%%p", "±").replace("%%c", "Ø")
        text = re.sub(r"\\[A-Za-z][^;]*;", "", text)
        size = float(dxf.first(p, 40, "250"))
        # Text heights are in drawing units; image uses the same uniform drawing scale.
        angle = float(dxf.first(p, 50, "0"))
        align = int(dxf.first(p, 72, "0"))
        anchor = {0: "start", 1: "middle", 2: "end"}.get(align, "start")
        return [("text", [pos, text, size, angle, anchor], layer)] if text.strip() else []
    return []


def get_colors(pairs):
    begin, end = dxf.parse_sections(pairs, "TABLES")
    colors = {}
    for record in dxf.records(pairs, begin+2, end):
        if record["type"] != "LAYER":
            continue
        p = dxf.props(record)
        name = dxf.first(p, 2, "")
        try:
            colors[name] = ACI.get(abs(int(dxf.first(p, 62, "7"))), FALLBACK.get(name, "#374239"))
        except ValueError:
            colors[name] = FALLBACK.get(name, "#374239")
    return colors


def render_view(name, spec, entities, blocks, colors):
    x0, x1, y0, y1 = spec["bounds"]
    HEIGHT = round(WIDTH * (y1-y0) / (x1-x0))
    scale = WIDTH / (x1-x0)
    def screen(point):
        x, y = point
        return (x-x0)*scale, HEIGHT-(y-y0)*scale

    primitives = []
    for entity in entities:
        primitives.extend(parse_primitives(entity, blocks, (1,0,0,1,0,0)))
    elements = []
    for kind, data, layer in primitives:
        color = colors.get(layer, FALLBACK.get(layer, "#667267"))
        if kind == "path":
            px = [point[0] for point in data]
            py = [point[1] for point in data]
            if max(px) < x0 or min(px) > x1 or max(py) < y0 or min(py) > y1:
                continue
            # Canvas crop clips geometry outside the requested drawing region.
            points = [screen(point) for point in data]
            path = "M" + " L".join(f"{x:.2f},{y:.2f}" for x,y in points)
            width = 1.25 if layer == "CS-CONC-MAJR" else 0.8
            elements.append(f'<path d="{path}" fill="none" stroke="{color}" stroke-width="{width}" stroke-linejoin="round"/>')
        else:
            (x,y), text, height, angle, anchor = data
            if not (x0-1000 <= x <= x1+1000 and y0-1000 <= y <= y1+1000):
                continue
            sx, sy = screen((x,y))
            size = max(4, min(26, height*scale))
            escaped = escape(text, quote=False)
            # Negative angle compensates for the SVG screen's downward-positive y axis.
            elements.append(f'<text x="{sx:.2f}" y="{sy:.2f}" font-size="{size:.2f}" text-anchor="{anchor}" fill="{color}" transform="rotate({-angle:.2f} {sx:.2f} {sy:.2f})">{escaped}</text>')

    svg = [
        f'<svg xmlns="http://www.w3.org/2000/svg" width="{WIDTH}" height="{HEIGHT}" viewBox="0 0 {WIDTH} {HEIGHT}" role="img" aria-label="{escape(spec["title"])} 원본 DXF 영역">',
        f'<title>{escape(spec["title"])} · 원본 DXF 벡터 캡처</title>',
        f'<g>{"".join(elements)}</g>',
        '</svg>',
    ]
    path = OUTPUT / f"BLOCK8_{name}.svg"
    path.write_text("\n".join(svg), encoding="utf-8")
    print(f"{path.relative_to(ROOT)}: {len(elements)}개 도면 요소")
    return {
        "title": spec["title"],
        "pixelSize": [WIDTH, HEIGHT],
        "cadBounds": {
            "xMin": x0,
            "xMax": x1,
            "yMin": y0,
            "yMax": y1,
        },
        "placement": None,
    }


def main():
    pairs = dxf.read_pairs(dxf.SOURCE)
    entities = dxf.parse_modelspace(pairs)
    blocks = dxf.parse_blocks(pairs)
    colors = get_colors(pairs)
    OUTPUT.mkdir(parents=True, exist_ok=True)
    metadata = {name: render_view(name, spec, entities, blocks, colors) for name, spec in VIEWS.items()}
    metadata["plan"]["placement"] = {"kind": "plan", "xOffset": 0, "displayEL": 108.8}
    metadata["upper-plan"]["placement"] = {"kind": "plan", "xOffset": -35_000, "displayEL": 108.8}
    metadata["longitudinal"]["placement"] = {
        "kind": "longitudinal",
        "stationCad": [1_218_301.059683612, 1_241_698.059683612],
        "elevationOffset": 205.2898,
        "lateralOffset": 15,
    }
    metadata["section-a"]["placement"] = {
        "kind": "section", "stationT": -0.0005005005,
        "cadXCenter": 1_296_487.109248054,
        "cadYBase": -78_059.37855593952, "baseEL": 101.777,
    }
    metadata["section-b"]["placement"] = {
        "kind": "section", "stationT": 1.0005005005,
        "cadXCenter": 1_296_487.109248054,
        "cadYBase": -97_286.37855593952, "baseEL": 101.292,
    }
    model_metadata = ROOT / "src/model/drawingViews.json"
    model_metadata.write_text(json.dumps(metadata, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    print(f"{model_metadata.relative_to(ROOT)}: 도면/모델 배치 기준 기록")


if __name__ == "__main__":
    main()