import { create } from "zustand";
import { persist } from "zustand/middleware";
import {
  api,
  type User,
  type LoginRequest,
  type RegistrationRequest,
} from "../utils/api";

interface AuthState {
  user: User | null;
  token: string | null;
  isAuthenticated: boolean;
  isLoading: boolean;
  error: string | null;
  registrationMessage: string | null;
  login: (credentials: LoginRequest) => Promise<boolean>;
  register: (credentials: RegistrationRequest) => Promise<boolean>;
  fetchUser: () => Promise<void>;
  logout: () => void;
  clearError: () => void;
}

export const useAuthStore = create<AuthState>()(
  persist(
    (set) => ({
      user: null,
      token: null,
      isAuthenticated: false,
      isLoading: false,
      error: null,
      registrationMessage: null,

      login: async (credentials: LoginRequest) => {
        set({ isLoading: true, error: null });

        try {
          const response = await api.login(credentials);

          set({
            user: response.user,
            token: response.token,
            isAuthenticated: true,
            isLoading: false,
            error: null,
          });

          return true;
        } catch (error) {
          const errorMessage =
            error instanceof Error ? error.message : "Login failed";
          set({
            user: null,
            token: null,
            isAuthenticated: false,
            isLoading: false,
            error: errorMessage,
          });

          return false;
        }
      },
      register: async (credentials: RegistrationRequest) => {
        set({ isLoading: true, error: null });

        try {
          const response = await api.register(credentials);

          set({
            registrationMessage: response.message,
          });

          return true;
        } catch (error) {
          const errorMessage =
            error instanceof Error ? error.message : "Registration failed";
          set({
            user: null,
            token: null,
            isAuthenticated: false,
            isLoading: false,
            error: errorMessage,
          });

          return false;
        }
      },

      fetchUser: async () => {
        const token = useAuthStore.getState().token;
        if (!token) return;

        try {
          const user = await api.fetchUser(token);
          set({ user });
        } catch (error) {
          console.error("Failed to refresh user:", error);
        }
      },

      logout: () => {
        set({
          user: null,
          token: null,
          isAuthenticated: false,
          error: null,
        });
      },

      clearError: () => set({ error: null }),
    }),
    {
      name: "auth-storage",
      partialize: (state) => ({
        user: state.user,
        token: state.token,
        isAuthenticated: state.isAuthenticated,
      }),
    },
  ),
);