import { useEffect, useMemo, useState } from 'react'
import { formatError } from '../lib/formatError'
import { assistantApi } from '../services/api/assistant'
import type {
  AssistantChatMessage,
  AssistantModelRead,
  AssistantQueryResponse,
  AssistantStatus,
  VectorSelectionBBox,
} from '../types'

export interface GeoAssistantMessage extends AssistantChatMessage {
  id: string
  response?: AssistantQueryResponse
}

interface UseGeoAssistantOptions {
  selectedProjectId: string | null
  selectedAreaId: string | null
  selectionBbox: VectorSelectionBBox | null
}

const ASSISTANT_MODEL_PREFERENCE_KEY = 'geointel.assistant.model-preference.v1'
let assistantMessageSequence = 0

function nextAssistantMessageId(role: AssistantChatMessage['role']): string {
  assistantMessageSequence += 1
  return `${role}-${Date.now()}-${assistantMessageSequence}`
}

function readStoredPreference(): string {
  try {
    return window.localStorage.getItem(ASSISTANT_MODEL_PREFERENCE_KEY) || 'automatic'
  } catch {
    return 'automatic'
  }
}

export function useGeoAssistant({ selectedProjectId, selectedAreaId, selectionBbox }: UseGeoAssistantOptions) {
  const [status, setStatus] = useState<AssistantStatus | null>(null)
  const [models, setModels] = useState<AssistantModelRead[]>([])
  const [selectedModelChoice, setSelectedModelChoice] = useState(readStoredPreference)
  const [defaultModel, setDefaultModel] = useState('')
  const [messages, setMessages] = useState<GeoAssistantMessage[]>([])
  const [loading, setLoading] = useState(false)
  const [loadingModels, setLoadingModels] = useState(false)
  const [error, setError] = useState<string | null>(null)

  const selectedModel = useMemo(() => {
    const available = new Set(models.map((model) => model.name))
    if (selectedModelChoice !== 'automatic' && available.has(selectedModelChoice)) return selectedModelChoice
    if (defaultModel && available.has(defaultModel)) return defaultModel
    return models[0]?.name ?? ''
  }, [defaultModel, models, selectedModelChoice])

  const setSelectedModel = (value: string) => {
    const valid = value === 'automatic' || models.some((model) => model.name === value)
    const next = valid ? value : 'automatic'
    setSelectedModelChoice(next)
    try { window.localStorage.setItem(ASSISTANT_MODEL_PREFERENCE_KEY, next) } catch { /* voorkeur blijft sessielokaal */ }
  }

  const loadModels = async () => {
    setLoadingModels(true)
    setError(null)
    try {
      const currentStatus = await assistantApi.status()
      setStatus(currentStatus)
      if (!currentStatus.enabled || !currentStatus.reachable) {
        setModels([])
        setDefaultModel('')
        return
      }
      const result = await assistantApi.models()
      setModels(result.items)
      const fallback = result.default_model && result.items.some((model) => model.name === result.default_model)
        ? result.default_model
        : result.items[0]?.name ?? ''
      setDefaultModel(fallback)
      setSelectedModelChoice((current) => current === 'automatic' || result.items.some((model) => model.name === current) ? current : 'automatic')
    } catch (requestError) {
      setStatus(null)
      setModels([])
      setDefaultModel('')
      setError(formatError(requestError, 'De lokale AI-assistent kon niet worden bereikt.'))
    } finally {
      setLoadingModels(false)
    }
  }

  useEffect(() => { void loadModels() }, [])
  useEffect(() => { setMessages([]); setError(null) }, [selectedProjectId])

  const ask = async (question: string): Promise<boolean> => {
    const trimmed = question.trim()
    if (!selectedProjectId || !trimmed || !selectedModel) return false
    const userMessage: GeoAssistantMessage = { id: nextAssistantMessageId('user'), role: 'user', content: trimmed }
    setMessages((current) => [...current, userMessage])
    setLoading(true)
    setError(null)
    try {
      const history = messages.slice(-6).map(({ role, content }) => ({ role, content }))
      const result = await assistantApi.query(selectedProjectId, {
        question: trimmed,
        model: selectedModel,
        bbox: selectionBbox,
        area_id: selectedAreaId,
        history,
      })
      setMessages((current) => [...current, { id: nextAssistantMessageId('assistant'), role: 'assistant', content: result.answer, response: result }])
      return true
    } catch (requestError) {
      setError(formatError(requestError, 'GeoIntel kon de vraag niet beantwoorden.'))
      return false
    } finally {
      setLoading(false)
    }
  }

  const clear = () => { setMessages([]); setError(null) }

  return { status, models, selectedModel, selectedModelChoice, defaultModel, messages, loading, loadingModels, error, loadModels, ask, clear, setSelectedModel }
}