// ✅ Deterministic FSM Agent Runtime
// file: src/agents/FsmAgentRuntime.ts

import { generateObject } from 'ai'
import { createAnthropic } from '@ai-sdk/anthropic'
import { z } from 'zod'
import type { AgentTool, AgentToolResult } from './types'

const anthropic = createAnthropic()

type AgentState = 'PLANNING' | 'TOOL_CALLING' | 'AWAITING_RESULT' | 'AWAITING_HUMAN' | 'RESPONDING' | 'FAILED'

const PlanSchema = z.object({
  reasoning: z.string(),
  nextAction: z.enum(['call_tool', 'respond_directly', 'request_human_approval']),
  toolName: z.string().optional(),
  toolArgs: z.record(z.unknown()).optional(),
  responseText: z.string().optional(),
})

export interface AgentConfig {
  maxSteps: number        // Hard budget — prevents runaway loops
  maxTokensPerStep: number
  tools: AgentTool[]
  systemPrompt: string
  requireHumanApproval: (toolName: string, args: unknown) => boolean
}

export class FsmAgentRuntime {
  private state: AgentState = 'PLANNING'
  private steps = 0
  private messages: { role: string; content: string }[] = []

  constructor(private readonly config: AgentConfig) {}

  async run(userTask: string): Promise<string> {
    this.messages.push({ role: 'user', content: userTask })
    this.state = 'PLANNING'

    while (this.state !== 'RESPONDING' && this.state !== 'FAILED') {
      if (this.steps >= this.config.maxSteps) {
        this.state = 'FAILED'
        return `Agent exceeded maximum step budget (${this.config.maxSteps} steps) without completing the task.`
      }

      this.steps++
      await this.transition()
    }

    return this.state === 'FAILED'
      ? 'The agent was unable to complete the task.'
      : (this.messages.at(-1)?.content ?? '')
  }

  private async transition(): Promise<void> {
    switch (this.state) {
      case 'PLANNING': return this.plan()
      case 'TOOL_CALLING': return this.callTool()
      case 'AWAITING_RESULT': return this.processResult()
      case 'AWAITING_HUMAN': return this.awaitHuman()
    }
  }

  private async plan(): Promise<void> {
    const { object: plan } = await generateObject({
      model: anthropic('claude-3-5-sonnet-20241022'),
      schema: PlanSchema,
      maxTokens: this.config.maxTokensPerStep,
      system: this.config.systemPrompt + '\n\nAvailable tools: ' +
        this.config.tools.map(t => `${t.name}: ${t.description}`).join(', '),
      messages: this.messages as any,
    })

    this.messages.push({ role: 'assistant', content: JSON.stringify(plan) })

    if (plan.nextAction === 'respond_directly') {
      this.messages.push({ role: 'assistant', content: plan.responseText ?? '' })
      this.state = 'RESPONDING'
    } else if (plan.nextAction === 'request_human_approval') {
      this.state = 'AWAITING_HUMAN'
    } else {
      this.state = 'TOOL_CALLING'
    }
  }

  private async callTool(): Promise<void> {
    const lastPlan = JSON.parse(this.messages.at(-1)?.content ?? '{}')
    const { toolName, toolArgs } = lastPlan

    if (!toolName) { this.state = 'FAILED'; return }

    // Check if this tool requires human approval
    if (this.config.requireHumanApproval(toolName, toolArgs)) {
      this.state = 'AWAITING_HUMAN'
      return
    }

    const tool = this.config.tools.find(t => t.name === toolName)
    if (!tool) {
      this.messages.push({ role: 'user', content: `Tool "${toolName}" not found.` })
      this.state = 'PLANNING'  // Re-plan with error context
      return
    }

    this.state = 'AWAITING_RESULT'
    // Execution happens in processResult (simulated here as immediate)
    const result = await tool.execute(toolArgs ?? {})
    this.messages.push({
      role: 'user',
      content: `Tool result for ${toolName}:\n${JSON.stringify(result)}`,
    })

    // Re-plan after result
    this.state = 'PLANNING'
  }

  private async processResult(): Promise<void> {
    // State handled inline in callTool — this handles async tool patterns
    this.state = 'PLANNING'
  }

  private async awaitHuman(): Promise<void> {
    // In production: pause here and emit approval request event (Part 17)
    // The runtime suspends; resumed by durable execution framework
    this.state = 'FAILED'  // Simplified — full implementation in Part 17
  }
}

// ✅ Structured tool error wrapper
export async function executeToolSafely(
  tool: AgentTool,
  args: unknown,
): Promise<AgentToolResult> {
  try {
    const result = await tool.execute(args as Record<string, unknown>)
    return { success: true, result }
  } catch (error) {
    // Convert error to structured model-readable context
    return {
      success: false,
      error: {
        type: error instanceof Error ? error.constructor.name : 'UnknownError',
        message: error instanceof Error ? error.message : String(error),
        recoverable: !(error instanceof FatalToolError),
        suggestion: error instanceof ValidationError
          ? `Check the tool arguments: ${error.details}`
          : 'Try a different approach or request human assistance.',
      },
    }
  }
}