lightspeed

//// Deterministic developer-tooling conformance harness for M59.

import gleam/int
import gleam/list
import gleam/string
import lightspeed/ops/generator_harness
import lightspeed/ops/hot_path_harness
import lightspeed/ops/render_churn_harness
import lightspeed/tooling/developer_productivity

pub const snapshot_version = 1

/// M59 conformance scenarios.
pub type Scenario {
  RuntimeDiagnosticsCoverageWithoutCustomInstrumentation
  ProfilingHotspotActionability
  GeneratorRefactorQualityGateDeterminism
  EditorDiagnosticsNavigationContracts
  ProductivityDeterminismGate
}

/// One M59 scenario outcome.
pub type ScenarioOutcome {
  ScenarioOutcome(
    scenario: Scenario,
    passed: Bool,
    deterministic: Bool,
    signature: String,
  )
}

/// Full M59 report.
pub type Report {
  Report(
    outcomes: List(ScenarioOutcome),
    failed_scenarios: Int,
    nondeterministic_failures: Int,
  )
}

/// Run all M59 scenarios.
pub fn run_matrix() -> Report {
  let outcomes =
    [
      RuntimeDiagnosticsCoverageWithoutCustomInstrumentation,
      ProfilingHotspotActionability,
      GeneratorRefactorQualityGateDeterminism,
      EditorDiagnosticsNavigationContracts,
      ProductivityDeterminismGate,
    ]
    |> list.map(run_scenario)

  Report(
    outcomes: outcomes,
    failed_scenarios: count_failed(outcomes),
    nondeterministic_failures: count_nondeterministic(outcomes),
  )
}

/// Run one M59 scenario twice and require deterministic parity.
pub fn run_scenario(scenario: Scenario) -> ScenarioOutcome {
  let #(first_passed, first_signature) = evaluate(scenario)
  let #(second_passed, second_signature) = evaluate(scenario)
  let deterministic =
    first_passed == second_passed && first_signature == second_signature
  let passed = first_passed && second_passed && deterministic

  ScenarioOutcome(
    scenario: scenario,
    passed: passed,
    deterministic: deterministic,
    signature: first_signature,
  )
}

/// Scenario label.
pub fn scenario_label(scenario: Scenario) -> String {
  case scenario {
    RuntimeDiagnosticsCoverageWithoutCustomInstrumentation ->
      "runtime_diagnostics_coverage_without_custom_instrumentation"
    ProfilingHotspotActionability -> "profiling_hotspot_actionability"
    GeneratorRefactorQualityGateDeterminism ->
      "generator_refactor_quality_gate_determinism"
    EditorDiagnosticsNavigationContracts ->
      "editor_diagnostics_navigation_contracts"
    ProductivityDeterminismGate -> "productivity_determinism_gate"
  }
}

/// Stable pass/fail label.
pub fn pass_fail_label(outcome: ScenarioOutcome) -> String {
  case outcome.passed {
    True -> "pass"
    False -> "fail"
  }
}

/// Scenario signature accessor.
pub fn signature(outcome: ScenarioOutcome) -> String {
  outcome.signature
}

/// Scenario accessor.
pub fn scenario(outcome: ScenarioOutcome) -> Scenario {
  outcome.scenario
}

/// Determinism accessor.
pub fn deterministic(outcome: ScenarioOutcome) -> Bool {
  outcome.deterministic
}

/// Report outcomes accessor.
pub fn outcomes(report: Report) -> List(ScenarioOutcome) {
  report.outcomes
}

/// Failed scenario count.
pub fn failed_scenarios(report: Report) -> Int {
  report.failed_scenarios
}

/// Nondeterministic scenario count.
pub fn nondeterministic_failures(report: Report) -> Int {
  report.nondeterministic_failures
}

/// Stable report signature.
pub fn report_signature(report: Report) -> String {
  let entries =
    list.map(report.outcomes, fn(outcome) {
      scenario_label(outcome.scenario)
      <> "="
      <> pass_fail_label(outcome)
      <> ":deterministic="
      <> bool_label(outcome.deterministic)
      <> ":"
      <> outcome.signature
    })

  join_with(";", entries)
}

/// Deterministic snapshot signature for M59 fixture drift gates.
pub fn snapshot_signature() -> String {
  "m59.snapshot.v"
  <> int.to_string(snapshot_version)
  <> "|"
  <> report_signature(run_matrix())
}

/// Deterministic markdown report for M59 fixture scripts.
pub fn snapshot_report_markdown() -> String {
  let report = run_matrix()
  let failed = failed_scenarios(report)
  let nondeterministic = nondeterministic_failures(report)
  let status = case failed == 0 && nondeterministic == 0 {
    True -> "OK"
    False -> "FAIL"
  }

  "# Developer Tooling Fixture Report\n\n"
  <> "snapshot_version: "
  <> int.to_string(snapshot_version)
  <> "\n"
  <> "profile_version: "
  <> developer_productivity.profile_version_label()
  <> "\n"
  <> "status: "
  <> status
  <> "\n"
  <> "failed_scenarios: "
  <> int.to_string(failed)
  <> "\n"
  <> "nondeterministic_failures: "
  <> int.to_string(nondeterministic)
  <> "\n\n"
  <> "snapshot_signature: "
  <> snapshot_signature()
  <> "\n\n"
  <> "report_signature: "
  <> report_signature(report)
  <> "\n"
}

fn evaluate(scenario: Scenario) -> #(Bool, String) {
  case scenario {
    RuntimeDiagnosticsCoverageWithoutCustomInstrumentation ->
      evaluate_runtime_diagnostics_coverage_without_custom_instrumentation()
    ProfilingHotspotActionability -> evaluate_profiling_hotspot_actionability()
    GeneratorRefactorQualityGateDeterminism ->
      evaluate_generator_refactor_quality_gate_determinism()
    EditorDiagnosticsNavigationContracts ->
      evaluate_editor_diagnostics_navigation_contracts()
    ProductivityDeterminismGate -> evaluate_productivity_determinism_gate()
  }
}

fn evaluate_runtime_diagnostics_coverage_without_custom_instrumentation() -> #(
  Bool,
  String,
) {
  let suites = developer_productivity.reference_suites()
  let passed =
    suites_all_valid(suites)
    && suites_all_diagnosable_without_custom_instrumentation(suites)
  let entries =
    list.map(suites, fn(suite) {
      let diagnostics =
        list.map(
          developer_productivity.diagnostics(suite),
          developer_productivity.diagnostics_signature,
        )

      developer_productivity.name(suite) <> ":" <> join_with(",", diagnostics)
    })

  #(passed, join_with(";", entries))
}

fn evaluate_profiling_hotspot_actionability() -> #(Bool, String) {
  let suites = developer_productivity.reference_suites()
  let passed =
    suites_all_have_profiling_contracts(suites)
    && suites_all_reduce_patch_churn(suites)
  let entries =
    list.map(suites, fn(suite) {
      let profiling =
        list.map(
          developer_productivity.profiling(suite),
          developer_productivity.profiling_signature,
        )
      let workflows =
        list.map(
          developer_productivity.refactor_workflows(suite),
          developer_productivity.refactor_workflow_signature,
        )

      developer_productivity.name(suite)
      <> ":profiling="
      <> join_with(",", profiling)
      <> ":workflows="
      <> join_with(",", workflows)
    })

  #(passed, join_with(";", entries))
}

fn evaluate_generator_refactor_quality_gate_determinism() -> #(Bool, String) {
  let suite = developer_productivity.default_suite()
  let gate_signatures =
    list.map(
      developer_productivity.quality_gates(suite),
      developer_productivity.quality_gate_signature,
    )
  let gate_prefixes =
    join_with(
      ",",
      list.map(developer_productivity.quality_gates(suite), fn(gate) {
        gate.snapshot_prefix
      }),
    )
  let generator_signature = generator_harness.snapshot_signature()
  let hot_path_signature = hot_path_harness.snapshot_signature()
  let render_signature = render_churn_harness.snapshot_signature()
  let passed =
    developer_productivity.stable_quality_signals(suite)
    && string.starts_with(generator_signature, "m25.snapshot.v")
    && string.starts_with(hot_path_signature, "m35.snapshot.v")
    && string.starts_with(render_signature, "m36.snapshot.v")
    && string.contains(gate_prefixes, "m25.snapshot.v")
    && string.contains(gate_prefixes, "m35.snapshot.v")
    && string.contains(gate_prefixes, "m36.snapshot.v")

  #(
    passed,
    "gates="
      <> join_with(";", gate_signatures)
      <> "|generator_signature="
      <> generator_signature
      <> "|hot_path_signature="
      <> hot_path_signature
      <> "|render_signature="
      <> render_signature,
  )
}

fn evaluate_editor_diagnostics_navigation_contracts() -> #(Bool, String) {
  let suite = developer_productivity.default_suite()
  let diagnostics =
    list.map(
      developer_productivity.editor_diagnostics(suite),
      developer_productivity.editor_diagnostic_signature,
    )
  let navigation =
    list.map(
      developer_productivity.navigation_contracts(suite),
      developer_productivity.navigation_signature,
    )
  let passed = developer_productivity.supports_editor_navigation(suite)

  #(
    passed,
    "diagnostics="
      <> join_with(";", diagnostics)
      <> "|navigation="
      <> join_with(";", navigation),
  )
}

fn evaluate_productivity_determinism_gate() -> #(Bool, String) {
  let first = developer_productivity.snapshot_signature()
  let second = developer_productivity.snapshot_signature()
  let fixtures = developer_productivity.fixture_snapshots()
  let passed = first == second && list.length(fixtures) == 3
  let entries =
    list.map(fixtures, fn(entry) {
      let #(label, signature) = entry
      label <> "=" <> signature
    })

  #(passed, first <> "|fixtures=" <> join_with(";", entries))
}

fn suites_all_valid(
  suites: List(developer_productivity.ProductivitySuite),
) -> Bool {
  case suites {
    [] -> True
    [suite, ..rest] ->
      developer_productivity.valid_suite(suite) && suites_all_valid(rest)
  }
}

fn suites_all_diagnosable_without_custom_instrumentation(
  suites: List(developer_productivity.ProductivitySuite),
) -> Bool {
  case suites {
    [] -> True
    [suite, ..rest] ->
      developer_productivity.diagnosable_without_custom_instrumentation(suite)
      && suites_all_diagnosable_without_custom_instrumentation(rest)
  }
}

fn suites_all_have_profiling_contracts(
  suites: List(developer_productivity.ProductivitySuite),
) -> Bool {
  case suites {
    [] -> True
    [suite, ..rest] ->
      list.length(developer_productivity.profiling(suite)) >= 3
      && suites_all_have_profiling_contracts(rest)
  }
}

fn suites_all_reduce_patch_churn(
  suites: List(developer_productivity.ProductivitySuite),
) -> Bool {
  case suites {
    [] -> True
    [suite, ..rest] ->
      developer_productivity.workflows_reduce_patch_churn(suite)
      && suites_all_reduce_patch_churn(rest)
  }
}

fn count_failed(outcomes: List(ScenarioOutcome)) -> Int {
  case outcomes {
    [] -> 0
    [outcome, ..rest] ->
      case outcome.passed {
        True -> count_failed(rest)
        False -> 1 + count_failed(rest)
      }
  }
}

fn count_nondeterministic(outcomes: List(ScenarioOutcome)) -> Int {
  case outcomes {
    [] -> 0
    [outcome, ..rest] ->
      case outcome.deterministic {
        True -> count_nondeterministic(rest)
        False -> 1 + count_nondeterministic(rest)
      }
  }
}

fn bool_label(value: Bool) -> String {
  case value {
    True -> "true"
    False -> "false"
  }
}

fn join_with(separator: String, values: List(String)) -> String {
  case values {
    [] -> ""
    [first, ..rest] ->
      list.fold(rest, first, fn(accumulator, value) {
        accumulator <> separator <> value
      })
  }
}