import { authService } from '@/services/auth.service'
import { type AdminUser } from '@/types/auth.types'
import { create } from 'zustand'
import { persist } from 'zustand/middleware'

interface AuthState {
  user: AdminUser | null
  token: string | null
  isAuthenticated: boolean
  isHydrated: boolean
  profileFetched: boolean
  setToken: (token: string | null) => void
  setUser: (user: AdminUser | null) => void
  setHydrated: (state: boolean) => void
  setProfileFetched: (state: boolean) => void
  clearAuth: () => void
  logout: () => Promise<void>
}

export const useAuthStore = create<AuthState>()(
  persist(
    (set) => ({
      token: null,
      user: null,

      isAuthenticated: false,
      isHydrated: false,
      profileFetched: false,

      setToken: (token) =>
        set({
          token,
          isAuthenticated: !!token,
        }),

      setUser: (user) =>
        set({
          user,
        }),

      setHydrated: (state) =>
        set({
          isHydrated: state,
        }),

      setProfileFetched: (state) =>
        set({
          profileFetched: state,
        }),

      clearAuth: () =>
        set({
          user: null,
          token: null,
          isAuthenticated: false,
          profileFetched: false,
        }),

      logout: async () => {
        try {
          await authService.logout()
        } finally {
          set({
            user: null,
            token: null,
            isAuthenticated: false,
            profileFetched: false,
          })
        }
      },
    }),
    {
      name: 'auth-storage',

      partialize: (state) => ({
        user: state.user,
        token: state.token,
        isAuthenticated: state.isAuthenticated,
      }),

      onRehydrateStorage: () => (state) => {
        state?.setHydrated(true)
      },
    }
  )
)