///|
/// Schema used by audit results and CLI input errors.
pub const REPORT_SCHEMA_VERSION : Int32 = 3

///|
pub(all) enum Verdict {
  Pass
  Different
  Indeterminate
}

///|
pub struct AuditResult {
  verdict : Verdict
  report : Json
}

///|
fn verdict_name(verdict : Verdict) -> String {
  match verdict {
    Pass => "pass"
    Different => "different"
    Indeterminate => "indeterminate"
  }
}

///|
fn side_name(side : Side) -> String {
  match side {
    Top => "top"
    Bottom => "bottom"
  }
}

///|
fn measured_angle(placement : Placement, convention : FileConvention) -> Double {
  let offset = match placement.side {
    Top => convention.top_angle_offset
    Bottom => convention.bottom_angle_offset
  }
  placement.angle_deg * convention.angle_sign + offset
}

///|
fn same_text(a : String, b : String) -> Bool {
  a.trim().to_lower() == b.trim().to_lower()
}

///|
fn findings(
  reference : Placement,
  target : Placement,
  policy : Policy,
  frame : Frame?,
  items : Array[Json],
) -> Unit {
  if reference.side != target.side {
    items.push({
      "ref": Json(reference.refdes),
      "kind": Json("side"),
      "baseline": Json(side_name(reference.side)),
      "delivery": Json(side_name(target.side)),
    })
    return
  }
  if !reference.value.is_empty() &&
    !target.value.is_empty() &&
    !same_text(reference.value, target.value) {
    items.push({
      "ref": Json(reference.refdes),
      "kind": Json("value"),
      "baseline": Json(reference.value),
      "delivery": Json(target.value),
    })
  }
  if !reference.footprint.is_empty() &&
    !target.footprint.is_empty() &&
    !same_text(reference.footprint, target.footprint) {
    items.push({
      "ref": Json(reference.refdes),
      "kind": Json("package"),
      "baseline": Json(reference.footprint),
      "delivery": Json(target.footprint),
    })
  }
  guard frame is Some(frame) else { return }
  let expected = position(
    reference,
    policy.baseline.units,
    policy.baseline.bottom_x is Negated,
  )
  let canonical = position(target, policy.delivery.units, frame.negate_bottom_x)
  let predicted = frame.transform.apply(canonical)
  let delta = difference(predicted, expected)
  let distance = magnitude(delta)
  if distance > policy.position_mm {
    items.push({
      "ref": Json(reference.refdes),
      "kind": Json("position"),
      "delta_x_mm": Json(delta.x),
      "delta_y_mm": Json(delta.y),
      "distance_mm": Json(distance),
    })
  }
  let rotation_deg = frame.rotation_deg
  let angle_delta = angle_wrap(
    measured_angle(target, policy.delivery) +
    rotation_deg -
    measured_angle(reference, policy.baseline),
  )
  if angle_delta.abs() > policy.angle_deg {
    items.push({
      "ref": Json(reference.refdes),
      "kind": Json("angle"),
      "delta_deg": Json(angle_delta),
    })
  }
}

///|
priv struct SideTargets {
  refs : Array[String]
  points : Array[Point]
}

///|
/// Delivery components on one side, already mapped into the baseline frame.
fn side_targets(
  delivery : Map[String, Placement],
  side : Side,
  frame : Frame,
  policy : Policy,
) -> SideTargets {
  let refs : Array[String] = []
  let points : Array[Point] = []
  let keys = delivery.keys().collect()
  keys.sort()
  for key in keys {
    let part = delivery[key]
    if part.side == side {
      let canonical = position(
        part,
        policy.delivery.units,
        frame.negate_bottom_x,
      )
      refs.push(key)
      points.push(frame.transform.apply(canonical))
    }
  }
  { refs, points, }
}

///|
/// Compare two exports of the same board revision.
/// Membership and side are always checked. Geometry requires a unique frame.
///
/// `top_gerber` and `bottom_gerber` are optional parsed copper layers used for
/// the pad-level cross-check; when absent the report records an empty pad list
/// and the previous behaviour is unchanged.
pub fn audit(
  baseline_table : PlacementTable,
  delivery_table : PlacementTable,
  policy : Policy,
  top_gerber~ : GerberDocument? = None,
  bottom_gerber~ : GerberDocument? = None,
) -> AuditResult {
  let baseline = baseline_table.rows
  let delivery = delivery_table.rows
  let anchor_issues : Array[Json] = []
  let pairs : Array[AnchorPair] = []
  for key in policy.anchors {
    match (baseline.get(key), delivery.get(key)) {
      (Some(a), Some(b)) if a.side == b.side =>
        pairs.push({ baseline: a, delivery: b, })
      (Some(_), Some(_)) =>
        anchor_issues.push({ "ref": Json(key), "kind": Json("anchor_side") })
      (None, None) =>
        anchor_issues.push({
          "ref": Json(key),
          "kind": Json("anchor_missing_both"),
        })
      (None, _) =>
        anchor_issues.push({
          "ref": Json(key),
          "kind": Json("anchor_missing_baseline"),
        })
      (_, None) =>
        anchor_issues.push({
          "ref": Json(key),
          "kind": Json("anchor_missing_delivery"),
        })
    }
  }
  let has_bottom = baseline.values().any(part => part.side == Bottom) ||
    delivery.values().any(part => part.side == Bottom)
  let search = if anchor_issues.is_empty() {
    candidate_frames(pairs, policy, has_bottom)
  } else {
    { baseline_has_area: false, accepted: [], rejected: [], }
  }
  let candidates = search.accepted
  let frame = if candidates.length() == 1 { Some(candidates[0]) } else { None }
  let keys = baseline.keys().collect()
  keys.sort()
  let extra = delivery.keys().filter(key => !baseline.contains(key)).collect()
  extra.sort()
  let missing = keys.filter(key => !delivery.contains(key))
  // A missing designator and an extra one at the same expected position is a
  // rename, not two independent errors. Pair them geometrically so the report
  // says "swapped" instead of "missing + extra".
  let swap_for_missing : Map[String, String] = Map([])
  let swapped_extra : Map[String, Bool] = Map([])
  match frame {
    Some(chosen) => {
      let limit = (policy.position_mm * 2.0).max(0.2)
      for key in missing {
        let expected = position(
          baseline[key],
          policy.baseline.units,
          policy.baseline.bottom_x is Negated,
        )
        let mut best = ""
        let mut best_distance = limit
        for candidate in extra {
          if !swapped_extra.contains(candidate) {
            let canonical = position(
              delivery[candidate],
              policy.delivery.units,
              chosen.negate_bottom_x,
            )
            let predicted = chosen.transform.apply(canonical)
            let distance = magnitude(difference(predicted, expected))
            if distance < best_distance {
              best_distance = distance
              best = candidate
            }
          }
        }
        if !best.is_empty() {
          swap_for_missing[key] = best
          swapped_extra[best] = true
        }
      }
    }
    None => ()
  }
  let evidence : Array[Json] = []
  for key in keys {
    match delivery.get(key) {
      Some(target) => findings(baseline[key], target, policy, frame, evidence)
      None =>
        match swap_for_missing.get(key) {
          Some(partner) =>
            evidence.push({
              "ref": Json(key),
              "kind": Json("swapped"),
              "with": Json(partner),
            })
          None => evidence.push({ "ref": Json(key), "kind": Json("missing") })
        }
    }
  }
  for key in extra {
    if !swapped_extra.contains(key) {
      evidence.push({ "ref": Json(key), "kind": Json("extra") })
    }
  }
  let pad_differences : Array[Json] = []
  let pad_results : Array[Json] = []
  let pad_warnings : Array[Json] = []
  let pad_sides : Array[Json] = []
  let panel_cells : Array[Json] = []
  let mut pad_checked = 0
  for layer in [(Top, top_gerber), (Bottom, bottom_gerber)] {
    guard layer is (side, Some(document)) else { continue }
    pad_sides.push(Json(side_name(side)))
    if document.panel_cell is Some(cell) {
      panel_cells.push({
        "side": Json(side_name(side)),
        "row": Json(cell.row),
        "column": Json(cell.column),
        "rows": Json(cell.grid.rows),
        "columns": Json(cell.grid.columns),
        "offset_x_mm": Json(cell.offset_mm.x),
        "offset_y_mm": Json(cell.offset_mm.y),
      })
    }
    for warning in document.warnings {
      pad_warnings.push({
        "side": Json(side_name(side)),
        "message": Json(warning),
      })
    }
    guard frame is Some(chosen) else { continue }
    let targets = side_targets(delivery, side, chosen, policy)
    let items = pad_evidence(
      document,
      targets.refs,
      targets.points,
      policy.pad_mm,
    )
    for i in 0.. {
          pad_checked += 1
          {
            "status": Json("by_reference"),
            "pad_count": Json(pad_count),
            "distance_mm": Json(distance),
            "within_tolerance": Json(distance <= policy.pad_mm),
          }
        }
        CopperOnly => { "status": Json("copper_only") }
        Unverified => { "status": Json("unverified") }
        PossibleClearance(witness) =>
          {
            "status": Json("unverified"),
            "reason": Json("possible_clearance"),
            "clearance": {
              "pad": {
                "object_number": Json(witness.pad_index),
                "statement_number": Json(witness.pad_statement),
                "pin": match witness.pin {
                  Some(pin) => Json(pin)
                  None => Json(null)
                },
                "x_mm": Json(witness.pad_center.x),
                "y_mm": Json(witness.pad_center.y),
              },
              "object": {
                "object_number": Json(witness.clear_index),
                "statement_number": Json(witness.clear_statement),
                "kind": Json(witness.clear_kind),
                "bounds_mm": {
                  "min_x": Json(witness.clear_bounds.lower.x),
                  "min_y": Json(witness.clear_bounds.lower.y),
                  "max_x": Json(witness.clear_bounds.upper.x),
                  "max_y": Json(witness.clear_bounds.upper.y),
                },
              },
            },
          }
        RepeatedReference =>
          { "status": Json("unverified"), "reason": Json("repeated_reference") }
      }
      pad_results.push({
        "ref": Json(refdes),
        "side": Json(side_name(side)),
        "evidence": details,
      })
      if pad_finding(refdes, items[i], policy.pad_mm) is Some(item) {
        pad_differences.push(item)
      }
    }
  }
  let pad_skipped = !pad_sides.is_empty() && frame is None
  let pad_status = if pad_sides.is_empty() {
    "not_requested"
  } else if pad_skipped {
    "skipped"
  } else if pad_checked < pad_results.length() {
    "incomplete"
  } else {
    "complete"
  }
  let (verdict, reason) = if !anchor_issues.is_empty() {
    (Indeterminate, Json("invalid_anchors"))
  } else if !search.baseline_has_area {
    (Indeterminate, Json("degenerate_baseline_anchors"))
  } else if candidates.is_empty() {
    (Indeterminate, Json("no_matching_frame"))
  } else if frame is None {
    (Indeterminate, Json("ambiguous_frame"))
  } else if !evidence.is_empty() || !pad_differences.is_empty() {
    (Different, Json(null))
  } else if pad_status == "incomplete" {
    (Indeterminate, Json("insufficient_pad_evidence"))
  } else if baseline.length() == pairs.length() {
    (Indeterminate, Json("no_independent_components"))
  } else {
    (Pass, Json(null))
  }
  let report : Json = {
    "schema_version": Json(REPORT_SCHEMA_VERSION),
    "status": Json(verdict_name(verdict)),
    "reason": reason,
    "frame": match frame {
      Some(chosen) => frame_json(chosen, policy)
      None => Json(null)
    },
    "candidate_frames": Json(
      candidates.map(candidate => frame_json(candidate, policy)),
    ),
    "rejected_frames": Json(search.rejected),
    "anchors": Json(policy.anchors),
    "anchor_issues": Json(anchor_issues),
    "baseline_count": Json(baseline.length()),
    "delivery_count": Json(delivery.length()),
    "differences": Json(evidence),
    "pad_differences": Json(pad_differences),
    "pad_checked": Json(pad_checked),
    "pad_skipped": Json(pad_skipped),
    "pad_status": Json(pad_status),
    "pad_sides": Json(pad_sides),
    "panel_cells": Json(panel_cells),
    "pad_evidence": Json(pad_results),
    "pad_warnings": Json(pad_warnings),
    "tolerances": {
      "position_mm": Json(policy.position_mm),
      "angle_deg": Json(policy.angle_deg),
      "anchor_mm": Json(policy.anchor_mm),
      "pad_mm": Json(policy.pad_mm),
    },
  }
  { verdict, report, }
}