lightspeed

//// Production-readiness gate bundle contracts for post-M60 certification.

import gleam/int
import gleam/list
import gleam/string
import lightspeed/ops/chaos_expansion_harness
import lightspeed/ops/durable_backend_harness
import lightspeed/ops/etl_reliability_harness
import lightspeed/ops/failover_harness
import lightspeed/ops/maturity_harness
import lightspeed/ops/operational_autopilot_harness
import lightspeed/ops/operations_kit_harness
import lightspeed/ops/overload_harness
import lightspeed/ops/pipeline_operations_surface_harness
import lightspeed/ops/replay_diagnostics_harness
import lightspeed/ops/tenant_expansion_harness

pub const snapshot_version = 1

/// Readiness risk class for one release gate.
pub type RiskClass {
  RuntimeResilience
  DataIntegrity
  TenantIsolation
  OperationalControl
  ReleaseGovernance
}

/// One production-readiness gate status.
pub type GateStatus {
  GateStatus(
    name: String,
    risk_class: RiskClass,
    required: Bool,
    expected_prefix: String,
    observed_signature: String,
    remediation: String,
    passed: Bool,
  )
}

/// Required production-readiness gates.
pub fn required_gates() -> List(GateStatus) {
  [
    gate(
      "m27_failover_fixture",
      RuntimeResilience,
      True,
      "m27.snapshot.v1|",
      failover_harness.snapshot_signature(),
      "make failover-fixture-gate",
    ),
    gate(
      "m33_etl_reliability_fixture",
      DataIntegrity,
      True,
      "m33.snapshot.v1|",
      etl_reliability_harness.snapshot_signature(),
      "make etl-fixture-gate",
    ),
    gate(
      "m40_operations_kit_fixture",
      OperationalControl,
      True,
      "m40.snapshot.v1|",
      operations_kit_harness.snapshot_signature(),
      "make operations-kit-fixture-gate",
    ),
    gate(
      "m42_replay_diagnostics_fixture",
      OperationalControl,
      True,
      "m42.snapshot.v1|",
      replay_diagnostics_harness.snapshot_signature(),
      "make replay-diagnostics-fixture-gate",
    ),
    gate(
      "m47_maturity_fixture",
      ReleaseGovernance,
      True,
      "m47.snapshot.v1|",
      maturity_harness.snapshot_signature(),
      "make maturity-fixture-gate",
    ),
    gate(
      "m49_durable_backend_fixture",
      RuntimeResilience,
      True,
      "m49.snapshot.v1|",
      durable_backend_harness.snapshot_signature(),
      "make durable-backend-fixture-gate",
    ),
    gate(
      "m50_overload_fixture",
      RuntimeResilience,
      True,
      "m50.snapshot.v1|",
      overload_harness.snapshot_signature(),
      "make overload-fixture-gate",
    ),
    gate(
      "m52_tenant_expansion_fixture",
      TenantIsolation,
      True,
      "m52.snapshot.v1|",
      tenant_expansion_harness.snapshot_signature(),
      "make tenant-expansion-fixture-gate",
    ),
    gate(
      "m53_chaos_expansion_fixture",
      RuntimeResilience,
      True,
      "m53.snapshot.v1|",
      chaos_expansion_harness.snapshot_signature(),
      "make chaos-expansion-fixture-gate",
    ),
    gate(
      "m54_operational_autopilot_fixture",
      OperationalControl,
      True,
      "m54.snapshot.v1|",
      operational_autopilot_harness.snapshot_signature(),
      "make operational-autopilot-fixture-gate",
    ),
    gate(
      "m60_pipeline_operations_surface_fixture",
      DataIntegrity,
      True,
      "m60.snapshot.v1|",
      pipeline_operations_surface_harness.snapshot_signature(),
      "make pipeline-operations-surface-fixture-gate",
    ),
  ]
}

/// `True` when all required gates pass.
pub fn ready() -> Bool {
  case failing_required_gates() {
    [] -> True
    _ -> False
  }
}

/// Required gates that are currently failing.
pub fn failing_required_gates() -> List(GateStatus) {
  collect_failing_required(required_gates(), [])
  |> list.reverse()
}

/// Gate name accessor.
pub fn gate_name(gate: GateStatus) -> String {
  gate.name
}

/// Risk-class accessor.
pub fn risk_class(gate: GateStatus) -> RiskClass {
  gate.risk_class
}

/// Passed accessor.
pub fn gate_passed(gate: GateStatus) -> Bool {
  gate.passed
}

/// Required accessor.
pub fn gate_required(gate: GateStatus) -> Bool {
  gate.required
}

/// Remediation accessor.
pub fn remediation(gate: GateStatus) -> String {
  gate.remediation
}

/// Stable risk-class label.
pub fn risk_class_label(risk_class: RiskClass) -> String {
  case risk_class {
    RuntimeResilience -> "runtime_resilience"
    DataIntegrity -> "data_integrity"
    TenantIsolation -> "tenant_isolation"
    OperationalControl -> "operational_control"
    ReleaseGovernance -> "release_governance"
  }
}

/// Stable gate signature.
pub fn gate_signature(gate: GateStatus) -> String {
  "name="
  <> gate.name
  <> "|risk="
  <> risk_class_label(gate.risk_class)
  <> "|required="
  <> bool_label(gate.required)
  <> "|expected="
  <> gate.expected_prefix
  <> "|observed="
  <> gate.observed_signature
  <> "|passed="
  <> bool_label(gate.passed)
  <> "|remediation="
  <> gate.remediation
}

/// Deterministic production-readiness snapshot signature.
pub fn snapshot_signature() -> String {
  let gates = required_gates()

  "prod.ready.v"
  <> int.to_string(snapshot_version)
  <> "|ready="
  <> bool_label(ready())
  <> "|gate_count="
  <> int.to_string(list.length(gates))
  <> "|gates="
  <> join_with(";", list.map(gates, gate_signature))
}

fn gate(
  name: String,
  risk_class: RiskClass,
  required: Bool,
  expected_prefix: String,
  observed_signature: String,
  remediation: String,
) -> GateStatus {
  let passed = string.starts_with(observed_signature, expected_prefix)

  GateStatus(
    name: name,
    risk_class: risk_class,
    required: required,
    expected_prefix: expected_prefix,
    observed_signature: observed_signature,
    remediation: remediation,
    passed: passed,
  )
}

fn collect_failing_required(
  gates: List(GateStatus),
  failing_rev: List(GateStatus),
) -> List(GateStatus) {
  case gates {
    [] -> failing_rev
    [entry, ..rest] ->
      case entry.required && !entry.passed {
        True -> collect_failing_required(rest, [entry, ..failing_rev])
        False -> collect_failing_required(rest, failing_rev)
      }
  }
}

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
      })
  }
}