export const SCHEMA_VERSION = 2 as const;
export const LEGACY_SCHEMA_VERSION = 1 as const;
export const START_PLACE_ID = "pl_session_start";
export const MAIN_TOKEN_ID = "tok_main";

export type PlaceType =
  | "Goal"
  | "Condition"
  | "InformationNeed"
  | "DecisionOutcome"
  | "Gate"
  | "Verified"
  | "Outcome";

export type PlaceState = "unknown" | "satisfied" | "invalidated";
export type GateState = "open" | "closed" | "blocked";

export interface Place {
  id: string;
  type: PlaceType;
  label: string;
  state: PlaceState;
  gateState?: GateState;
  evidenceIds: string[];
}

export type TransitionType =
  | "Investigate"
  | "Decide"
  | "Implement"
  | "Verify"
  | "Recover"
  | "AskHuman"
  | "Branch"
  | "Conclude";

export type TransitionStatus = "planned" | "active" | "completed" | "failed" | "retired" | "superseded";
export type PlanCommitment = "committed" | "provisional" | "directional";
export type PlanningSource = "declared" | "human" | "migration_default";

export type PlanningDependency =
  | { kind: "place_state"; placeId: string; state: "satisfied" | "invalidated" }
  | { kind: "gate_state"; placeId: string; state: GateState }
  | { kind: "transition_outcome"; transitionId: string; outcome: "success" | "failure" }
  | { kind: "evidence_selector"; selector: string };

export interface TransitionPlanningInput {
  commitment: PlanCommitment;
  dependsOn?: PlanningDependency[];
  reconsiderWhen?: string;
  refinementTrigger?: string;
}

export interface TransitionPlanning {
  commitment: PlanCommitment;
  dependsOn: PlanningDependency[];
  requiresRefinement: boolean;
  reconsiderWhen?: string;
  refinementTrigger?: string;
  source: PlanningSource;
}

export interface TransitionContract {
  whyNow?: string;
  scope?: string;
  expectedEvidence: string[];
  evidenceSelectors: string[];
  allowedEpisodeKinds: string[];
  exitCondition?: string;
  failureCondition?: string;
}

export interface Transition {
  id: string;
  type: TransitionType;
  intent: string;
  status: TransitionStatus;
  planning: TransitionPlanning;
  contract: TransitionContract;
  evidenceIds: string[];
  supersededBy?: string;
}

export type ArcKind = "flow" | "read" | "success" | "failure";

export interface Arc {
  id: string;
  fromId: string;
  toId: string;
  kind: ArcKind;
}

export type RefinementStatus = "draft" | "active" | "completed" | "superseded";

export interface TransitionRefinement {
  id: string;
  parentTransitionId: string;
  nodeIds: string[];
  arcIds: string[];
  entryPlaceId: string;
  successExitPlaceId: string;
  failureExitPlaceId?: string;
  status: RefinementStatus;
  outcome?: "success" | "failure";
  supersededBy?: string;
}

export interface ExecutionToken {
  id: string;
  placeId: string;
  status: "active" | "waiting" | "blocked" | "complete";
}

export interface Reservation {
  transitionId: string;
  tokenId: string;
  inputPlaceId: string;
}

export type EvidenceType =
  | "agent_declaration"
  | "tool_episode"
  | "test_result"
  | "error_signature"
  | "git_fact"
  | "external_gate"
  | "human_statement"
  | "observer_inference";

export interface EvidenceInput {
  evidenceId: string;
  type: EvidenceType;
  summary: string;
  source: string;
  selectors?: string[];
  observedAt?: string;
  redacted?: boolean;
}

export interface Evidence extends EvidenceInput {
  selectors: string[];
  observedAt: string;
  redacted: boolean;
}

export interface AppliedPatchRecord {
  patchId: string;
  revision: number;
  snapshotHash: string;
  requestHash: string;
}

export interface WorkflowState {
  schemaVersion: typeof SCHEMA_VERSION;
  revision: number;
  rootIntent?: string;
  places: Record<string, Place>;
  transitions: Record<string, Transition>;
  arcs: Record<string, Arc>;
  refinements: Record<string, TransitionRefinement>;
  token: ExecutionToken;
  reservation?: Reservation;
  evidence: Record<string, Evidence>;
  appliedPatches: Record<string, AppliedPatchRecord>;
}

export interface SetRootIntentOp {
  op: "set_root_intent";
  rootIntent: string;
}

export interface CreatePlaceOp {
  op: "create_place";
  placeId: string;
  placeType: PlaceType;
  label: string;
  placeState?: PlaceState;
  gateState?: GateState;
}

export interface CreateTransitionOp {
  op: "create_transition";
  transitionId: string;
  transitionType: TransitionType;
  intent: string;
  planning: TransitionPlanningInput;
  whyNow?: string;
  scope?: string;
  expectedEvidence?: string[];
  evidenceSelectors?: string[];
  allowedEpisodeKinds?: string[];
  exitCondition?: string;
  failureCondition?: string;
}

export interface ConnectOp {
  op: "connect";
  arcId: string;
  fromId: string;
  toId: string;
  arcKind: ArcKind;
}

export interface SetPlaceStateOp {
  op: "set_place_state";
  placeId: string;
  placeState: PlaceState;
  evidenceIds?: string[];
}

export interface SetTransitionContractOp {
  op: "set_transition_contract";
  transitionId: string;
  whyNow?: string;
  scope?: string;
  expectedEvidence?: string[];
  evidenceSelectors?: string[];
  allowedEpisodeKinds?: string[];
  exitCondition?: string;
  failureCondition?: string;
}

export interface SetTransitionPlanningOp {
  op: "set_transition_planning";
  transitionId: string;
  planning: Partial<TransitionPlanningInput>;
  reason: string;
  evidenceIds?: string[];
}

export interface RefineTransitionOp {
  op: "refine_transition";
  refinementId: string;
  parentTransitionId: string;
  nodeIds: string[];
  arcIds: string[];
  entryPlaceId: string;
  successExitPlaceId: string;
  failureExitPlaceId?: string;
  reason: string;
  evidenceIds?: string[];
}

export interface SupersedeRefinementOp {
  op: "supersede_refinement";
  oldRefinementId: string;
  newRefinementId: string;
  reason: string;
  evidenceIds?: string[];
}

export interface ActivateTransitionOp {
  op: "activate_transition";
  transitionId: string;
  tokenId: string;
}

export interface CompleteTransitionOp {
  op: "complete_transition";
  transitionId: string;
  tokenId: string;
  evidenceIds?: string[];
}

export interface FailTransitionOp {
  op: "fail_transition";
  transitionId: string;
  tokenId: string;
  evidenceIds?: string[];
}

export interface RetireTransitionOp {
  op: "retire_transition";
  transitionId: string;
  reason: string;
}

export interface SupersedeTransitionOp {
  op: "supersede_transition";
  oldTransitionId: string;
  newTransitionId: string;
  reason: string;
  evidenceIds?: string[];
}

export interface AttachEvidenceOp {
  op: "attach_evidence";
  targetId: string;
  evidence: EvidenceInput;
}

export interface MarkGateOp {
  op: "mark_gate";
  placeId: string;
  gateState: GateState;
  evidenceIds?: string[];
}

export type GraphPatchOp =
  | SetRootIntentOp
  | CreatePlaceOp
  | CreateTransitionOp
  | ConnectOp
  | SetPlaceStateOp
  | SetTransitionContractOp
  | SetTransitionPlanningOp
  | RefineTransitionOp
  | SupersedeRefinementOp
  | ActivateTransitionOp
  | CompleteTransitionOp
  | FailTransitionOp
  | RetireTransitionOp
  | SupersedeTransitionOp
  | AttachEvidenceOp
  | MarkGateOp;

export interface GraphPatch {
  schemaVersion: typeof SCHEMA_VERSION;
  patchId: string;
  baseRevision: number;
  idempotencyKey: string;
  correlationId?: string;
  /** Runtime-verified human Evidence IDs. Internal committed-envelope metadata, never exposed in GraphPatchSchema. */
  trustedHumanEvidenceIds?: string[];
  ops: GraphPatchOp[];
}

export interface DomainEvent {
  kind: string;
  opIndex: number;
  eventIndex: number;
  payload: Record<string, unknown>;
}

export interface CommittedBatch {
  patch: GraphPatch;
  revision: number;
  events: DomainEvent[];
  snapshotHash: string;
  committedAt: string;
}

export type PatchFailureKind = "conflict" | "rejected";

export type ApplyPatchResult =
  | {
      status: "applied";
      state: WorkflowState;
      batch: CommittedBatch;
    }
  | {
      status: "already_applied";
      state: WorkflowState;
      revision: number;
      snapshotHash: string;
    }
  | {
      status: PatchFailureKind;
      state: WorkflowState;
      error: string;
      currentRevision: number;
    };

export type AlignmentState = "pending" | "aligned" | "lagging" | "diverged" | "unknown";
export type ExecutionPositionMode = "at_place" | "executing" | "blocked" | "complete" | "unanchored";

export interface ExecutionPosition {
  mode: ExecutionPositionMode;
  activeLeafTransitionId?: string;
  activeShellTransitionIds: string[];
  tokenPlaceId: string;
  alignment: AlignmentState;
}

export interface AttentionFuture {
  transitionId: string;
  intent: string;
  commitment: PlanCommitment;
  label: string;
}

export interface AttentionView {
  revision: number;
  rootIntent: string;
  stack: string[];
  now: string;
  why: string;
  next: string[];
  future: AttentionFuture[];
  watch: string[];
  alignment: AlignmentState;
  position: ExecutionPosition;
  activeLeafTransitionId?: string;
  activeShellTransitionIds: string[];
  snapshotHash: string;
}

export interface NodeChange {
  revision: number;
  committedAt: string;
  checkpointEntryId: string;
  parentEntryId?: string;
  patchId: string;
  actor: "agent" | "human" | "observer" | "external";
  targetId: string;
  operation: string;
  opIndex: number;
  eventIndex: number;
  summary: string;
  before?: unknown;
  after?: unknown;
  reason?: string;
}

export interface GraphCheckpointDetails {
  kind: "intent-petri/graph-checkpoint";
  checkpointSchemaVersion?: typeof SCHEMA_VERSION;
  migratedFromSchemaVersion?: typeof LEGACY_SCHEMA_VERSION;
  status: ApplyPatchResult["status"];
  patchId: string;
  revision: number;
  snapshotHash: string;
  state?: WorkflowState;
  batch?: CommittedBatch;
  attention?: AttentionView;
  error?: string;
}