import AppKit
import CoreText
import SwiftUI

enum BoxTint: String {
    case plain, blue, green, amber, red
}

struct BoxNode {
    let id: String
    var title: String
    var details: [String] = []
    var tint = BoxTint.plain
    var children: [BoxNode] = []
}

struct BoxRow {
    var main: [BoxNode] = []
    var aside: [BoxNode] = []
}

struct BoxEdge {
    let from: String
    let to: String
    let label: String?
    let dashed: Bool
}

struct BoxPreset {
    let name: String
    let ids: Set<String>
}

struct BoxDiagram {
    var rows: [BoxRow] = []
    var edges: [BoxEdge] = []
    var presets: [BoxPreset] = []
}

private enum Token: Equatable {
    case word(String)
    case text(String)
}

private func tokenize(_ line: String) throws(DiagramError) -> [Token] {
    var out: [Token] = []
    var rest = Substring(line)
    while true {
        rest = rest.drop { $0 == " " || $0 == "\t" }
        guard let c = rest.first else {
            return out
        }
        if c == "\"" {
            var text = ""
            var i = rest.index(after: rest.startIndex)
            var closed = false
            while i < rest.endIndex {
                let ch = rest[i]
                if ch == "\\", rest.index(after: i) < rest.endIndex {
                    i = rest.index(after: i)
                    text.append(rest[i])
                } else if ch == "\"" {
                    closed = true
                    break
                } else {
                    text.append(ch)
                }
                i = rest.index(after: i)
            }
            guard closed else {
                throw DiagramError(reason: "unclosed quote in \"\(line)\"")
            }
            out.append(.text(text))
            rest = rest[rest.index(after: i)...]
            continue
        }
        let word = rest.prefix { $0 != " " && $0 != "\t" && $0 != "\"" }
        out.append(.word(String(word)))
        rest = rest.dropFirst(word.count)
    }
}

private let boxId = Re(#"^[A-Za-z0-9_-]+$"#)

private final class NodeBuilder {
    var node: BoxNode
    var children: [NodeBuilder] = []

    init(_ node: BoxNode) {
        self.node = node
    }

    func build() -> BoxNode {
        var n = node
        n.children = children.map { $0.build() }
        return n
    }
}

func parseBoxDiagram(_ src: String) throws(DiagramError) -> BoxDiagram {
    var rows: [(main: [NodeBuilder], aside: [NodeBuilder])] = []
    var stack: [(indent: Int, node: NodeBuilder)] = []
    var ids = Set<String>()
    var diagram = BoxDiagram()
    for raw in src.components(separatedBy: "\n") {
        let line = raw.replacingOccurrences(of: "\t", with: "    ")
        let body = trimmed(line)
        if body.isEmpty || body.hasPrefix("#") {
            continue
        }
        let indent = line.prefix { $0 == " " }.count
        var toks = try tokenize(body)
        if indent == 0 {
            stack = []
            if toks == [.word("row")] {
                rows.append(([], []))
                continue
            }
            if toks.first == .word("highlight") {
                guard toks.count >= 3, case .text(let name) = toks[1] else {
                    throw DiagramError(reason: "a highlight needs a quoted name and box ids: \"\(body)\"")
                }
                var set = Set<String>()
                for t in toks.dropFirst(2) {
                    guard case .word(let id) = t else {
                        throw DiagramError(reason: "can't parse \"\(body)\"")
                    }
                    set.insert(id)
                }
                diagram.presets.append(BoxPreset(name: name, ids: set))
                continue
            }
            guard toks.count == 3 || toks.count == 4, case .word(let from) = toks[0], case .word(let arrow) = toks[1], case .word(let to) = toks[2], arrow == "->" || arrow == "..>" else {
                throw DiagramError(reason: "can't parse \"\(body)\"; top-level lines are row, highlight or an edge like a -> b \"label\"")
            }
            var label: String?
            if toks.count == 4 {
                guard case .text(let l) = toks[3] else {
                    throw DiagramError(reason: "an edge's label must be quoted: \"\(body)\"")
                }
                label = l
            }
            diagram.edges.append(BoxEdge(from: from, to: to, label: label, dashed: arrow == "..>"))
            continue
        }
        guard !rows.isEmpty else {
            throw DiagramError(reason: "boxes go under a row: \"\(body)\"")
        }
        let aside = toks.first == .word("aside")
        if aside {
            toks.removeFirst()
        }
        guard case .word(let id) = toks.first, boxId.test(id) else {
            throw DiagramError(reason: "a box starts with its id: \"\(body)\"")
        }
        guard ids.insert(id).inserted else {
            throw DiagramError(reason: "box \(id) is defined twice")
        }
        var node = BoxNode(id: id, title: id)
        var texts: [String] = []
        for t in toks.dropFirst() {
            switch t {
            case .text(let s):
                texts.append(s)
            case .word(let w):
                guard let tint = BoxTint(rawValue: w) else {
                    throw DiagramError(reason: "\(w) isn't a color; use blue, green, amber, red or plain")
                }
                node.tint = tint
            }
        }
        if let first = texts.first {
            node.title = first
            node.details = Array(texts.dropFirst())
        }
        let b = NodeBuilder(node)
        while let last = stack.last, last.indent >= indent {
            stack.removeLast()
        }
        if let parent = stack.last {
            guard !aside else {
                throw DiagramError(reason: "aside boxes sit directly under a row: \"\(body)\"")
            }
            parent.node.children.append(b)
        } else if aside {
            rows[rows.count - 1].aside.append(b)
        } else {
            rows[rows.count - 1].main.append(b)
        }
        stack.append((indent, b))
    }
    diagram.rows = rows.map { BoxRow(main: $0.main.map { $0.build() }, aside: $0.aside.map { $0.build() }) }
    if ids.isEmpty {
        throw DiagramError(reason: "empty diagram")
    }
    for e in diagram.edges {
        for id in [e.from, e.to] where !ids.contains(id) {
            throw DiagramError(reason: "edge \(e.from) -> \(e.to) names no box \(id)")
        }
    }
    for p in diagram.presets {
        for id in p.ids where !ids.contains(id) {
            throw DiagramError(reason: "highlight \"\(p.name)\" names no box \(id)")
        }
    }
    return diagram
}

struct PlacedBox {
    let node: BoxNode
    let rect: CGRect
    let depth: Int
    let parent: String?
    let header: CGRect
}

struct RoutedEdge {
    let edge: BoxEdge
    let points: [CGPoint]
    let labelRect: CGRect?
}

struct BoxLayout: Identifiable {
    let id = UUID()
    let boxes: [PlacedBox]
    let index: [String: Int]
    let edges: [RoutedEdge]
    let presets: [BoxPreset]
    let size: CGSize

    func ancestors(_ id: String) -> [String] {
        var out: [String] = []
        var p = boxes[index[id]!].parent
        while let id = p {
            out.append(id)
            p = boxes[index[id]!].parent
        }
        return out
    }

    func hit(_ p: CGPoint) -> String? {
        boxes.filter { $0.rect.contains(p) }.max { $0.depth < $1.depth }?.node.id
    }
}

struct BoxFocus {
    let boxes: Set<String>
    let edges: Set<Int>

    static func box(_ id: String, _ layout: BoxLayout) -> BoxFocus {
        var boxes: Set<String> = [id]
        var edges = Set<Int>()
        for (i, r) in layout.edges.enumerated() where r.edge.from == id || r.edge.to == id {
            edges.insert(i)
            boxes.insert(r.edge.from)
            boxes.insert(r.edge.to)
        }
        return BoxFocus(boxes: boxes, edges: edges)
    }

    static func preset(_ p: BoxPreset, _ layout: BoxLayout) -> BoxFocus {
        let edges = layout.edges.indices.filter { p.ids.contains(layout.edges[$0].edge.from) && p.ids.contains(layout.edges[$0].edge.to) }
        return BoxFocus(boxes: p.ids, edges: Set(edges))
    }

    func dims(_ b: PlacedBox, _ layout: BoxLayout) -> Bool {
        if boxes.contains(b.node.id) || layout.ancestors(b.node.id).contains(where: boxes.contains) {
            return false
        }
        return !boxes.contains { layout.ancestors($0).contains(b.node.id) }
    }
}

private let pad: CGFloat = 12
private let childGap: CGFloat = 14
private let boxGap: CGFloat = 20
private let rowGap: CGFloat = 48
private let columnGap: CGFloat = 80
private let margin: CGFloat = 20

@MainActor
private var titleFont: CTFont {
    Fonts.ns(13, weight: 600) as CTFont
}

@MainActor
private var detailFont: CTFont {
    Fonts.ns(12) as CTFont
}

@MainActor
private var edgeLabelFont: CTFont {
    Fonts.ns(11) as CTFont
}

@MainActor
private func headerSize(_ n: BoxNode) -> CGSize {
    let t = textSize(n.title, titleFont)
    var w = t.width
    var h = t.height
    for d in n.details {
        let s = textSize(d, detailFont)
        w = max(w, s.width)
        h += s.height
    }
    return CGSize(width: w, height: h + (n.details.isEmpty ? 0 : 2))
}

@MainActor
private struct Sizer {
    let labelGaps: [String: CGFloat]

    init(_ d: BoxDiagram) {
        var gaps: [String: CGFloat] = [:]
        for e in d.edges {
            guard let label = e.label else {
                continue
            }
            let key = Sizer.pair(e.from, e.to)
            gaps[key] = max(gaps[key] ?? 0, textSize(label, edgeLabelFont).width + 16)
        }
        labelGaps = gaps
    }

    static func pair(_ a: String, _ b: String) -> String {
        a < b ? "\(a) \(b)" : "\(b) \(a)"
    }

    func gaps(_ nodes: [BoxNode], _ base: CGFloat) -> [CGFloat] {
        zip(nodes, nodes.dropFirst()).map { a, b in max(base, labelGaps[Sizer.pair(a.id, b.id)] ?? 0) }
    }

    func naturalSize(_ n: BoxNode) -> CGSize {
        let head = headerSize(n)
        if n.children.isEmpty {
            return CGSize(width: head.width + pad * 2, height: head.height + pad * 2)
        }
        let kids = n.children.map(naturalSize)
        let row = kids.map(\.width).reduce(0, +) + gaps(n.children, childGap).reduce(0, +)
        return CGSize(width: max(head.width, row) + pad * 2, height: pad + head.height + pad + kids.map(\.height).max()! + pad)
    }

    func stretch(_ nodes: [BoxNode], to width: CGFloat, gaps: [CGFloat]) -> [CGFloat] {
        let natural = nodes.map { naturalSize($0).width }
        let sum = natural.reduce(0, +)
        let extra = width - sum - gaps.reduce(0, +)
        return natural.map { $0 + extra * $0 / sum }
    }

    func place(_ n: BoxNode, _ rect: CGRect, _ depth: Int, _ parent: String?, _ out: inout [PlacedBox]) {
        let head = headerSize(n)
        let header = n.children.isEmpty ? rect : CGRect(x: rect.minX, y: rect.minY, width: min(rect.width, head.width + pad * 2), height: pad + head.height)
        out.append(PlacedBox(node: n, rect: rect, depth: depth, parent: parent, header: header))
        if n.children.isEmpty {
            return
        }
        let gaps = gaps(n.children, childGap)
        let widths = stretch(n.children, to: rect.width - pad * 2, gaps: gaps)
        let top = rect.minY + pad + head.height + pad
        var x = rect.minX + pad
        for (i, (c, w)) in zip(n.children, widths).enumerated() {
            place(c, CGRect(x: x, y: top, width: w, height: rect.maxY - pad - top), depth + 1, n.id, &out)
            x += w + (i < gaps.count ? gaps[i] : 0)
        }
    }

    func rowWidth(_ r: BoxRow) -> CGFloat {
        r.main.map { naturalSize($0).width }.reduce(0, +) + gaps(r.main, boxGap).reduce(0, +)
    }
}

@MainActor
func layoutBoxDiagram(_ d: BoxDiagram) throws(DiagramError) -> BoxLayout {
    let sizer = Sizer(d)
    let mainWidth: CGFloat = d.rows.map(sizer.rowWidth).max() ?? 0
    let asideWidth: CGFloat = d.rows.flatMap(\.aside).map { sizer.naturalSize($0).width }.max() ?? 0
    let asideX = margin + mainWidth + columnGap
    var boxes: [PlacedBox] = []
    var y = margin
    var asideBottom = margin - rowGap
    var bottom = margin
    for r in d.rows {
        let height = r.main.map { sizer.naturalSize($0).height }.max() ?? 0
        let gaps = sizer.gaps(r.main, boxGap)
        var x = margin
        for (i, (n, w)) in zip(r.main, sizer.stretch(r.main, to: mainWidth, gaps: gaps)).enumerated() {
            sizer.place(n, CGRect(x: x, y: y, width: w, height: height), 0, nil, &boxes)
            x += w + (i < gaps.count ? gaps[i] : 0)
        }
        var ay = max(y, asideBottom + rowGap)
        for n in r.aside {
            let h = sizer.naturalSize(n).height
            sizer.place(n, CGRect(x: asideX, y: ay, width: asideWidth, height: h), 0, nil, &boxes)
            ay += h + rowGap
            asideBottom = ay - rowGap
        }
        bottom = max(bottom, y + height, asideBottom)
        y += height + (r.main.isEmpty ? 0 : rowGap)
    }
    let width = (asideWidth > 0 ? asideX + asideWidth : margin + mainWidth) + margin
    let size = CGSize(width: width, height: bottom + margin)
    let index = Dictionary(uniqueKeysWithValues: boxes.enumerated().map { ($0.element.node.id, $0.offset) })
    var router = Router(boxes: boxes, index: index, size: size)
    let order = d.edges.indices.sorted { a, b in
        router.span(d.edges[a]) < router.span(d.edges[b])
    }
    var points = [[CGPoint]](repeating: [], count: d.edges.count)
    for i in order {
        points[i] = try router.route(d.edges[i])
    }
    var solid: [CGRect] = boxes.map(\.header)
    let lines = points.map { pts in zip(pts, pts.dropFirst()).map { a, b in CGRect(x: min(a.x, b.x), y: min(a.y, b.y), width: abs(a.x - b.x), height: abs(a.y - b.y)).insetBy(dx: -1, dy: -1) } }
    var routed: [RoutedEdge] = []
    for (i, (e, pts)) in zip(d.edges, points).enumerated() {
        var labelRect: CGRect?
        if let label = e.label {
            let others = lines.enumerated().filter { $0.offset != i }.flatMap(\.element)
            let r = labelSpot(textSize(label, edgeLabelFont), pts, solid: solid, lines: others, CGRect(origin: .zero, size: size))
            solid.append(r)
            labelRect = r
        }
        routed.append(RoutedEdge(edge: e, points: pts, labelRect: labelRect))
    }
    return BoxLayout(boxes: boxes, index: index, edges: routed, presets: d.presets, size: size)
}

private func labelSpot(_ size: CGSize, _ pts: [CGPoint], solid: [CGRect], lines: [CGRect], _ bounds: CGRect) -> CGRect {
    var candidates: [(rect: CGRect, order: Int)] = []
    let segs = zip(pts, pts.dropFirst()).sorted { a, b in
        abs(a.0.x - a.1.x) + abs(a.0.y - a.1.y) > abs(b.0.x - b.1.x) + abs(b.0.y - b.1.y)
    }
    for (a, b) in segs {
        for t in stride(from: 0.5, through: 0.95, by: 0.05).flatMap({ $0 == 0.5 ? [$0] : [$0, 1 - $0] }) {
            let p = CGPoint(x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t)
            if a.x == b.x {
                candidates.append((CGRect(x: p.x + 6, y: p.y - size.height / 2, width: size.width, height: size.height), candidates.count))
                candidates.append((CGRect(x: p.x - 6 - size.width, y: p.y - size.height / 2, width: size.width, height: size.height), candidates.count))
            } else {
                candidates.append((CGRect(x: p.x - size.width / 2, y: p.y - 3 - size.height, width: size.width, height: size.height), candidates.count))
                candidates.append((CGRect(x: p.x - size.width / 2, y: p.y + 3, width: size.width, height: size.height), candidates.count))
            }
        }
    }
    func area(_ a: CGRect, _ b: CGRect) -> CGFloat {
        let i = a.insetBy(dx: -2, dy: -2).intersection(b)
        return i.isNull ? 0 : max(1, i.width * i.height)
    }
    func overlap(_ c: CGRect) -> CGFloat {
        let inside = c.intersection(bounds)
        let outside = c.width * c.height - (inside.isNull ? 0 : inside.width * inside.height)
        let covered = solid.reduce(outside) { $0 + area($1, c) }
        return covered * 100 + lines.reduce(0) { $0 + area($1, c) }
    }
    return candidates.min { a, b in
        let oa = overlap(a.rect)
        let ob = overlap(b.rect)
        return oa != ob ? oa < ob : a.order < b.order
    }!.rect
}

private let cell: CGFloat = 4
private let stepCost = 10
private let turnCost = 60
private let nearCost = 4
private let parallelCost = 80
private let laneCost = 40
private let laneWidth = 3
private let crossCost = 15
private let dx = [1, 0, -1, 0]
private let dy = [0, 1, 0, -1]

private struct Port {
    let cell: Int
    let dir: Int
    let border: CGPoint
    let cost: Int
}

private struct Router {
    let boxes: [PlacedBox]
    let index: [String: Int]
    let cols: Int
    let rows: Int
    var used: [UInt8]
    var lanes: [UInt8]

    init(boxes: [PlacedBox], index: [String: Int], size: CGSize) {
        self.boxes = boxes
        self.index = index
        cols = Int(ceil(size.width / cell))
        rows = Int(ceil(size.height / cell))
        used = [UInt8](repeating: 0, count: cols * rows)
        lanes = [UInt8](repeating: 0, count: cols * rows)
    }

    func span(_ e: BoxEdge) -> CGFloat {
        let a = boxes[index[e.from]!].rect
        let b = boxes[index[e.to]!].rect
        return abs(a.midX - b.midX) + abs(a.midY - b.midY)
    }

    private func cells(_ r: CGRect) -> (x0: Int, y0: Int, x1: Int, y1: Int) {
        (Int(floor(r.minX / cell)), Int(floor(r.minY / cell)), Int(ceil(r.maxX / cell)) - 1, Int(ceil(r.maxY / cell)) - 1)
    }

    private func lineage(_ id: String) -> [String] {
        var out: [String] = []
        var p = boxes[index[id]!].parent
        while let id = p {
            out.append(id)
            p = boxes[index[id]!].parent
        }
        return out
    }

    private func blocked(_ e: BoxEdge) -> [Bool] {
        let open = Set(lineage(e.from) + lineage(e.to))
        var grid = [Bool](repeating: false, count: cols * rows)
        for b in boxes {
            let c = cells(open.contains(b.node.id) ? b.header : b.rect)
            for y in max(0, c.y0 - 1)...min(rows - 1, c.y1 + 1) {
                for x in max(0, c.x0 - 1)...min(cols - 1, c.x1 + 1) {
                    grid[y * cols + x] = true
                }
            }
        }
        return grid
    }

    private func ports(_ id: String, _ grid: [Bool], outward: Bool) -> [Port] {
        let r = boxes[index[id]!].rect
        let c = cells(r)
        var out: [Port] = []
        func add(_ x: Int, _ y: Int, _ dir: Int, _ border: CGPoint, _ offset: Int) {
            guard x >= 0, y >= 0, x < cols, y < rows, !grid[y * cols + x] else {
                return
            }
            out.append(Port(cell: y * cols + x, dir: outward ? dir : (dir + 2) % 4, border: border, cost: offset * 2))
        }
        let midX = (c.x0 + c.x1) / 2
        let midY = (c.y0 + c.y1) / 2
        if c.x1 - c.x0 >= 2 {
            for x in (c.x0 + 1)...(c.x1 - 1) {
                let px = (CGFloat(x) + 0.5) * cell
                add(x, c.y0 - 2, 3, CGPoint(x: px, y: r.minY), abs(x - midX))
                add(x, c.y1 + 2, 1, CGPoint(x: px, y: r.maxY), abs(x - midX))
            }
        }
        if c.y1 - c.y0 >= 2 {
            for y in (c.y0 + 1)...(c.y1 - 1) {
                let py = (CGFloat(y) + 0.5) * cell
                add(c.x0 - 2, y, 2, CGPoint(x: r.minX, y: py), abs(y - midY))
                add(c.x1 + 2, y, 0, CGPoint(x: r.maxX, y: py), abs(y - midY))
            }
        }
        return out
    }

    mutating func route(_ e: BoxEdge) throws(DiagramError) -> [CGPoint] {
        let grid = blocked(e)
        var near = [Bool](repeating: false, count: cols * rows)
        for i in grid.indices where grid[i] {
            let x = i % cols
            let y = i / cols
            for yy in max(0, y - 2)...min(rows - 1, y + 2) {
                for xx in max(0, x - 2)...min(cols - 1, x + 2) {
                    near[yy * cols + xx] = true
                }
            }
        }
        let starts = ports(e.from, grid, outward: true)
        let goals = ports(e.to, grid, outward: false)
        guard !starts.isEmpty, !goals.isEmpty, e.from != e.to else {
            throw DiagramError(reason: "can't route \(e.from) -> \(e.to)")
        }
        var goalAt: [Int: Port] = [:]
        for g in goals {
            goalAt[g.cell] = g
        }
        let gx0 = goals.map { $0.cell % cols }.min()!
        let gx1 = goals.map { $0.cell % cols }.max()!
        let gy0 = goals.map { $0.cell / cols }.min()!
        let gy1 = goals.map { $0.cell / cols }.max()!
        func h(_ c: Int) -> Int {
            let x = c % cols
            let y = c / cols
            return stepCost * (max(0, gx0 - x, x - gx1) + max(0, gy0 - y, y - gy1))
        }
        let states = cols * rows * 4
        var cost = [Int](repeating: .max, count: states)
        var from = [Int](repeating: -1, count: states)
        var heap = Heap()
        var startAt: [Int: Port] = [:]
        for s in starts {
            let st = s.cell * 4 + s.dir
            if s.cost < cost[st] {
                cost[st] = s.cost
                startAt[st] = s
                heap.push(s.cost + h(s.cell), st)
            }
        }
        var best = Int.max
        var bestState = -1
        while let top = heap.pop() {
            let (f, st) = top
            if f >= best {
                break
            }
            let g = cost[st]
            if f > g + h(st / 4) {
                continue
            }
            let c = st / 4
            let dir = st % 4
            if let goal = goalAt[c] {
                let total = g + (dir == goal.dir ? 0 : turnCost)
                if total < best {
                    best = total
                    bestState = st
                }
            }
            let x = c % cols
            let y = c / cols
            for nd in 0..<4 where nd != (dir + 2) % 4 {
                let nx = x + dx[nd]
                let ny = y + dy[nd]
                guard nx >= 0, ny >= 0, nx < cols, ny < rows else {
                    continue
                }
                let n = ny * cols + nx
                if grid[n] {
                    continue
                }
                var step = stepCost + (nd == dir ? 0 : turnCost) + (near[n] ? nearCost : 0)
                let axis: UInt8 = nd % 2 == 0 ? 1 : 2
                if used[n] & axis != 0 {
                    step += parallelCost
                } else if lanes[n] & axis != 0 {
                    step += laneCost
                } else if used[n] != 0 {
                    step += crossCost
                }
                let ns = n * 4 + nd
                if g + step < cost[ns] {
                    cost[ns] = g + step
                    from[ns] = st
                    heap.push(g + step + h(n), ns)
                }
            }
        }
        guard bestState >= 0 else {
            throw DiagramError(reason: "can't route \(e.from) -> \(e.to)")
        }
        var path: [Int] = []
        var st = bestState
        while st >= 0 {
            path.append(st)
            st = from[st]
        }
        path.reverse()
        for (a, b) in zip(path, path.dropFirst()) {
            let axis: UInt8 = (b % 4) % 2 == 0 ? 1 : 2
            used[a / 4] |= axis
            used[b / 4] |= axis
            for c in [a / 4, b / 4] {
                let x = c % cols
                let y = c / cols
                for k in 1...laneWidth {
                    for (nx, ny) in axis == 1 ? [(x, y - k), (x, y + k)] : [(x - k, y), (x + k, y)] where nx >= 0 && ny >= 0 && nx < cols && ny < rows {
                        lanes[ny * cols + nx] |= axis
                    }
                }
            }
        }
        func center(_ c: Int) -> CGPoint {
            CGPoint(x: (CGFloat(c % cols) + 0.5) * cell, y: (CGFloat(c / cols) + 0.5) * cell)
        }
        var pts = [startAt[path[0]]!.border]
        pts += path.map { center($0 / 4) }
        pts.append(goalAt[bestState / 4]!.border)
        return simplify(pts)
    }
}

private func simplify(_ pts: [CGPoint]) -> [CGPoint] {
    var out: [CGPoint] = []
    for p in pts {
        if let last = out.last, last == p {
            continue
        }
        if out.count >= 2 {
            let a = out[out.count - 2]
            let b = out[out.count - 1]
            if (a.x == b.x && b.x == p.x) || (a.y == b.y && b.y == p.y) {
                out[out.count - 1] = p
                continue
            }
        }
        out.append(p)
    }
    return out
}

private struct Heap {
    private var items: [(Int, Int)] = []

    mutating func push(_ key: Int, _ value: Int) {
        items.append((key, value))
        var i = items.count - 1
        while i > 0 {
            let p = (i - 1) / 2
            if items[p].0 <= items[i].0 {
                break
            }
            items.swapAt(p, i)
            i = p
        }
    }

    mutating func pop() -> (Int, Int)? {
        guard let top = items.first else {
            return nil
        }
        let last = items.removeLast()
        if !items.isEmpty {
            items[0] = last
            var i = 0
            while true {
                let l = i * 2 + 1
                let r = l + 1
                var m = i
                if l < items.count && items[l].0 < items[m].0 {
                    m = l
                }
                if r < items.count && items[r].0 < items[m].0 {
                    m = r
                }
                if m == i {
                    break
                }
                items.swapAt(m, i)
                i = m
            }
        }
        return top
    }
}

@MainActor
private var layoutCache: [String: Result<BoxLayout, DiagramError>] = [:]

@MainActor
func cachedBoxLayout(_ source: String) -> Result<BoxLayout, DiagramError> {
    let key = "\(FontSize.shared.body)\n\(source)"
    if let hit = layoutCache[key] {
        return hit
    }
    let result = Result(catching: { () throws(DiagramError) -> BoxLayout in try layoutBoxDiagram(parseBoxDiagram(source)) })
    if layoutCache.count > 64 {
        layoutCache = [:]
    }
    layoutCache[key] = result
    return result
}

private func fill(_ b: PlacedBox) -> Color {
    switch b.node.tint {
    case .blue: Palette.accentTint
    case .green: Palette.okTint
    case .amber: Palette.warnTint
    case .red: Palette.dangerTint
    case .plain: b.depth == 0 ? Palette.surface : Palette.raised
    }
}

struct BoxCanvas: View {
    let layout: BoxLayout
    var focus: BoxFocus?

    var body: some View {
        Canvas { context, size in
            let scale = layout.size.width > 0 ? size.width / layout.size.width : 1
            context.scaleBy(x: scale, y: scale)
            draw(&context)
        }
    }

    private func draw(_ context: inout GraphicsContext) {
        let titleLine = textSize("X", titleFont).height
        let detailLine = textSize("X", detailFont).height
        for b in layout.boxes {
            var ctx = context
            if let focus, focus.dims(b, layout) {
                ctx.opacity = 0.3
            }
            let path = Path(roundedRect: b.rect, cornerRadius: b.depth == 0 ? 8 : 6)
            ctx.fill(path, with: .color(fill(b)))
            let lit = focus?.boxes.contains(b.node.id) == true
            ctx.stroke(path, with: .color(lit ? Palette.accent : Palette.border), lineWidth: lit ? 1.5 : 1)
            var y = b.rect.minY + pad
            ctx.draw(Text(b.node.title).font(Font(titleFont)).foregroundColor(Palette.text), at: CGPoint(x: b.rect.minX + pad, y: y), anchor: .topLeading)
            y += titleLine + 2
            for d in b.node.details {
                ctx.draw(Text(d).font(Font(detailFont)).foregroundColor(Palette.muted), at: CGPoint(x: b.rect.minX + pad, y: y), anchor: .topLeading)
                y += detailLine
            }
        }
        for (i, r) in layout.edges.enumerated() {
            var ctx = context
            let lit = focus?.edges.contains(i) == true
            if focus != nil && !lit {
                ctx.opacity = 0.2
            }
            let color = lit ? Palette.accent : Palette.muted
            ctx.stroke(rounded(r.points), with: .color(color), style: StrokeStyle(lineWidth: lit ? 2 : 1.3, lineCap: .round, lineJoin: .round, dash: r.edge.dashed ? [5, 4] : []))
            if r.points.count >= 2 {
                arrow(&ctx, r.points[r.points.count - 2], r.points[r.points.count - 1], color)
            }
            if let label = r.edge.label, let rect = r.labelRect {
                ctx.draw(Text(label).font(Font(edgeLabelFont)).foregroundColor(lit ? Palette.accent : Palette.muted), at: CGPoint(x: rect.minX, y: rect.minY), anchor: .topLeading)
            }
        }
    }

    private func rounded(_ pts: [CGPoint]) -> Path {
        var p = Path()
        guard let first = pts.first else {
            return p
        }
        p.move(to: first)
        if pts.count > 2 {
            for i in 1..<(pts.count - 1) {
                let a = pts[i - 1]
                let b = pts[i]
                let c = pts[i + 1]
                let r = min(6, hypot(b.x - a.x, b.y - a.y) / 2, hypot(c.x - b.x, c.y - b.y) / 2)
                p.addArc(tangent1End: b, tangent2End: c, radius: r)
            }
        }
        p.addLine(to: pts[pts.count - 1])
        return p
    }

    private func arrow(_ context: inout GraphicsContext, _ from: CGPoint, _ to: CGPoint, _ color: Color) {
        let angle = atan2(to.y - from.y, to.x - from.x)
        let size: CGFloat = 8
        var head = Path()
        head.move(to: to)
        head.addLine(to: CGPoint(x: to.x - size * cos(angle - .pi / 7), y: to.y - size * sin(angle - .pi / 7)))
        head.addLine(to: CGPoint(x: to.x - size * cos(angle + .pi / 7), y: to.y - size * sin(angle + .pi / 7)))
        head.closeSubpath()
        context.fill(head, with: .color(color))
    }
}

struct BoxDiagramView: View {
    let source: String
    @Environment(Overlays.self) private var overlays

    var body: some View {
        switch cachedBoxLayout(source) {
        case .success(let layout):
            FitWidth(natural: layout.size) {
                BoxCanvas(layout: layout)
            }
            .contentShape(Rectangle())
            .onTapGesture {
                overlays.diagram = layout
            }
            .help("Open full size")
            .frame(maxWidth: .infinity, alignment: .leading)
        case .failure(let error):
            DiagramFailure(source: source, reason: error.reason)
        }
    }
}

struct DiagramViewer: View {
    let layout: BoxLayout
    @ViewState private var picked: String?
    @ViewState private var preset: Int?

    private var focus: BoxFocus? {
        if let picked {
            return .box(picked, layout)
        }
        if let preset {
            return .preset(layout.presets[preset], layout)
        }
        return nil
    }

    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            if !layout.presets.isEmpty {
                HStack(spacing: 6) {
                    ForEach(Array(layout.presets.enumerated()), id: \.offset) { i, p in
                        Button(p.name) {
                            picked = nil
                            preset = preset == i ? nil : i
                        }
                        .buttonStyle(WebButtonStyle(primary: preset == i))
                    }
                }
            }
            ZoomingCanvas(layout: layout, focus: focus) { id in
                preset = nil
                picked = id == picked ? nil : id
            }
        }
        .padding(12)
        .background(Palette.raised, in: RoundedRectangle(cornerRadius: 10))
        .overlay(RoundedRectangle(cornerRadius: 10).stroke(Palette.border))
        .shadow(color: Palette.overlayShadow, radius: 14, y: 8)
    }
}

private struct TappableCanvas: View {
    let layout: BoxLayout
    let focus: BoxFocus?
    let tap: (String?) -> Void

    var body: some View {
        BoxCanvas(layout: layout, focus: focus)
            .frame(width: layout.size.width, height: layout.size.height)
            .contentShape(Rectangle())
            .onTapGesture(coordinateSpace: .local) { p in
                tap(layout.hit(p))
            }
    }
}

private final class CenteringClipView: NSClipView {
    override func constrainBoundsRect(_ proposedBounds: NSRect) -> NSRect {
        var r = super.constrainBoundsRect(proposedBounds)
        guard let doc = documentView else {
            return r
        }
        if r.width > doc.frame.width {
            r.origin.x = (doc.frame.width - r.width) / 2
        }
        if r.height > doc.frame.height {
            r.origin.y = (doc.frame.height - r.height) / 2
        }
        return r
    }
}

private final class FittingScrollView: NSScrollView {
    var fitted = false

    override func layout() {
        super.layout()
        guard !fitted, let doc = documentView, bounds.width > 0, bounds.height > 0, doc.frame.width > 0 else {
            return
        }
        fitted = true
        magnification = min(2, bounds.width / doc.frame.width, bounds.height / doc.frame.height)
    }
}

private struct ZoomingCanvas: NSViewRepresentable {
    let layout: BoxLayout
    let focus: BoxFocus?
    let tap: (String?) -> Void

    func makeNSView(context: Context) -> FittingScrollView {
        let scroll = FittingScrollView()
        scroll.contentView = CenteringClipView()
        scroll.drawsBackground = false
        scroll.hasVerticalScroller = true
        scroll.hasHorizontalScroller = true
        scroll.autohidesScrollers = true
        scroll.allowsMagnification = true
        scroll.minMagnification = 0.25
        scroll.maxMagnification = 6
        let host = NSHostingView(rootView: TappableCanvas(layout: layout, focus: focus, tap: tap))
        host.frame = CGRect(origin: .zero, size: layout.size)
        scroll.documentView = host
        return scroll
    }

    func updateNSView(_ scroll: FittingScrollView, context: Context) {
        (scroll.documentView as? NSHostingView<TappableCanvas>)?.rootView = TappableCanvas(layout: layout, focus: focus, tap: tap)
    }
}