'use client'

import React, { useState } from 'react'
import { useAgentAnalysis } from './_hooks/useAgentAnalysis'
import { AnalysisResult } from './_components/AnalysisResult'
import { AnalysisHistory } from './_components/AnalysisHistory'
import { FollowUpQuestions } from './_components/FollowUpQuestions'
import { ScanResult } from './_components/ScanResult'
import { DocCheckTab } from './_components/DocCheckTab'

type AnalysisMode = 'pre_launch' | 'post_launch'
type AnalysisTab = 'quick' | 'scan' | 'doc-check'

const MODES: { id: AnalysisMode; label: string; desc: string; icon: string }[] = [
  { id: 'pre_launch', label: 'Internes Dokument', desc: 'Vor Veroeffentlichung pruefen', icon: '📋' },
  { id: 'post_launch', label: 'Live-Website', desc: 'Bereits online analysieren', icon: '🌐' },
]

const TABS: { id: AnalysisTab; label: string; desc: string }[] = [
  { id: 'quick', label: 'Schnellanalyse', desc: 'Einzelne Seite klassifizieren + bewerten' },
  { id: 'scan', label: 'Website-Scan', desc: 'Mehrere Seiten scannen + Dienstleister abgleichen' },
  { id: 'doc-check', label: 'Dokumenten-Pruefung', desc: 'Einzelne Dokumente gezielt pruefen' },
]

export default function AgentPage() {
  // Restore state from localStorage on mount
  const [url, setUrl] = useState(() => typeof window !== 'undefined' ? localStorage.getItem('agent-scan-url') || '' : '')
  const [mode, setMode] = useState<AnalysisMode>(() => (typeof window !== 'undefined' ? localStorage.getItem('agent-scan-mode') as AnalysisMode : null) || 'post_launch')
  const [tab, setTab] = useState<AnalysisTab>(() => (typeof window !== 'undefined' ? localStorage.getItem('agent-scan-tab') as AnalysisTab : null) || 'quick')
  const [scanLoading, setScanLoading] = useState(false)
  const [scanError, setScanError] = useState<string | null>(null)
  const [scanData, setScanData] = useState<any>(() => {
    if (typeof window === 'undefined') return null
    try { const s = localStorage.getItem('agent-scan-result'); return s ? JSON.parse(s) : null } catch { return null }
  })
  const [scanProgress, setScanProgress] = useState<string>('')
  const [activeScanId, setActiveScanId] = useState<string>(() => typeof window !== 'undefined' ? localStorage.getItem('agent-scan-id') || '' : '')
  const [scanHistory, setScanHistory] = useState<{ url: string; date: string; findings: number; docs: number }[]>(() => {
    if (typeof window === 'undefined') return []
    try { return JSON.parse(localStorage.getItem('agent-scan-history') || '[]') } catch { return [] }
  })
  const { analyze, answerFollowUp, loading, error, result, history } = useAgentAnalysis()

  // Persist state to localStorage
  React.useEffect(() => { localStorage.setItem('agent-scan-url', url) }, [url])
  React.useEffect(() => { localStorage.setItem('agent-scan-mode', mode) }, [mode])
  React.useEffect(() => { localStorage.setItem('agent-scan-tab', tab) }, [tab])
  React.useEffect(() => { if (scanData?.services) localStorage.setItem('agent-scan-result', JSON.stringify(scanData)) }, [scanData])

  // Resume polling if scan was in progress when page was left
  React.useEffect(() => {
    if (!activeScanId || scanData?.services) return
    let cancelled = false
    setScanLoading(true)
    setScanProgress('Scan laeuft noch...')
    const poll = async () => {
      while (!cancelled) {
        await new Promise(r => setTimeout(r, 5000))
        try {
          const res = await fetch(`/api/sdk/v1/agent/scan?scan_id=${activeScanId}`)
          if (!res.ok) continue
          const data = await res.json()
          if (data.progress) setScanProgress(data.progress)
          if (data.status === 'completed' && data.result) {
            setScanData(data.result)
            setScanProgress('')
            setScanLoading(false)
            localStorage.setItem('agent-scan-result', JSON.stringify(data.result))
            localStorage.removeItem('agent-scan-id')
            setActiveScanId('')
            _addToHistory(data.result)
            return
          }
          if (data.status === 'failed') {
            setScanError(data.error || 'Scan fehlgeschlagen')
            setScanProgress('')
            setScanLoading(false)
            localStorage.removeItem('agent-scan-id')
            setActiveScanId('')
            return
          }
          if (data.status === 'not_found') {
            setScanProgress('')
            setScanLoading(false)
            localStorage.removeItem('agent-scan-id')
            setActiveScanId('')
            return
          }
        } catch { /* retry */ }
      }
    }
    poll()
    return () => { cancelled = true }
  }, []) // eslint-disable-line react-hooks/exhaustive-deps

  const _addToHistory = (result: any) => {
    const entry = {
      url: url || result.url || '',
      date: new Date().toISOString(),
      findings: result.findings?.length || 0,
      docs: result.discovered_documents?.length || 0,
    }
    const updated = [entry, ...scanHistory].slice(0, 50)
    setScanHistory(updated)
    localStorage.setItem('agent-scan-history', JSON.stringify(updated))
  }

  const _loadFromHistory = (entry: { url: string }) => {
    setUrl(entry.url)
    setTab('scan')
    // Load saved result if same URL
    try {
      const saved = localStorage.getItem('agent-scan-result')
      if (saved) {
        const parsed = JSON.parse(saved)
        if (parsed.url === entry.url) {
          setScanData(parsed)
        }
      }
    } catch {}
  }

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault()
    if (!url.trim()) return

    if (tab === 'quick') {
      analyze(url.trim(), mode)
    } else {
      setScanLoading(true)
      setScanError(null)
      setScanData(null)
      setScanProgress('Scan wird gestartet...')
      try {
        // Step 1: Start async scan
        const startRes = await fetch('/api/sdk/v1/agent/scan', {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({ url: url.trim(), mode }),
        })
        if (!startRes.ok) throw new Error(`Scan konnte nicht gestartet werden: ${startRes.status}`)
        const { scan_id } = await startRes.json()
        if (!scan_id) throw new Error('Keine Scan-ID erhalten')
        setActiveScanId(scan_id)
        localStorage.setItem('agent-scan-id', scan_id)

        // Step 2: Poll for results
        let attempts = 0
        const maxAttempts = 120 // 10 min at 5s intervals
        while (attempts < maxAttempts) {
          await new Promise(r => setTimeout(r, 5000))
          const pollRes = await fetch(`/api/sdk/v1/agent/scan?scan_id=${scan_id}`)
          if (!pollRes.ok) { attempts++; continue }
          const pollData = await pollRes.json()

          if (pollData.progress) {
            setScanProgress(pollData.progress)
          }

          if (pollData.status === 'completed' && pollData.result) {
            setScanData(pollData.result)
            setScanProgress('')
            localStorage.setItem('agent-scan-result', JSON.stringify(pollData.result))
            localStorage.removeItem('agent-scan-id')
            setActiveScanId('')
            _addToHistory(pollData.result)
            break
          }
          if (pollData.status === 'failed') {
            throw new Error(pollData.error || 'Scan fehlgeschlagen')
          }
          attempts++
        }
        if (attempts >= maxAttempts) throw new Error('Scan-Timeout (10 Minuten)')
      } catch (e) {
        setScanError(e instanceof Error ? e.message : 'Unbekannter Fehler')
        setScanProgress('')
      } finally {
        setScanLoading(false)
      }
    }
  }

  const isLoading = tab === 'quick' ? loading : scanLoading
  const currentError = tab === 'quick' ? error : scanError

  return (
    <div className="space-y-6 max-w-4xl">
      <div>
        <h1 className="text-2xl font-bold text-gray-900">Compliance Agent</h1>
        <p className="text-gray-500 mt-1">Analysiere Dokumente und Webseiten auf DSGVO-Konformitaet.</p>
      </div>

      {/* Mode Selection */}
      <div className="grid grid-cols-2 gap-3">
        {MODES.map(m => (
          <button key={m.id} onClick={() => setMode(m.id)}
            className={`p-3 rounded-xl border-2 text-left transition-all ${
              mode === m.id ? 'border-purple-500 bg-purple-50' : 'border-gray-200 hover:border-gray-300'}`}>
            <div className="flex items-center gap-3">
              <span className="text-xl">{m.icon}</span>
              <div>
                <p className={`text-sm font-semibold ${mode === m.id ? 'text-purple-900' : 'text-gray-900'}`}>{m.label}</p>
                <p className="text-xs text-gray-500">{m.desc}</p>
              </div>
            </div>
          </button>
        ))}
      </div>

      {/* Tab Selection */}
      <div className="flex border-b border-gray-200">
        {TABS.map(t => (
          <button key={t.id} onClick={() => setTab(t.id)}
            className={`px-4 py-2.5 text-sm font-medium border-b-2 transition-colors ${
              tab === t.id
                ? 'border-purple-500 text-purple-700'
                : 'border-transparent text-gray-500 hover:text-gray-700'}`}>
            {t.label}
          </button>
        ))}
      </div>

      {/* Doc Check Tab — own component */}
      {tab === 'doc-check' && <DocCheckTab />}

      {/* URL Input (quick + scan only) */}
      {tab !== 'doc-check' && <form onSubmit={handleSubmit} className="flex gap-3">
        <input type="url" value={url} onChange={e => setUrl(e.target.value)}
          placeholder={tab === 'scan' ? 'https://www.example.com/' : 'https://example.com/datenschutz'}
          className="flex-1 px-4 py-3 border border-gray-300 rounded-lg focus:ring-2 focus:ring-purple-500 focus:border-transparent text-sm"
          disabled={isLoading} required />
        <button type="submit" disabled={isLoading || !url.trim()}
          className="px-6 py-3 bg-purple-600 text-white rounded-lg hover:bg-purple-700 disabled:opacity-50 transition-colors flex items-center gap-2 text-sm font-medium">
          {isLoading ? (
            <><svg className="animate-spin w-4 h-4" fill="none" viewBox="0 0 24 24">
              <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
              <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z" />
            </svg>{tab === 'scan' ? 'Scanne...' : 'Analysiere...'}</>
          ) : tab === 'scan' ? 'Website scannen' : 'Analysieren'}
        </button>
      </form>}

      {/* Scan Progress */}
      {scanProgress && tab === 'scan' && (
        <div className="bg-purple-50 border border-purple-200 rounded-lg p-4 text-sm text-purple-700 flex items-center gap-3">
          <svg className="animate-spin w-5 h-5 text-purple-500 shrink-0" fill="none" viewBox="0 0 24 24">
            <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
            <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z" />
          </svg>
          {scanProgress}
        </div>
      )}

      {/* Error */}
      {currentError && (
        <div className="bg-red-50 border border-red-200 rounded-lg p-4 text-sm text-red-700">{currentError}</div>
      )}

      {/* Quick Analysis Result */}
      {tab === 'quick' && result && (
        <div className="bg-white border border-gray-200 rounded-xl p-6 shadow-sm space-y-6">
          <AnalysisResult result={result} />
          {result.follow_up_questions.length > 0 && (
            <div className="border-t pt-4">
              <FollowUpQuestions questions={result.follow_up_questions} answers={result.follow_up_answers} onAnswer={answerFollowUp} />
            </div>
          )}
        </div>
      )}

      {/* Scan Result — only render when we have a complete response with services */}
      {tab === 'scan' && scanData && scanData.services && (
        <div className="bg-white border border-gray-200 rounded-xl p-6 shadow-sm">
          <ScanResult data={scanData} />
        </div>
      )}

      {/* History (quick only) */}
      {tab === 'quick' && (
        <AnalysisHistory history={history} onSelect={r => { setUrl(r.url); analyze(r.url, mode) }} />
      )}

      {/* Scan History */}
      {tab === 'scan' && scanHistory.length > 0 && (
        <div className="border border-gray-200 rounded-xl p-4">
          <h4 className="text-sm font-medium text-gray-700 mb-3">Letzte Scans</h4>
          <div className="space-y-2">
            {scanHistory.map((h, i) => (
              <button key={i} onClick={() => _loadFromHistory(h)}
                className="w-full flex items-center justify-between p-3 rounded-lg border border-gray-100 hover:border-purple-200 hover:bg-purple-50/30 transition-all text-left">
                <div className="min-w-0 flex-1">
                  <div className="text-sm font-medium text-gray-900 truncate">{h.url}</div>
                  <div className="text-xs text-gray-500">
                    {new Date(h.date).toLocaleDateString('de-DE', { day: '2-digit', month: '2-digit', year: 'numeric', hour: '2-digit', minute: '2-digit' })}
                  </div>
                </div>
                <div className="flex items-center gap-3 shrink-0 ml-3">
                  {h.docs > 0 && <span className="text-xs text-purple-600">{h.docs} Dok.</span>}
                  <span className={`text-xs font-medium ${h.findings > 0 ? 'text-red-600' : 'text-green-600'}`}>
                    {h.findings} Findings
                  </span>
                </div>
              </button>
            ))}
          </div>
        </div>
      )}
    </div>
  )
}