lightspeed

//// Deterministic turnkey-presets conformance harness for M58.

import gleam/int
import gleam/list
import lightspeed/platform/turnkey_presets

pub const snapshot_version = 1

/// M58 conformance scenarios.
pub type Scenario {
  OneCommandSecureScaffoldBaseline
  SecureDefaultsAndExplicitOverrideSeams
  ReferenceScenarioCriticalFlowCertification
  OverridesWithoutFrameworkInternalEdits
  PresetLifecycleDeterminismGate
}

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

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

/// Run all M58 scenarios.
pub fn run_matrix() -> Report {
  let outcomes =
    [
      OneCommandSecureScaffoldBaseline,
      SecureDefaultsAndExplicitOverrideSeams,
      ReferenceScenarioCriticalFlowCertification,
      OverridesWithoutFrameworkInternalEdits,
      PresetLifecycleDeterminismGate,
    ]
    |> list.map(run_scenario)

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

/// Run one 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 {
    OneCommandSecureScaffoldBaseline -> "one_command_secure_scaffold_baseline"
    SecureDefaultsAndExplicitOverrideSeams ->
      "secure_defaults_and_explicit_override_seams"
    ReferenceScenarioCriticalFlowCertification ->
      "reference_scenario_critical_flow_certification"
    OverridesWithoutFrameworkInternalEdits ->
      "overrides_without_framework_internal_edits"
    PresetLifecycleDeterminismGate -> "preset_lifecycle_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 M58 fixture drift gates.
pub fn snapshot_signature() -> String {
  "m58.snapshot.v"
  <> int.to_string(snapshot_version)
  <> "|"
  <> report_signature(run_matrix())
}

/// Deterministic markdown report for M58 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"
  }

  "# Turnkey Presets Fixture Report\n\n"
  <> "snapshot_version: "
  <> int.to_string(snapshot_version)
  <> "\n"
  <> "profile_version: "
  <> turnkey_presets.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 {
    OneCommandSecureScaffoldBaseline ->
      evaluate_one_command_secure_scaffold_baseline()
    SecureDefaultsAndExplicitOverrideSeams ->
      evaluate_secure_defaults_and_explicit_override_seams()
    ReferenceScenarioCriticalFlowCertification ->
      evaluate_reference_scenario_critical_flow_certification()
    OverridesWithoutFrameworkInternalEdits ->
      evaluate_overrides_without_framework_internal_edits()
    PresetLifecycleDeterminismGate ->
      evaluate_preset_lifecycle_determinism_gate()
  }
}

fn evaluate_one_command_secure_scaffold_baseline() -> #(Bool, String) {
  let presets = turnkey_presets.reference_presets()
  let passed =
    list.length(presets) == 3
    && presets_all_scaffoldable_secure_baselines(presets)
  let entries =
    list.map(presets, fn(preset) {
      turnkey_presets.name(preset)
      <> ":"
      <> turnkey_presets.scaffold_command(preset)
    })

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

fn evaluate_secure_defaults_and_explicit_override_seams() -> #(Bool, String) {
  let presets = turnkey_presets.reference_presets()
  let passed =
    presets_all_valid(presets)
    && presets_all_secure(presets)
    && presets_all_have_explicit_seams(presets)
  let entries =
    list.map(presets, fn(preset) {
      turnkey_presets.name(preset)
      <> ":secure="
      <> bool_label(turnkey_presets.secure_defaults(preset))
      <> ":overrides="
      <> turnkey_presets.override_surface_signature(preset)
    })

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

fn evaluate_reference_scenario_critical_flow_certification() -> #(Bool, String) {
  let scenarios = turnkey_presets.reference_scenarios()
  let passed = list.length(scenarios) == 3 && scenarios_all_certified(scenarios)
  let entries = list.map(scenarios, turnkey_presets.scenario_signature)

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

fn evaluate_overrides_without_framework_internal_edits() -> #(Bool, String) {
  let baseline = turnkey_presets.secure_saas_preset()
  let custom_override =
    turnkey_presets.override_hook(
      turnkey_presets.QueueSeam,
      "MyApp.Queue.CustomPolicy",
      "select_retry_queue",
      "route retry queue by tenant risk class",
    )
  let customized = turnkey_presets.with_override_hook(baseline, custom_override)
  let passed =
    turnkey_presets.override_without_internal_edits(customized)
    && turnkey_presets.valid(customized)
  let signature =
    "baseline="
    <> turnkey_presets.override_surface_signature(baseline)
    <> "|customized="
    <> turnkey_presets.override_surface_signature(customized)
    <> "|internal_edits="
    <> bool_label(turnkey_presets.requires_framework_internal_edits(customized))

  #(passed, signature)
}

fn evaluate_preset_lifecycle_determinism_gate() -> #(Bool, String) {
  let first = turnkey_presets.snapshot_signature()
  let second = turnkey_presets.snapshot_signature()
  let fixtures = turnkey_presets.fixture_snapshots()
  let passed = first == second && list.length(fixtures) == 3
  let fixture_entries =
    list.map(fixtures, fn(entry) {
      let #(label, value) = entry
      label <> "=" <> value
    })

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

fn presets_all_scaffoldable_secure_baselines(
  presets: List(turnkey_presets.StarterPreset),
) -> Bool {
  case presets {
    [] -> True
    [preset, ..rest] ->
      turnkey_presets.scaffoldable_secure_baseline(preset)
      && presets_all_scaffoldable_secure_baselines(rest)
  }
}

fn presets_all_valid(presets: List(turnkey_presets.StarterPreset)) -> Bool {
  case presets {
    [] -> True
    [preset, ..rest] -> turnkey_presets.valid(preset) && presets_all_valid(rest)
  }
}

fn presets_all_secure(presets: List(turnkey_presets.StarterPreset)) -> Bool {
  case presets {
    [] -> True
    [preset, ..rest] ->
      turnkey_presets.secure_defaults(preset) && presets_all_secure(rest)
  }
}

fn presets_all_have_explicit_seams(
  presets: List(turnkey_presets.StarterPreset),
) -> Bool {
  case presets {
    [] -> True
    [preset, ..rest] ->
      turnkey_presets.has_explicit_override_seams(preset)
      && presets_all_have_explicit_seams(rest)
  }
}

fn scenarios_all_certified(
  scenarios: List(turnkey_presets.ReferenceScenario),
) -> Bool {
  case scenarios {
    [] -> True
    [scenario, ..rest] ->
      turnkey_presets.scenario_certified(scenario)
      && scenarios_all_certified(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
      })
  }
}