'use client'

import { useState, useEffect, useCallback } from 'react'
import type { Agent } from '@/lib/types'
import { readArrayResponse } from '@/lib/auth/client-redirect'

interface DbAgent {
  id: string
  name: string
  description: string
  model: string
  permissionMode: string
  isMain: number
  parentId: string | null
  enabled: number
  instructions: string
  soul: string
  identity: string
  toolsConfig: string
  userId: string
  skillIds: string[]
  createdAt: string
  updatedAt: string
}

function mapAgent(row: DbAgent): Agent {
  let toolsConfig: Record<string, boolean> = {}
  try { toolsConfig = JSON.parse(row.toolsConfig) } catch { /* empty */ }

  return {
    id: row.id,
    name: row.name,
    description: row.description,
    model: row.model,
    permissionMode: row.permissionMode as 'confirm' | 'full',
    isMain: row.isMain === 1,
    parentId: row.parentId,
    enabled: row.enabled === 1,
    instructions: row.instructions,
    soul: row.soul,
    identity: row.identity,
    toolsConfig,
    skillIds: row.skillIds || [],
    createdAt: row.createdAt,
    updatedAt: row.updatedAt,
  }
}

export function useAgents() {
  const [agents, setAgents] = useState<Agent[]>([])
  const [loading, setLoading] = useState(true)

  const fetchAgents = useCallback(async () => {
    try {
      const res = await fetch('/api/agents')
      const data = await readArrayResponse<DbAgent>(res)
      setAgents(data.map(mapAgent))
    } catch (err) {
      console.error('Failed to fetch agents:', err)
    } finally {
      setLoading(false)
    }
  }, [])

  useEffect(() => { fetchAgents() }, [fetchAgents])

  const createAgent = useCallback(async (opts?: { name?: string; is_main?: boolean }) => {
    const res = await fetch('/api/agents', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(opts || {}),
    })
    const data = mapAgent(await res.json())
    setAgents((prev) => [data, ...prev])
    return data
  }, [])

  const updateAgent = useCallback(async (id: string, updates: Record<string, unknown>) => {
    const res = await fetch(`/api/agents/${id}`, {
      method: 'PATCH',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(updates),
    })
    const data = mapAgent(await res.json())
    setAgents((prev) => prev.map((a) => (a.id === id ? data : a)))
    return data
  }, [])

  const deleteAgent = useCallback(async (id: string) => {
    await fetch(`/api/agents/${id}`, { method: 'DELETE' })
    setAgents((prev) => prev.filter((a) => a.id !== id))
  }, [])

  const updateAgentSkills = useCallback(async (agentId: string, skillIds: string[]) => {
    await fetch(`/api/agents/${agentId}/skills`, {
      method: 'PUT',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ skill_ids: skillIds }),
    })
    setAgents((prev) => prev.map((a) => (a.id === agentId ? { ...a, skillIds } : a)))
  }, [])

  return { agents, loading, createAgent, updateAgent, deleteAgent, updateAgentSkills, refreshAgents: fetchAgents }
}