"use client"

import React, { createContext, useContext, useState, useEffect, ReactNode } from 'react'
import { authFetch } from '@/lib/fetchAuth'

interface User {
  id: number
  username: string
  email: string
  registerdate: string
  lastlogin: string
  ip: string
  certified?: boolean
  gameData?: any
}

interface AuthContextType {
  user: User | null
  login: (username: string, password: string) => Promise<boolean>
  setUserFromRegistration: (user: User) => void
  setUserCertified: (certified: boolean) => void
  showCertReminder: boolean
  clearCertReminder: () => void
  logout: () => void
  loading: boolean
  error: string | null
}

const AuthContext = createContext<AuthContextType | undefined>(undefined)

export function AuthProvider({ children }: { children: ReactNode }) {
  const [user, setUser] = useState<User | null>(null)
  const [loading, setLoading] = useState(true)
  const [error, setError] = useState<string | null>(null)
  const [showCertReminder, setShowCertReminder] = useState(false)

  useEffect(() => {
    const loadSession = async () => {
      try {
        const response = await authFetch('/api/auth/me')
        if (response.ok) {
          const data = await response.json()
          if (data.authenticated && data.user) {
            setUser(data.user)
            if (data.user.certified === false) {
              setShowCertReminder(true)
            }
          }
        }
      } catch {
        // ignore network errors on boot
      } finally {
        setLoading(false)
      }
    }

    loadSession()
  }, [])

  const login = async (username: string, password: string): Promise<boolean> => {
    try {
      setLoading(true)
      setError(null)

      const response = await authFetch('/api/auth/login', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ username, password }),
      })

      const data = await response.json()

      if (response.ok && data.success) {
        setUser(data.user)
        if (data.user.certified === false) {
          setShowCertReminder(true)
        }
        return true
      }

      setError(data.error || 'Login failed')
      return false
    } catch {
      setError('Network error. Please try again.')
      return false
    } finally {
      setLoading(false)
    }
  }

  const setUserFromRegistration = (registeredUser: User) => {
    setUser(registeredUser)
    setError(null)
    if (registeredUser.certified === false) {
      setShowCertReminder(true)
    }
  }

  const setUserCertified = (certified: boolean) => {
    setUser((prev) => {
      if (!prev) return prev
      return { ...prev, certified }
    })
    if (certified) {
      setShowCertReminder(false)
    }
  }

  const clearCertReminder = () => setShowCertReminder(false)

  const logout = async () => {
    try {
      await authFetch('/api/auth/logout', { method: 'POST' })
    } catch {
      // ignore
    }
    setUser(null)
    setShowCertReminder(false)
  }

  const value: AuthContextType = {
    user,
    login,
    setUserFromRegistration,
    setUserCertified,
    showCertReminder,
    clearCertReminder,
    logout,
    loading,
    error,
  }

  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>
}

export function useAuth() {
  const context = useContext(AuthContext)
  if (context === undefined) {
    throw new Error('useAuth must be used within an AuthProvider')
  }
  return context
}