'use client'

import { create } from 'zustand'
import { devtools, persist } from 'zustand/middleware'

import { setCookie, deleteCookie } from 'cookies-next'

import { Toast } from '@/components/ui/Toast'
import ServiceInstance, { apiUrl } from '@/utils/ClientRequest'
import { zustandCookieStorage } from '@/utils/ZustandCookies'
import { profile } from 'console'
export interface AuthState {
    user: any | null
    token: string | null
    isAuthenticated: boolean
    isLoading: boolean
    sidebarToggle: boolean
    profileDetails: any | null
    language: string

    login: (
        payload: any,
        callback?: (s: boolean) => void,
        isToast?: boolean
    ) => Promise<void>
    registerUser: (
        payload: any,
        callback?: (s: boolean) => void,
        isToast?: boolean
    ) => Promise<void>
    logout: () => void
    verifyYourEmail: (
        payload: any,
        callback?: (s: boolean) => void,
        isToast?: boolean
    ) => Promise<void>
    resendOtp: (
        payload: any,
        callback?: (s: boolean) => void,
        isToast?: boolean
    ) => Promise<void>
    updateSidebarToggle: (isSidebar: boolean) => void
    forgotPassword: (
        payload: any,
        callback?: (s: boolean) => void,
        isToast?: boolean
    ) => Promise<void>
    verifyOtp: (
        payload: any,
        callback?: (s: boolean) => void,
        isToast?: boolean
    ) => Promise<void>
    verifyResetPassword: (
        payload: any,
        callback?: (s: boolean) => void,
        isToast?: boolean
    ) => Promise<void>
    resetPassword: (
        payload: any,
        callback?: (s: boolean) => void,
        isToast?: boolean
    ) => Promise<void>
    viewProfile: (
        callback?: (s: boolean) => void,
        isToast?: boolean
    ) => Promise<void>
    updateProfile: (
        payload: any,
        callback?: (s: boolean) => void,
        isToast?: boolean
    ) => Promise<void>

    setLanguage: (lang: string) => void
}
export const useAuthStore = create<AuthState>()(
    devtools(
        persist(
            (set) => ({
                user: null,
                token: null,
                isAuthenticated: false,
                isLoading: false,
                sidebarToggle: false,
                profileDetails: null,
                language: 'en',

                setLanguage: (lang: string) => {
                    set({ language: lang })
                },

                login: async (payload, callback, isToast = true) => {
                    set({ isLoading: true })

                    try {
                        const { data } = await ServiceInstance.post(
                            apiUrl.login,
                            payload
                        )
                        const success = Boolean(data?.meta?.status)

                        if (success) {
                            set({
                                profileDetails: data.data,
                                token: data.meta.tokens?.access_token,
                                isAuthenticated: true
                            })
                        }

                        isToast &&
                            Toast(
                                success ? 'success' : 'error',
                                data?.meta?.message
                            )
                        if (success) callback?.(success)
                    } catch (error: any) {
                        console.log('error', error)
                        Toast('error', error?.meta?.message || 'Login failed')
                    } finally {
                        set({ isLoading: false })
                    }
                },

                registerUser: async (payload, callback, isToast = true) => {
                    set({ isLoading: true })

                    try {
                        const { data } = await ServiceInstance.post(
                            apiUrl.register,
                            payload
                        )

                        const success = Boolean(data?.meta?.status)

                        isToast &&
                            Toast(
                                success ? 'success' : 'error',
                                data?.meta?.message
                            )

                        if (success) callback?.(success)
                    } catch (error: any) {
                        Toast(
                            'error',
                            error?.meta?.message || 'Registration failed'
                        )
                        callback?.(false)
                    } finally {
                        set({ isLoading: false })
                    }
                },

                logout: () => {
                    deleteCookie('auth-store')
                    set({
                        profileDetails: null,
                        token: null,
                        isAuthenticated: false
                    })
                    window.location.href =
                        process.env.NEXT_PUBLIC_BASE_URL ?? '/'
                },

                verifyYourEmail: async (payload, callback, isToast = true) => {
                    set({ isLoading: true })

                    try {
                        const { data } = await ServiceInstance.post(
                            apiUrl.verifyYourEmail,
                            payload
                        )
                        const success = Boolean(data?.meta?.status)
                        isToast &&
                            Toast(
                                success ? 'success' : 'error',
                                data?.meta?.message
                            )
                        if (success) callback?.(success)
                    } catch (error: any) {
                        Toast('error', error?.message || 'Login failed')
                    } finally {
                        set({ isLoading: false })
                    }
                },
                resendOtp: async (payload, callback, isToast = true) => {
                    set({ isLoading: true })

                    try {
                        const { data } = await ServiceInstance.post(
                            apiUrl.resendVerificationCode,
                            payload
                        )
                        const success = Boolean(data?.meta?.status)
                        isToast &&
                            Toast(
                                success ? 'success' : 'error',
                                data?.meta?.message
                            )
                        if (success) callback?.(success)
                    } catch (error: any) {
                        Toast('error', error?.message || 'Login failed')
                    } finally {
                        set({ isLoading: false })
                    }
                },

                verifyResetPassword: async (
                    payload,
                    callback,
                    isToast = true
                ) => {
                    set({ isLoading: true })

                    try {
                        const { data } = await ServiceInstance.post(
                            apiUrl.resetPasswordVerify,
                            payload
                        )
                        const success = Boolean(data?.meta?.status)
                        isToast &&
                            Toast(
                                success ? 'success' : 'error',
                                data?.meta?.message
                            )
                        if (success) callback?.(success)
                    } catch (error: any) {
                        Toast('error', error?.message || 'Login failed')
                    } finally {
                        set({ isLoading: false })
                    }
                },

                updateSidebarToggle: (value) => {
                    set({
                        sidebarToggle: value
                    })
                },

                forgotPassword: async (payload, callback, isToast = true) => {
                    set({ isLoading: true })

                    try {
                        const { data } = await ServiceInstance.post(
                            apiUrl.forgotPassword,
                            payload
                        )

                        isToast &&
                            Toast(
                                data?.meta?.status ? 'success' : 'error',
                                data?.meta?.message
                            )

                        callback?.(data?.meta?.status)
                    } catch (error: any) {
                        Toast('error', error?.message || 'Request failed')
                        callback?.(false)
                    } finally {
                        set({ isLoading: false })
                    }
                },

                verifyOtp: async (payload, callback, isToast = true) => {
                    set({ isLoading: true })

                    try {
                        const { data } = await ServiceInstance.post(
                            apiUrl.verifyOtp,
                            payload
                        )

                        isToast &&
                            Toast(
                                data?.meta?.status ? 'success' : 'error',
                                data?.meta?.message
                            )

                        callback?.(data?.meta?.status)
                    } catch (error: any) {
                        Toast('error', error?.message || 'Request failed')
                        callback?.(false)
                    } finally {
                        set({ isLoading: false })
                    }
                },

                resetPassword: async (payload, callback, isToast = true) => {
                    set({ isLoading: true })

                    try {
                        const { data } = await ServiceInstance.post(
                            apiUrl.resetPassword,
                            payload
                        )

                        isToast &&
                            Toast(
                                data?.meta?.status ? 'success' : 'error',
                                data?.meta?.message
                            )

                        callback?.(data?.meta?.status)
                    } catch (error: any) {
                        Toast('error', error?.message || 'Request failed')
                        callback?.(false)
                    } finally {
                        set({ isLoading: false })
                    }
                },

                viewProfile: async (callback, isToast = false) => {
                    set({ isLoading: true })
                    try {
                        const { data } = await ServiceInstance.get(
                            apiUrl.viewProfile
                        )
                        const success = Boolean(data?.meta?.status)

                        if (success) {
                            set({
                                profileDetails: data.data
                            })
                            callback?.(success)
                        } else {
                            set({
                                profileDetails: null
                            })
                        }
                        isToast &&
                            Toast(
                                success ? 'success' : 'error',
                                data?.meta?.message
                            )
                    } catch (error: any) {
                        Toast('error', error?.message || 'Fetch failed')
                    } finally {
                        set({ isLoading: false })
                    }
                },
                updateProfile: async (payload, callback, isToast = true) => {
                    set({ isLoading: true })
                    try {
                        const { data } = await ServiceInstance.put(
                            apiUrl.updateProfile,
                            payload
                        )
                        const success = Boolean(data?.meta?.status)
                        isToast &&
                            Toast(
                                success ? 'success' : 'error',
                                data?.meta?.message
                            )
                        if (success) callback?.(success)
                    } catch (error: any) {
                        Toast('error', error?.message || 'Update failed')
                    } finally {
                        set({ isLoading: false })
                    }
                }
            }),

            {
                name: 'auth-store',
                storage: zustandCookieStorage,
                partialize: (state) => ({
                    user: state.user,
                    token: state.token,
                    isAuthenticated: state.isAuthenticated,
                    sidebarToggle: state.sidebarToggle
                })
            }
        )
    )
)