'use client'

import { createContext, useContext, useState, useEffect, ReactNode } from 'react'
import { useRouter } from 'next/navigation'
import api from './api'
import Cookies from 'js-cookie'

interface User {
  id: number
  email: string
  name: string
  role: string
}

interface AuthContextType {
  user: User | null
  loading: boolean
  login: (email: string, password: string) => Promise<void>
  logout: () => void
}

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 router = useRouter()

  useEffect(() => {
    const loadUser = async () => {
      const token = Cookies.get('access_token')
      if (token) {
        // Restore user from localStorage first (optimistic)
        const savedUser = localStorage.getItem('inventory_user')
        if (savedUser) {
          try {
            setUser(JSON.parse(savedUser))
          } catch (_) { /* ignore */ }
        }
        
        // Try to verify token by getting profile
        // This will trigger refresh if needed via interceptor
        try {
          const response = await api.get('/auth/profile')
          if (response.data) {
            const userData = {
              id: response.data.id,
              email: response.data.email,
              name: response.data.name,
              role: response.data.role,
            }
            setUser(userData)
            localStorage.setItem('inventory_user', JSON.stringify(userData))
          }
        } catch (error: any) {
          // If profile fails, check if it's a 401 (token expired)
          // The interceptor will handle refresh automatically
          if (error.response?.status === 401) {
            // Wait a bit for interceptor to try refresh
            await new Promise((resolve) => setTimeout(resolve, 500))
            // Try once more
            try {
              const retryResponse = await api.get('/auth/profile')
              if (retryResponse.data) {
                const userData = {
                  id: retryResponse.data.id,
                  email: retryResponse.data.email,
                  name: retryResponse.data.name,
                  role: retryResponse.data.role,
                }
                setUser(userData)
                localStorage.setItem('inventory_user', JSON.stringify(userData))
              }
            } catch (retryError) {
              // If still fails, clear everything
              if (!Cookies.get('refresh_token')) {
                Cookies.remove('access_token')
                Cookies.remove('refresh_token')
                localStorage.removeItem('inventory_user')
                setUser(null)
              }
            }
          } else {
            // Other errors, clear if no refresh token
            if (!Cookies.get('refresh_token')) {
              Cookies.remove('access_token')
              Cookies.remove('refresh_token')
              localStorage.removeItem('inventory_user')
              setUser(null)
            }
          }
        }
      }
      setLoading(false)
    }
    loadUser()
  }, [])

  const login = async (email: string, password: string) => {
    try {
      const response = await api.post('/auth/login', { email, password })
      const { access_token, refresh_token, user: userData } = response.data

      Cookies.set('access_token', access_token, { expires: 1, sameSite: 'lax' })       // 1 day
      Cookies.set('refresh_token', refresh_token, { expires: 7, sameSite: 'lax' })   // 7 days
      localStorage.setItem('inventory_user', JSON.stringify(userData))
      setUser(userData)
      router.push('/dashboard')
    } catch (error: any) {
      throw new Error(error.response?.data?.message || 'Error al iniciar sesión')
    }
  }

  const logout = () => {
    Cookies.remove('access_token')
    Cookies.remove('refresh_token')
    localStorage.removeItem('inventory_user')
    setUser(null)
    router.push('/login')
  }

  return (
    <AuthContext.Provider value={{ user, loading, login, logout }}>
      {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
}