// Production Implementation: POrchestra Runtime Protocol & Hindsight Feedback Attribution Engine
// Mengimplementasikan On-the-Fly Harness Adaptation, Structured Communication Signals,
// dan Trajectory Attribution untuk On-Policy Orchestration Distillation (OPOD)
// Berdasarkan formulasi matematis formal arXiv:2610.13485 (Tsinghua / Microsoft Research)

export interface SubAgentHarness {
  subgoal: string;                   // g_i: Deskripsi tujuan terdelegasi
  context: string;                   // C_i: Konteks runtime yang dikurasi orchestrator
  allowedTools: string[];            // \Omega_i: Toolset yang diizinkan untuk sub-agen
  stepBudget: number;                // B_i: Batas langkah eksekusi lokal
}

export type ProactiveActionType = 'submit' | 'revise' | 'stop';

export interface ProactiveCommunicationMessage {
  action: ProactiveActionType;
  // Sinyal 1: Status Signal (kemajuan, ketidakpastian epistemik, dan penyebab hambatan)
  statusSignal: {
    currentProgressSummary: string;
    uncertaintyScore: number;       // [0.0 - 1.0]
    blockageReason?: 'TOOL_REVOKED' | 'TASK_AMBIGUITY' | 'EXTERNAL_EVENT' | 'BUDGET_EXHAUSTED';
  };
  // Sinyal 2: Request Signal (target penyesuaian: Task Scope atau Resource)
  requestSignal?: {
    taskScopeAdjustment?: {
      operation: 'SPLIT_SUBGOAL' | 'UPDATE_TARGET';
      revisedSubgoal: string;
    };
    resourceAdjustment?: {
      appendContext?: string;
      requestAdditionalTools?: string[];
      extendBudgetSteps?: number;
    };
  };
  // Sinyal 3: Evidence Signal (output mentah tool yang menjadi bukti eskalasi)
  evidenceSignal: {
    lastToolInvoked: string;
    toolOutputSample: string;
    observedErrorCode?: string;
  };
}

export interface LocalExecutionState {
  agentId: string;
  stepCount: number;
  harness: SubAgentHarness;
  localTrajectoryHistory: Array<{
    step: number;
    action: string;
    observation: string;
  }>;
  isPaused: boolean;
  status: 'RUNNING' | 'PAUSED_REVISING' | 'COMPLETED' | 'TERMINATED';
}

export interface OrchestrationDecisionRecord {
  decisionId: string;
  timestamp: number;
  orchestratorAction: 'DELEGATE' | 'REVISE' | 'STOP' | 'FINISH';
  targetAgentId?: string;
  assignedHarness?: SubAgentHarness;
  resultingSubAgentFeedback?: ProactiveCommunicationMessage;
}

/**
 * POrchestra Coordination Coordinator
 * Mengelola interleave eksekusi sub-agen dan adaptasi harness secara dinamis.
 */
export class POrchestraRuntimeCoordinator {
  private activeSubAgents: Map = new Map();
  private decisionHistory: OrchestrationDecisionRecord[] = [];
  private globalObservationSpace: string[] = [];

  constructor(private orchestratorModelName: string = 'Qwen3.5-9B-OPOD') {}

  /**
   * Menginisialisasi sub-agen baru dengan isolasi riwayat lokal h_i
   */
  public spawnSubAgent(agentId: string, initialHarness: SubAgentHarness): LocalExecutionState {
    const state: LocalExecutionState = {
      agentId,
      stepCount: 0,
      harness: initialHarness,
      localTrajectoryHistory: [],
      isPaused: false,
      status: 'RUNNING',
    };
    this.activeSubAgents.set(agentId, state);

    this.decisionHistory.push({
      decisionId: `dec-${Date.now()}-${Math.random().toString(36).substring(7)}`,
      timestamp: Date.now(),
      orchestratorAction: 'DELEGATE',
      targetAgentId: agentId,
      assignedHarness: { ...initialHarness },
    });

    return state;
  }

  /**
   * Protokol Komunikasi Proaktif: Sub-agen menginterupsi eksekusi lokal
   * dan meminta adaptasi harness secara on-the-fly tanpa mereset memori.
   */
  public handleProactiveInterrupt(
    agentId: string,
    message: ProactiveCommunicationMessage
  ): { resumed: boolean; updatedHarness?: SubAgentHarness; finalResult?: string } {
    const agent = this.activeSubAgents.get(agentId);
    if (!agent) {
      throw new Error(`Sub-agent ${agentId} tidak ditemukan pada runtime.`);
    }

    if (message.action === 'submit') {
      agent.status = 'COMPLETED';
      return {
        resumed: false,
        finalResult: message.statusSignal.currentProgressSummary,
      };
    }

    if (message.action === 'stop') {
      agent.status = 'TERMINATED';
      return { resumed: false };
    }

    if (message.action === 'revise') {
      agent.isPaused = true;
      agent.status = 'PAUSED_REVISING';

      // Evaluasi permintaan revisi oleh Orchestrator (Policy \pi_\theta)
      const req = message.requestSignal;
      const newHarness: SubAgentHarness = { ...agent.harness };

      if (req?.taskScopeAdjustment) {
        newHarness.subgoal = req.taskScopeAdjustment.revisedSubgoal;
      }

      if (req?.resourceAdjustment) {
        if (req.resourceAdjustment.appendContext) {
          newHarness.context += `\n[REVISION_CONTEXT]: ${req.resourceAdjustment.appendContext}`;
        }
        if (req.resourceAdjustment.requestAdditionalTools) {
          newHarness.allowedTools = Array.from(
            new Set([...newHarness.allowedTools, ...req.resourceAdjustment.requestAdditionalTools])
          );
        }
        if (req.resourceAdjustment.extendBudgetSteps) {
          newHarness.stepBudget += req.resourceAdjustment.extendBudgetSteps;
        }
      }

      // Terapkan pembaruan harness tanpa menghapus localTrajectoryHistory (h_i dipertahankan!)
      agent.harness = newHarness;
      agent.isPaused = false;
      agent.status = 'RUNNING';

      // Catat revisi sebagai observasi komunikasi o_comm ke riwayat lokal
      agent.localTrajectoryHistory.push({
        step: agent.stepCount,
        action: 'PROACTIVE_REVISE_SYNC',
        observation: `Harness diperbarui oleh Orchestrator: Tools=[${newHarness.allowedTools.join(', ')}], Subgoal="${newHarness.subgoal}"`,
      });

      this.decisionHistory.push({
        decisionId: `dec-${Date.now()}-${Math.random().toString(36).substring(7)}`,
        timestamp: Date.now(),
        orchestratorAction: 'REVISE',
        targetAgentId: agentId,
        assignedHarness: { ...newHarness },
        resultingSubAgentFeedback: message,
      });

      return { resumed: true, updatedHarness: newHarness };
    }

    return { resumed: false };
  }

  /**
   * Modul OPOD Hindsight Feedback Attribution
   * Mengatribusikan permintaan revisi sub-agen ke keputusan orkestrasi awal
   * guna memproduksi Process Supervision (D_P) untuk On-Policy Self-Distillation.
   */
  public generateHindsightAttributionDataset(): Array<{
    precedingDecisionId: string;
    subAgentRevisionReason: string;
    correctiveTargetHarness: SubAgentHarness;
    processSupervisionLossWeight: number;
  }> {
    const attributionPairs = [];

    for (const record of this.decisionHistory) {
      if (record.orchestratorAction === 'REVISE' && record.resultingSubAgentFeedback) {
        const feedback = record.resultingSubAgentFeedback;
        // Cari keputusan DELEGATE yang mengawali sub-agen ini
        const rootDelegate = this.decisionHistory.find(
          d => d.targetAgentId === record.targetAgentId && d.orchestratorAction === 'DELEGATE'
        );

        if (rootDelegate && record.assignedHarness) {
          attributionPairs.push({
            precedingDecisionId: rootDelegate.decisionId,
            subAgentRevisionReason: `${feedback.statusSignal.blockageReason}: ${feedback.statusSignal.currentProgressSummary}`,
            correctiveTargetHarness: record.assignedHarness,
            processSupervisionLossWeight: 1.0 + feedback.statusSignal.uncertaintyScore,
          });
        }
      }
    }

    return attributionPairs;
  }
}