import { SerializedWorkflow, SerializedBlock } from '@/serializer/types' 
import { ExecutionContext, ExecutionResult, Tool } from './types' 
import { tools } from '@/tools' 
import { BlockState } from '@/stores/workflow/types' 

export class Executor {
  private workflow: SerializedWorkflow 
  
  constructor(workflow: SerializedWorkflow) {
    this.workflow = workflow 
  }

  private async executeBlock(
    block: SerializedBlock,
    inputs: Record<string, any>,
    context: ExecutionContext
  ): Promise<Record<string, any>> {
    const config = block.config 
    const toolId = config.tool 

    if (!toolId) {
      throw new Error(`Block ${block.id} does not specify a tool`) 
    }

    const tool = tools[toolId] 
    if (!tool) {
      throw new Error(`Tool not found: ${toolId}`) 
    }

    // Validate interface compatibility
    this.validateInterface(block, inputs) 

    // Merge block parameters with runtime inputs
    const params = {
      ...config.params,
      ...inputs
    } 

    // Validate tool parameters
    this.validateToolParams(tool, params) 

    try {
      // Make the HTTP request
      const url = typeof tool.request.url === 'function' 
        ? tool.request.url(params)
        : tool.request.url 

      const response = await fetch(url, {
        method: tool.request.method,
        headers: tool.request.headers(params),
        body: tool.request.body ? JSON.stringify(tool.request.body(params)) : undefined
      }) 

      if (!response.ok) {
        const error = await response.json().catch(() => ({ message: response.statusText })) 
        throw new Error(tool.transformError(error)) 
      }

      const result = await tool.transformResponse(response) 

      // Validate the output matches the interface
      this.validateToolOutput(block, result) 
      return result 
    } catch (error) {
      throw new Error(`Tool ${toolId} execution failed: ${error instanceof Error ? error.message : 'Unknown error'}`) 
    }
  }

  private validateToolParams(tool: Tool, params: Record<string, any>): void {
    // Check required parameters
    for (const [paramName, paramConfig] of Object.entries(tool.params)) {
      if (paramConfig.required && !(paramName in params)) {
        throw new Error(`Missing required parameter '${paramName}' for tool ${tool.id}`) 
      }
    }
  }

  private validateInterface(block: SerializedBlock, inputs: Record<string, any>): void {
    const { interface: blockInterface } = block.config 
    
    // Check if all required inputs are provided
    for (const [inputName, inputType] of Object.entries(blockInterface.inputs)) {
      if (!(inputName in inputs)) {
        throw new Error(`Missing required input '${inputName}' of type '${inputType}' for block ${block.id}`) 
      }
      // Basic type validation (can be enhanced for more complex types)
      if (!this.validateType(inputs[inputName], inputType)) {
        throw new Error(`Invalid type for input '${inputName}' in block ${block.id}. Expected ${inputType}`) 
      }
    }
  }

  private validateToolOutput(block: SerializedBlock, output: Record<string, any>): void {
    const { interface: blockInterface } = block.config 
    
    // Check if all promised outputs are present
    for (const [outputName, outputType] of Object.entries(blockInterface.outputs)) {
      if (!(outputName in output)) {
        throw new Error(`Tool output missing required field '${outputName}' of type '${outputType}' for block ${block.id}`) 
      }
      // Basic type validation (can be enhanced for more complex types)
      if (!this.validateType(output[outputName], outputType)) {
        throw new Error(`Invalid type for output '${outputName}' in block ${block.id}. Expected ${outputType}`) 
      }
    }
  }

  private validateType(value: any, expectedType: string): boolean {
    switch (expectedType.toLowerCase()) {
      case 'string':
        return typeof value === 'string' 
      case 'number':
        return typeof value === 'number' 
      case 'boolean':
        return typeof value === 'boolean' 
      case 'json':
        try {
          if (typeof value === 'string') {
            JSON.parse(value) 
          }
          return true 
        } catch {
          return false 
        }
      default:
        // For complex types, we just do basic object/array validation
        return true 
    }
  }

  private determineExecutionOrder(): string[] {
    const { blocks, connections } = this.workflow 
    const order: string[] = [] 
    const visited = new Set<string>() 
    const inDegree = new Map<string, number>() 
    
    blocks.forEach(block => inDegree.set(block.id, 0)) 
    connections.forEach(conn => {
      const target = conn.target 
      inDegree.set(target, (inDegree.get(target) || 0) + 1) 
    }) 
    
    const queue = blocks
      .filter(block => (inDegree.get(block.id) || 0) === 0)
      .map(block => block.id) 
    
    while (queue.length > 0) {
      const blockId = queue.shift()! 
      if (visited.has(blockId)) continue 
      
      visited.add(blockId) 
      order.push(blockId) 
      
      connections
        .filter(conn => conn.source === blockId)
        .forEach(conn => {
          const targetId = conn.target 
          inDegree.set(targetId, (inDegree.get(targetId) || 0) - 1) 
          
          if (inDegree.get(targetId) === 0) {
            queue.push(targetId) 
          }
        }) 
    }
    
    if (order.length !== blocks.length) {
      throw new Error('Workflow contains cycles') 
    }
    
    return order 
  }

  private resolveInputs(
    block: SerializedBlock, 
    context: ExecutionContext
  ): Record<string, any> {
    const inputs: Record<string, any> = {} 
    
    // Get all incoming connections for this block
    const incomingConnections = this.workflow.connections.filter(
      conn => conn.target === block.id
    ) 
    
    // Map outputs from previous blocks to inputs for this block
    incomingConnections.forEach(conn => {
      const sourceOutput = context.blockStates.get(conn.source) 
      if (sourceOutput && conn.sourceHandle && conn.targetHandle) {
        inputs[conn.targetHandle] = sourceOutput[conn.sourceHandle] 
      }
    }) 
    
    // If this is a start block with no inputs, use the block's params
    if (Object.keys(inputs).length === 0) {
      const targetBlock = this.workflow.blocks.find(b => b.id === block.id) 
      if (targetBlock) {
        return targetBlock.config.params 
      }
    }
    
    return inputs 
  }

  async execute(workflowId: string): Promise<ExecutionResult> {
    const startTime = new Date() 
    const context: ExecutionContext = {
      workflowId,
      blockStates: new Map(),
      metadata: {
        startTime: startTime.toISOString()
      }
    } 

    try {
      const executionOrder = this.determineExecutionOrder() 
      
      for (const blockId of executionOrder) {
        const block = this.workflow.blocks.find(b => b.id === blockId) 
        if (!block) {
          throw new Error(`Block ${blockId} not found in workflow`) 
        }
        
        const blockInputs = this.resolveInputs(block, context) 
        const result = await this.executeBlock(block, blockInputs, context) 
        context.blockStates.set(blockId, result) 
      }

      const lastBlockId = executionOrder[executionOrder.length - 1] 
      const finalOutput = context.blockStates.get(lastBlockId) 

      const endTime = new Date() 
      return {
        success: true,
        data: finalOutput,
        metadata: {
          duration: endTime.getTime() - startTime.getTime(),
          startTime: startTime.toISOString(),
          endTime: endTime.toISOString()
        }
      } 
    } catch (error) {
      const endTime = new Date() 
      return {
        success: false,
        data: {},
        error: error instanceof Error ? error.message : 'Unknown error occurred',
        metadata: {
          duration: endTime.getTime() - startTime.getTime(),
          startTime: startTime.toISOString(),
          endTime: endTime.toISOString()
        }
      } 
    }
  }
}