/**
 * Deterministic FSM for Multi-Step Workflows
 *
 * Orchestrates plan -> review -> execute -> verify using rules, not LLM decisions.
 * Risk-based phase skipping: high=all phases, medium=skip planner, low=execute+test only.
 */

export type Phase = "classify"|"plan"|"plan_review"|"execute"|"code_review"|"quality_review"|"security"|"test"|"output_review"|"done"|"failed"|"paused";
export type RiskLevel = "low"|"medium"|"high";
export type Verdict = "approve"|"approve_with_notes"|"request_changes"|"reject"|"block";

export interface PhaseRecord {
  phase: Phase; enteredAt: string; exitedAt: string|null;
  verdict: Verdict|null; provider: string|null; model: string|null;
  retryCount: number; notes: string|null;
}

export interface WorkflowContext {
  id: string; currentPhase: Phase; risk: RiskLevel;
  lastVerdict: Verdict|null; retries: Record<string,number>;
  maxRetries: number; testsPass: boolean;
  history: PhaseRecord[]; createdAt: string;
  metadata: Record<string,unknown>;
}

interface Transition { from: Phase; to: Phase; condition: (ctx: WorkflowContext) => boolean; description: string; }

const HIGH_KEYWORDS = ["schema","migration","deploy","delete","drop","env","database","refactor","security","auth","production","secrets","credentials","permission"];
const MED_KEYWORDS = ["endpoint","feature","service","model","api","integration","webhook","middleware","route"];

export function classifyRisk(desc: string): RiskLevel {
  const l = desc.toLowerCase();
  if (HIGH_KEYWORDS.some(k => l.includes(k))) return "high";
  if (MED_KEYWORDS.some(k => l.includes(k))) return "medium";
  return "low";
}

const PHASE_ORDER: Phase[] = ["classify","plan","plan_review","execute","code_review","quality_review","security","test","output_review"];

const T: Transition[] = [
  {from:"classify",to:"plan",condition:c=>c.risk==="high",description:"High risk -> full planning"},
  {from:"classify",to:"execute",condition:c=>c.risk==="medium",description:"Medium risk -> skip planner"},
  {from:"classify",to:"execute",condition:c=>c.risk==="low",description:"Low risk -> direct execute"},
  {from:"plan",to:"plan_review",condition:()=>true,description:"Plan -> review"},
  {from:"plan_review",to:"execute",condition:c=>c.lastVerdict==="approve"||c.lastVerdict==="approve_with_notes",description:"Plan approved -> execute"},
  {from:"plan_review",to:"plan",condition:c=>(c.lastVerdict==="reject"||c.lastVerdict==="request_changes")&&(c.retries["plan"]??0)<c.maxRetries,description:"Plan rejected -> retry"},
  {from:"plan_review",to:"failed",condition:c=>(c.lastVerdict==="reject"||c.lastVerdict==="request_changes")&&(c.retries["plan"]??0)>=c.maxRetries,description:"Plan rejected max retries"},
  {from:"execute",to:"code_review",condition:c=>c.risk!=="low",description:"Non-low -> code review"},
  {from:"execute",to:"test",condition:c=>c.risk==="low",description:"Low -> skip reviews"},
  {from:"code_review",to:"quality_review",condition:c=>c.lastVerdict==="approve"||c.lastVerdict==="approve_with_notes",description:"Code approved -> quality"},
  {from:"code_review",to:"execute",condition:c=>(c.lastVerdict==="reject"||c.lastVerdict==="request_changes")&&(c.retries["execute"]??0)<c.maxRetries,description:"Code rejected -> re-execute"},
  {from:"code_review",to:"failed",condition:c=>(c.lastVerdict==="reject"||c.lastVerdict==="request_changes")&&(c.retries["execute"]??0)>=c.maxRetries,description:"Code rejected max retries"},
  {from:"quality_review",to:"security",condition:c=>c.risk==="high",description:"High -> security audit"},
  {from:"quality_review",to:"test",condition:c=>c.risk!=="high",description:"Non-high -> skip security"},
  {from:"security",to:"failed",condition:c=>c.lastVerdict==="block",description:"Security BLOCK -> failed"},
  {from:"security",to:"test",condition:c=>c.lastVerdict!=="block",description:"Security passed -> test"},
  {from:"test",to:"output_review",condition:c=>c.testsPass,description:"Tests pass -> output review"},
  {from:"test",to:"execute",condition:c=>!c.testsPass&&(c.retries["execute"]??0)<c.maxRetries,description:"Tests fail -> re-execute"},
  {from:"test",to:"failed",condition:c=>!c.testsPass&&(c.retries["execute"]??0)>=c.maxRetries,description:"Tests fail max retries"},
  {from:"output_review",to:"done",condition:()=>true,description:"Output reviewed -> done"},
];

export function createWorkflow(id: string, description: string, opts?: {maxRetries?: number; metadata?: Record<string,unknown>}): WorkflowContext {
  const risk = classifyRisk(description);
  return {id, currentPhase:"classify", risk, lastVerdict:null, retries:{}, maxRetries:opts?.maxRetries??3, testsPass:false,
    history:[{phase:"classify",enteredAt:new Date().toISOString(),exitedAt:null,verdict:null,provider:null,model:null,retryCount:0,notes:`Risk: ${risk}`}],
    createdAt:new Date().toISOString(), metadata:opts?.metadata??{}};
}

export function advance(ctx: WorkflowContext, result?: {verdict?:Verdict;testsPass?:boolean;provider?:string;model?:string;notes?:string}): Phase|null {
  if(result?.verdict!=null) ctx.lastVerdict=result.verdict;
  if(result?.testsPass!=null) ctx.testsPass=result.testsPass;
  const cur=ctx.history[ctx.history.length-1];
  if(cur){cur.exitedAt=new Date().toISOString();cur.verdict=result?.verdict??null;cur.provider=result?.provider??null;cur.model=result?.model??null;cur.notes=result?.notes??null;}
  for(const t of T){
    if(t.from===ctx.currentPhase&&t.condition(ctx)){
      const fi=PHASE_ORDER.indexOf(t.from),ti=PHASE_ORDER.indexOf(t.to);
      if(ti>=0&&fi>=0&&ti<=fi) ctx.retries[t.to]=(ctx.retries[t.to]??0)+1;
      ctx.currentPhase=t.to;
      ctx.history.push({phase:t.to,enteredAt:new Date().toISOString(),exitedAt:null,verdict:null,provider:null,model:null,retryCount:ctx.retries[t.to]??0,notes:t.description});
      return t.to;
    }
  }
  return null;
}

export function pause(ctx: WorkflowContext, reason: string): void {
  ctx.currentPhase="paused";
  ctx.history.push({phase:"paused",enteredAt:new Date().toISOString(),exitedAt:null,verdict:null,provider:null,model:null,retryCount:0,notes:reason});
}

export function resume(ctx: WorkflowContext, phase: Phase): void {
  const p=ctx.history[ctx.history.length-1];if(p)p.exitedAt=new Date().toISOString();
  ctx.currentPhase=phase;
  ctx.history.push({phase,enteredAt:new Date().toISOString(),exitedAt:null,verdict:null,provider:null,model:null,retryCount:ctx.retries[phase]??0,notes:"Resumed"});
}

export function isTerminated(ctx: WorkflowContext): boolean { return ctx.currentPhase==="done"||ctx.currentPhase==="failed"; }
export function getPhaseSequence(ctx: WorkflowContext): Phase[] { return ctx.history.map(r=>r.phase); }
export function getLLMCallCount(ctx: WorkflowContext): number {
  const sys: Phase[]=["classify","paused","done","failed"];
  return ctx.history.filter(r=>!sys.includes(r.phase)&&r.exitedAt!=null).length;
}