import { UserResponse } from '@goodgo/types';
import { create } from 'zustand';
import { persist } from 'zustand/middleware';

import { authApi } from '../services/api/auth.api';

/**
 * EN: Authentication state interface for Zustand store
 * VI: Interface trạng thái xác thực cho Zustand store
 */
interface AuthState {
  /** EN: Current authenticated user / VI: Người dùng đã xác thực hiện tại */
  user: UserResponse | null;
  /** EN: Authentication status / VI: Trạng thái xác thực */
  isAuthenticated: boolean;
  /** EN: Loading state for async operations / VI: Trạng thái loading cho async operations */
  isLoading: boolean;
  /** EN: Login method / VI: Method đăng nhập */
  login: (email: string, password: string) => Promise<void>;
  /** EN: Register method / VI: Method đăng ký */
  register: (email: string, password: string, confirmPassword: string) => Promise<void>;
  /** EN: Logout method / VI: Method đăng xuất */
  logout: () => Promise<void>;
  /** EN: Fetch current user method / VI: Method lấy thông tin user hiện tại */
  fetchUser: () => Promise<void>;
  /** EN: OAuth login method / VI: Method đăng nhập OAuth */
  oauthLogin: (accessToken: string) => Promise<void>;
  /** EN: Update profile method / VI: Method cập nhật profile */
  updateProfile: (data: Partial<UserResponse>) => void;
}

/**
 * EN: Zustand store for authentication state management with persistence
 * VI: Zustand store để quản lý trạng thái xác thực với persistence
 *
 * Features:
 * - User state management (authenticated user data)
 * - Authentication status tracking
 * - Loading states for async operations
 * - Login, register, logout operations
 * - OAuth authentication support
 * - Persistent storage with localStorage (user and auth status only)
 */
export const useAuthStore = create<AuthState>()(
  persist(
    (set) => ({
      user: null,
      isAuthenticated: false,
      isLoading: false,

      /**
       * EN: Login user and update store state
       * VI: Đăng nhập người dùng và cập nhật trạng thái store
       *
       * @param email - User email address / Địa chỉ email người dùng
       * @param password - User password / Mật khẩu người dùng
       * @throws Error if login fails / Ném lỗi nếu đăng nhập thất bại
       */
      login: async (email: string, password: string) => {
        set({ isLoading: true });
        try {
          const response = await authApi.login({ email, password });
          if (response.success && response.data) {
            set({
              user: response.data.user,
              isAuthenticated: true,
              isLoading: false,
            });
          } else {
            throw new Error(response.error?.message || 'Login failed');
          }
        } catch (error) {
          set({ isLoading: false });
          throw error;
        }
      },

      /**
       * EN: Register new user and update store state
       * VI: Đăng ký người dùng mới và cập nhật trạng thái store
       *
       * @param email - User email address / Địa chỉ email người dùng
       * @param password - User password / Mật khẩu người dùng
       * @param confirmPassword - Password confirmation / Xác nhận mật khẩu
       * @throws Error if registration fails / Ném lỗi nếu đăng ký thất bại
       */
      register: async (email: string, password: string, confirmPassword: string) => {
        set({ isLoading: true });
        try {
          const response = await authApi.register({ email, password, confirmPassword });
          if (response.success && response.data) {
            set({
              user: response.data.user,
              isAuthenticated: true,
              isLoading: false,
            });
          } else {
            throw new Error(response.error?.message || 'Registration failed');
          }
        } catch (error) {
          set({ isLoading: false });
          throw error;
        }
      },

      /**
       * EN: Logout user and clear store state
       * VI: Đăng xuất người dùng và xóa trạng thái store
       *
       * Clears tokens and user data from both store and localStorage
       * Xóa tokens và dữ liệu người dùng khỏi cả store và localStorage
       */
      logout: async () => {
        try {
          await authApi.logout();
        } finally {
          // EN: Always clear state even if logout API call fails
          // VI: Luôn xóa trạng thái ngay cả khi API call logout thất bại
          set({
            user: null,
            isAuthenticated: false,
          });
        }
      },

      /**
       * EN: Fetch current user profile from API
       * VI: Lấy hồ sơ người dùng hiện tại từ API
       *
       * Used for checking authentication status on app initialization
       * Được sử dụng để kiểm tra trạng thái xác thực khi khởi tạo ứng dụng
       */
      fetchUser: async () => {
        set({ isLoading: true });
        try {
          const response = await authApi.getMe();
          if (response.success && response.data) {
            set({
              user: response.data,
              isAuthenticated: true,
              isLoading: false,
            });
          } else {
            // EN: Clear state if user fetch fails (token might be invalid)
            // VI: Xóa trạng thái nếu fetch user thất bại (token có thể không hợp lệ)
            set({
              user: null,
              isAuthenticated: false,
              isLoading: false,
            });
          }
        } catch (error) {
          // EN: Clear user state on fetch failure (token expired or invalid)
          // VI: Xóa trạng thái user khi fetch thất bại (token hết hạn hoặc không hợp lệ)
          set({
            user: null,
            isAuthenticated: false,
            isLoading: false,
          });
        }
      },

      /**
       * EN: Login with OAuth token from callback
       * VI: Đăng nhập với OAuth token từ callback
       *
       * @param accessToken - OAuth access token / OAuth access token
       * @throws Error if OAuth login fails / Ném lỗi nếu đăng nhập OAuth thất bại
       */
      oauthLogin: async (accessToken: string) => {
        set({ isLoading: true });
        try {
          const response = await authApi.oauthLogin(accessToken);
          if (response.success && response.data) {
            // EN: Store refresh token if provided
            // VI: Lưu refresh token nếu được cung cấp
            if (response.data.refreshToken && typeof window !== 'undefined') {
              localStorage.setItem('refreshToken', response.data.refreshToken);
            }
            set({
              user: response.data.user,
              isAuthenticated: true,
              isLoading: false,
            });
          } else {
            throw new Error(response.error?.message || 'OAuth login failed / Đăng nhập OAuth thất bại');
          }
        } catch (error) {
          set({ isLoading: false });
          throw error;
        }
      },

      /**
       * EN: Update user profile in store
       * VI: Cập nhật hồ sơ người dùng trong store
       *
       * @param data - Updated user data / Dữ liệu người dùng đã cập nhật
       */
      updateProfile: (data: Partial<UserResponse>) => {
        set((state) => ({
          user: state.user ? { ...state.user, ...data } : null,
        }));
      },
    }),
    {
      // EN: Persist auth state to localStorage
      // VI: Persist trạng thái auth vào localStorage
      name: 'auth-storage',
      // EN: Only persist user and isAuthenticated, exclude isLoading
      // VI: Chỉ persist user và isAuthenticated, loại trừ isLoading
      partialize: (state) => ({ user: state.user, isAuthenticated: state.isAuthenticated }),
    }
  )
);
