import assert from "node:assert/strict";
import { after, before, test } from "node:test";

import { createServer } from "vite";

let server;
let parseE30ReviewCatalog;
let parseE30ReviewItems;
let parseE30ReviewItemDetail;
let fetchE30ReviewItems;
let E30ReviewContractError;

const resultId = `e30-materialization-${"a".repeat(64)}`;
const reviewPackId = `e30-review-pack-${"b".repeat(64)}`;
const e29ResultId = `e29-camera-geometry-${"c".repeat(64)}`;
const itemId = `e30-review-item-${"d".repeat(64)}`;

function result(overrides = {}) {
  return {
    result_id: resultId,
    created_at_utc: "2026-07-26T00:00:00Z",
    review_pack_id: reviewPackId,
    e29_result_id: e29ResultId,
    source_session_id: "20260720T065719Z_viewer_live",
    item_count: 486,
    stratum_counts: {
      conflict: 38,
      agree: 96,
      "camera-only": 128,
      unknown: 96,
      "geometry-only": 128,
    },
    reason_taxonomy: ["time_mismatch", "geometry_mismatch", "other"],
    projection: {
      width: 800,
      height: 600,
      source_id: "sensor.camera.right",
      calibration_slot: "camera_1",
    },
    camera_evidence_available: true,
    human_review_complete: false,
    lab_published: false,
    access: "read-only",
    authority: {
      commands_enabled: false,
      navigation_or_safety_accepted: false,
    },
    ...overrides,
  };
}

function item(overrides = {}) {
  return {
    item_id: itemId,
    sequence: 212,
    review_key: "semantic:1800:1",
    stratum: "conflict",
    range_bucket: "unavailable",
    frame_index: 1800,
    source_frame_index: 1800,
    session_seconds: 215.323857292,
    locator: {
      kind: "semantic-observation",
      observation_index: 1,
    },
    snapshot: {
      label: "car",
      geometry_status: "conflict",
      geometry_reason: "camera-object-region-observed-as-local-surface",
      range_m: null,
      bbox_xyxy: [223.6, 270.2, 282.4, 305.2],
    },
    materialization: {
      frame_point_count: 1813,
      projected_point_count: 3,
      projection_width: 800,
      projection_height: 600,
      candidate_point_count: 2,
      selected_point_count: 1,
      rejected_candidate_point_count: 1,
      selected_and_candidate_lossless: true,
      free_space_valid: false,
      human_review_complete: false,
      detector_score: 0.83,
    },
    camera_frame_available: true,
    engineering_triage: {
      provenance: "deterministic-evidence-readiness/v1",
      state: "ready-for-ai-review",
      attention: "standard",
      signals: [],
      semantic_verdict: null,
      human_exception_required: null,
    },
    review: {
      state: "unreviewed",
      reason_code: null,
      notes: null,
    },
    access: "read-only",
    ...overrides,
  };
}

function catalog(overrides = {}) {
  return {
    schema_version: "missioncore.laboratory-e30-catalog/v1",
    configured: true,
    items: [result()],
    candidate_total: 1,
    invalid_total: 0,
    access: "read-only",
    ...overrides,
  };
}

function items(overrides = {}) {
  return {
    schema_version: "missioncore.laboratory-e30-items/v1",
    result_id: resultId,
    stratum: "conflict",
    items: [item()],
    total: 38,
    next_cursor: null,
    reason_taxonomy: ["time_mismatch", "geometry_mismatch", "other"],
    access: "read-only",
    ...overrides,
  };
}

function detail(overrides = {}) {
  return {
    schema_version: "missioncore.laboratory-e30-item-detail/v1",
    result_id: resultId,
    item: {
      ...item(),
      camera_frame: {
        available: true,
        url: `/api/v1/laboratory/e30/reviews/${resultId}/items/${itemId}/camera-frame?generation=${"e".repeat(64)}`,
        sha256: "e".repeat(64),
        width: 800,
        height: 600,
        source_frame_index: 1800,
        exact_source_frame: true,
      },
      selected: {
        source_indices: [7],
        points_map_xyz_m: [[1, 2, 3]],
      },
      candidate: {
        source_indices: [7, 8],
        points_map_xyz_m: [[1, 2, 3], [1.1, 2.1, 3.1]],
      },
      projection: {
        source_indices: [7, 8, 9],
        points_map_xyz_m: [[1, 2, 3], [1.1, 2.1, 3.1], [2, 3, 4]],
        pixels_xy: [[220, 270], [230, 275], [500, 400]],
        depth_m: [3, 3.1, 4],
        point_class: [2, 1, 0],
        point_height_m: [0.8, 0.1, 0],
        candidate_mask: [1, 1, 0],
        selected_mask: [1, 0, 0],
      },
      pose: {
        position_map_xyz_m: [10, 11, 0],
        orientation_map_from_lidar_xyzw: [0, 0, 0, 1],
      },
      ...overrides,
    },
    access: "read-only",
  };
}

before(async () => {
  server = await createServer({
    appType: "custom",
    logLevel: "silent",
    server: { middlewareMode: true },
  });
  ({
    parseE30ReviewCatalog,
    parseE30ReviewItems,
    parseE30ReviewItemDetail,
    fetchE30ReviewItems,
    E30ReviewContractError,
  } = await server.ssrLoadModule("/src/core/laboratory/e30Review.ts"));
});

after(async () => {
  await server?.close();
});

test("decodes immutable E30 catalog, strata and exact point evidence", () => {
  const decodedCatalog = parseE30ReviewCatalog(catalog());
  const decodedItems = parseE30ReviewItems(items());
  const decodedDetail = parseE30ReviewItemDetail(detail());

  assert.equal(decodedCatalog.items[0].stratumCounts.conflict, 38);
  assert.equal(decodedCatalog.items[0].humanReviewComplete, false);
  assert.equal(decodedItems.items[0].sessionSeconds, 215.323857292);
  assert.deepEqual(decodedDetail.selected.sourceIndices, [7]);
  assert.deepEqual(decodedDetail.projection.selectedMask, [1, 0, 0]);
  assert.equal(decodedDetail.cameraFrame.exactSourceFrame, true);
});

test("rejects authority escalation and inconsistent materialized arrays", () => {
  assert.throws(
    () => parseE30ReviewCatalog(catalog({
      items: [result({
        authority: {
          commands_enabled: true,
          navigation_or_safety_accepted: false,
        },
      })],
    })),
    E30ReviewContractError,
  );
  assert.throws(
    () => parseE30ReviewItemDetail(detail({
      selected: {
        source_indices: [7, 8],
        points_map_xyz_m: [[1, 2, 3]],
      },
    })),
    E30ReviewContractError,
  );
});

test("fetches the canonical read-only stratum endpoint", async () => {
  const requests = [];
  const decoded = await fetchE30ReviewItems(resultId, "conflict", {
    fetcher: async (input, init) => {
      requests.push({ input: String(input), method: init?.method });
      return new Response(JSON.stringify(items()), {
        status: 200,
        headers: { "Content-Type": "application/json" },
      });
    },
  });

  assert.equal(decoded.total, 38);
  assert.deepEqual(requests, [{
    input: `/api/v1/laboratory/e30/reviews/${resultId}/items?stratum=conflict&limit=128&cursor=0`,
    method: "GET",
  }]);
});