source: chapterx-frontend/src/store/authStore.ts@ acf690c

import { create } from 'zustand'
import { persist } from 'zustand/middleware'
import { User, UserRole } from '../types'
import { mockUsers } from '../data/mockData'
import axios from 'axios'

const API_BASE = 'https://localhost:7125/api'

interface AuthStore {
  currentUser: User | null
  token: string | null
  showMatureContent: boolean
  allUsers: User[]
  login: (emailOrUsername: string, password: string) => Promise<void>
  logout: () => void
  register: (data: { username: string; email: string; name: string; surname: string; password: string }, role: 'regular' | 'writer') => Promise<void>
  switchUser: (userId: number) => void
  setShowMatureContent: (show: boolean) => void
  updateUserRole: (userId: number, role: UserRole) => void
  addUser: (user: User) => void
}

export const useAuthStore = create<AuthStore>()(
  persist(
    (set, get) => ({
      currentUser: null,
      token: null,
      showMatureContent: true,
      allUsers: [],

      login: async (emailOrUsername, password) => {
        // Try backend first
        try {
          const email = emailOrUsername.includes('@')
            ? emailOrUsername
            : get().allUsers.find(u => u.username === emailOrUsername)?.email || emailOrUsername
          const res = await axios.post(`${API_BASE}/auth/login`, { email, password }, { timeout: 3000 })
          const { token, userId, username, name, surname, role } = res.data
          const user: User = {
            user_id: userId,
            username,
            email,
            name: name ?? username,
            surname: surname ?? '',
            role: role ?? 'regular',
            created_at: new Date().toISOString(),
            follower_count: 0,
            following_count: 0,
          }
          set({ currentUser: user, token })
          return
        } catch (err: any) {
          // Only fall through to mock if the backend is unreachable (network/timeout)
          // If the backend responded with an error (4xx/5xx), surface it to the user
          if (err?.response) {
            const message = err.response.data?.message || err.response.data || 'Invalid email or password.'
            throw new Error(typeof message === 'string' ? message : 'Invalid email or password.')
          }
          // Network error / timeout — fall through to mock login
        }

        // Fallback to mock
        const user = get().allUsers.find(
          u => u.username === emailOrUsername || u.email === emailOrUsername
        )
        if (!user) throw new Error('User not found. Try using a quick-login option.')
        set({ currentUser: user, token: 'mock-token' })
      },

      logout: () => set({ currentUser: null, token: null }),

      register: async (data, role) => {
        try {
          await axios.post(`${API_BASE}/auth/register`, data, { timeout: 3000 })
          // Register doesn't return a token — auto-login to get one
          const loginRes = await axios.post(`${API_BASE}/auth/login`, { email: data.email, password: data.password }, { timeout: 3000 })
          const { token, userId, username } = loginRes.data
          const newUser: User = {
            user_id: userId,
            username,
            email: data.email,
            name: data.name,
            surname: data.surname,
            role,
            created_at: new Date().toISOString(),
            follower_count: 0,
            following_count: 0,
          }
          set(state => ({ allUsers: [...state.allUsers, newUser], currentUser: newUser, token }))
          return
        } catch (err: any) {
          if (err?.response) {
            const message = err.response.data?.message || err.response.data || 'Registration failed.'
            throw new Error(typeof message === 'string' ? message : 'Registration failed.')
          }
          // Network error / timeout — fall through to mock register
          console.warn('Backend unreachable during register, using mock:', err?.message)
        }

        const newUser: User = {
          user_id: Date.now(),
          ...data,
          role,
          created_at: new Date().toISOString(),
          follower_count: 0,
          following_count: 0,
        }
        set(state => ({
          allUsers: [...state.allUsers, newUser],
          currentUser: newUser,
          token: 'mock-token',
        }))
      },

      switchUser: (userId: number) => {
        if (userId === 0) {
          set({ currentUser: null, token: null })
          return
        }
        const user = get().allUsers.find(u => u.user_id === userId)
        if (user) set({ currentUser: user, token: 'mock-token' })
      },

      setShowMatureContent: (show: boolean) => set({ showMatureContent: show }),

      updateUserRole: (userId: number, role: UserRole) =>
        set(state => ({
          allUsers: state.allUsers.map(u => (u.user_id === userId ? { ...u, role } : u)),
          currentUser:
            state.currentUser?.user_id === userId
              ? { ...state.currentUser, role }
              : state.currentUser,
        })),

      addUser: (user: User) =>
        set(state => ({ allUsers: [...state.allUsers, user] })),
    }),
    {
      name: 'chapterx-auth',
      partialize: s => ({
        currentUser: s.currentUser,
        token: s.token,
        showMatureContent: s.showMatureContent,
      }),
    }
  )
)