// Production Implementation: FlowState Execution State Memory Controller
// Berdasarkan Arsitektur Ant International / Ant Group (arXiv:2609.34565 - Late 2026)
//
// Karakteristik Inti:
// 1. Persistent State Repository (M_k): Repositori runtime lintas-request (node, relasi, bukti alat mentah).
// 2. Historical State Index (G_k): Indeks ringkas terdistilasi yang disuntikkan ke prompt context model.
// 3. Active State (S_{k,t}): Graf memori kerja aktif pada langkah t (5 tipe semantik).
// 4. Incremental State Update (ISU): Operasi Add, Update, Remove lokal dengan validasi aturan P.
// 5. Progressive State Access (PSA): Pengungkapan bukti historis dan traversal relasi bertahap secara on-demand.

export type SemanticStateType =
  | 'preference'   // User-side: preferensi, batasan, tujuan pengguna
  | 'knowledge'    // Environment-side: observasi fakta langsung dari alat
  | 'attribute'    // Environment-side: atribut entitas terdistilasi
  | 'judgement'    // Agent-side: evaluasi, rencana, mitigasi risiko
  | 'artifact';    // Agent-side: luaran terstruktur yang dapat dipakai ulang

export interface StateNode {
  id: string;               // Semantic identifier unik (misal: "pref_budget", "hotel_policy_c2")
  type: SemanticStateType;
  sourceRequestId: string;  // q_k sumber penciptaan
  summary: string;          // Ringkasan untuk indeks ringan G_k
  fullContent: string;      // Konten lengkap yang diungkap saat PSA
  relatedNodeIds: string[]; // Relasi terarah ke node lain
  toolObservationRef?: string; // ID observasi mentah lingkungan jika relevan
  createdAtStep: number;
}

export interface StateDelta {
  add?: StateNode[];
  update?: Partial[];
  remove?: string[];
}

export interface AccessRequest {
  targetNodeIds: string[]; // Node historis yang diminta diungkap pada turn t
}

export interface AgentExecutionStepOutput {
  stateDelta?: StateDelta;
  accessRequest?: AccessRequest;
  executionDecision?: {
    actionType: 'tool_call' | 'final_answer' | 'defer_to_expansion';
    tool?: string;
    params?: Record;
    answer?: string;
  };
}

export class FlowStateRuntimeController {
  private persistentRepository: Map = new Map();
  private rawToolEvidenceStore: Map = new Map();
  private activeStateNodes: Map = new Map();
  private currentRequestId: string = '';
  private currentStep: number = 0;

  constructor() {}

  /**
   * Menginisialisasi request baru q_k: membangun indeks G_k dan mereset active state S_{k,1}
   */
  public startRequest(requestId: string): { historicalIndex: Array<{ id: string; summary: string }> } {
    this.currentRequestId = requestId;
    this.currentStep = 1;
    this.activeStateNodes.clear();

    // Buat G_k = Index(M_k) yang sangat ringan untuk disuntikkan ke prompt context
    const historicalIndex: Array<{ id: string; summary: string }> = [];
    for (const [id, node] of this.persistentRepository.entries()) {
      historicalIndex.push({ id, summary: node.summary });
    }

    return { historicalIndex };
  }

  /**
   * Siklus Utama Langkah t: Memvalidasi dan mengeksekusi ISU serta PSA secara atomik
   */
  public processStepOutput(
    output: AgentExecutionStepOutput,
    currentToolObservation?: { id: string; payload: string }
  ): {
    activeState: StateNode[];
    disclosedEvidence: Array<{ id: string; content: string }>;
    readyForAction: boolean;
  } {
    if (currentToolObservation) {
      this.rawToolEvidenceStore.set(currentToolObservation.id, currentToolObservation.payload);
    }

    // 1. Eksekusi Incremental State Update (ISU) dengan Aturan Validasi P
    if (output.stateDelta) {
      this.applyIncrementalStateUpdate(output.stateDelta);
    }

    // 2. Eksekusi Progressive State Access (PSA)
    const disclosedEvidence: Array<{ id: string; content: string }> = [];
    if (output.accessRequest && output.accessRequest.targetNodeIds.length > 0) {
      for (const targetId of output.accessRequest.targetNodeIds) {
        // Validasi: Node harus ada di M_k atau mereferensikan raw tool evidence
        if (this.persistentRepository.has(targetId)) {
          const histNode = this.persistentRepository.get(targetId)!;
          // Buka konten lengkap ke dalam Active State S_{k,t+1}
          this.activeStateNodes.set(targetId, histNode);

          // Jika node mereferensikan observasi alat mentah, ikut sertakan buktinya
          if (histNode.toolObservationRef && this.rawToolEvidenceStore.has(histNode.toolObservationRef)) {
            disclosedEvidence.push({
              id: histNode.toolObservationRef,
              content: this.rawToolEvidenceStore.get(histNode.toolObservationRef)!,
            });
          }
        }
      }
    }

    this.currentStep++;
    const readyForAction = output.executionDecision?.actionType !== 'defer_to_expansion';

    return {
      activeState: Array.from(this.activeStateNodes.values()),
      disclosedEvidence,
      readyForAction,
    };
  }

  /**
   * ISU: Menerapkan delta lokal ke Active State (hanya node milik request berjalan yang boleh di-update/remove)
   */
  private applyIncrementalStateUpdate(delta: StateDelta): void {
    if (delta.add) {
      for (const node of delta.add) {
        // Validasi: ID unik dan semantik valid
        if (!this.activeStateNodes.has(node.id)) {
          this.activeStateNodes.set(node.id, {
            ...node,
            sourceRequestId: this.currentRequestId,
            createdAtStep: this.currentStep,
          });
        }
      }
    }

    if (delta.update) {
      for (const upd of delta.update) {
        if (upd.id && this.activeStateNodes.has(upd.id)) {
          const existing = this.activeStateNodes.get(upd.id)!;
          // Validasi P: Hanya node request aktif yang boleh di-update
          if (existing.sourceRequestId === this.currentRequestId) {
            this.activeStateNodes.set(upd.id, { ...existing, ...upd });
          }
        }
      }
    }

    if (delta.remove) {
      for (const id of delta.remove) {
        const existing = this.activeStateNodes.get(id);
        if (existing && existing.sourceRequestId === this.currentRequestId) {
          this.activeStateNodes.delete(id);
        }
      }
    }
  }

  /**
   * Menutup request q_k dan mengonsolidasikan node aktif ke Persistent State Repository M_{k+1}
   */
  public finalizeRequest(): void {
    for (const [id, node] of this.activeStateNodes.entries()) {
      // Simpan node yang relevan ke persistent repository jangka panjang
      this.persistentRepository.set(id, node);
    }
  }

  public getTelemetry(): { persistentNodeCount: number; activeNodeCount: number } {
    return {
      persistentNodeCount: this.persistentRepository.size,
      activeNodeCount: this.activeStateNodes.size,
    };
  }
}