"use client"

import { createContext, useContext, useState, useEffect, type ReactNode } from "react"

type UserRole = "admin" | "ingeniero"

interface User {
  id: string
  name: string
  email: string
  role: UserRole
  matricula?: string
}

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

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

import { apiFetch } from "@/lib/apiutils"

const MOCK_USERS = [
  {
    id: "1",
    email: "admin@agroreceta.com",
    password: "admin123",
    name: "Administrador",
    role: "admin" as UserRole,
    matricula: "MP 1001",
  },
  {
    id: "2",
    email: "ingeniero@agroreceta.com",
    password: "ingeniero123",
    name: "Ing. Agr. Juan Pérez",
    role: "ingeniero" as UserRole,
    matricula: "MP 12345",
  },
]

export function AuthProvider({ children }: { children: ReactNode }) {
  const [user, setUser] = useState<User | null>(null)

  useEffect(() => {
    const checkToken = async () => {
      const token = localStorage.getItem("token")
      if (!token) return

      const mockUser = localStorage.getItem("mockUser")
      if (token.startsWith("mock-token-") && mockUser) {
        setUser(JSON.parse(mockUser))
        return
      }

      try {
        const res = await apiFetch("/user")
        if (res.ok) {
          const data = await res.json()
          setUser(data)
        } else {
          if (mockUser) {
            setUser(JSON.parse(mockUser))
          } else {
            localStorage.removeItem("token")
            setUser(null)
          }
        }
      } catch (error) {
        if (mockUser) {
          setUser(JSON.parse(mockUser))
        } else {
          localStorage.removeItem("token")
          setUser(null)
        }
      }
    }
    checkToken()
  }, [])

  const login = async (email: string, password: string): Promise<boolean> => {
    try {
      const res = await apiFetch("/login", {
        method: "POST",
        body: JSON.stringify({ email, password }),
      })

      if (res.ok) {
        const data = await res.json()
        localStorage.setItem("token", data.token)
        setUser(data.user)
        localStorage.removeItem("mockUser")
        return true
      }

      return mockLogin(email, password)
    } catch (error) {
      return mockLogin(email, password)
    }
  }

  const mockLogin = (email: string, password: string): boolean => {
    const foundUser = MOCK_USERS.find((u) => u.email === email && u.password === password)

    if (foundUser) {
      const userData: User = {
        id: foundUser.id,
        name: foundUser.name,
        email: foundUser.email,
        role: foundUser.role,
        matricula: foundUser.matricula,
      }
      const mockToken = `mock-token-${foundUser.id}-${Date.now()}`
      localStorage.setItem("token", mockToken)
      localStorage.setItem("mockUser", JSON.stringify(userData))
      setUser(userData)
      return true
    }

    return false
  }

  const logout = async () => {
    try {
      await apiFetch("/logout", { method: "POST" })
    } catch (e) {
      // ignore error on logout
    }
    localStorage.removeItem("token")
    localStorage.removeItem("mockUser")
    setUser(null)
  }

  const refreshUser = async () => {
    try {
      const res = await apiFetch("/user")
      if (res.ok) {
        const data = await res.json()
        setUser(data)
        // Update mockUser cache if we are in a hybrid mode or just to keep consistency
        // But for real backend auth, we just update state.
      }
    } catch (error) {
      console.error("Failed to refresh user", error)
    }
  }

  return (
    <AuthContext.Provider
      value={{
        user,
        login,
        logout,
        refreshUser,
        isAuthenticated: !!user,
      }}
    >
      {children}
    </AuthContext.Provider>
  )
}

export function useAuth() {
  const context = useContext(AuthContext)
  if (context === undefined) {
    throw new Error("useAuth debe usarse dentro de AuthProvider")
  }
  return context
}