lh-website/src/store/authStore.ts

import { create } from 'zustand';
import type { User, LoginForm, LoginResponse } from '@/types';

interface AuthState {
  user: User | null;
  token: string | null;
  isLoggedIn: boolean;
  login: (form: LoginForm) => Promise<LoginResponse>;
  logout: () => void;
  setUser: (user: User) => void;
  setToken: (token: string) => void;
  setIsLoggedIn: (isLoggedIn: boolean) => void;
}

const mockUsers: Record<string, { password: string; user: User }> = {
  'super_admin': {
    password: 'admin123',
    user: {
      id: 'u1',
      username: 'super_admin',
      email: 'super@token.com',
      phone: '13800000001',
      role: 'super_admin',
      status: 'enabled',
      enterpriseId: '',
      departmentId: null,
      quota: -1,
      usedQuota: 0,
      createdAt: '2024-01-01',
      updatedAt: '2024-01-01',
    },
  },
  'platform_operator': {
    password: 'operator123',
    user: {
      id: 'u2',
      username: 'platform_operator',
      email: 'operator@token.com',
      phone: '13800000002',
      role: 'platform_operator',
      status: 'enabled',
      enterpriseId: '',
      departmentId: null,
      quota: -1,
      usedQuota: 0,
      createdAt: '2024-01-01',
      updatedAt: '2024-01-01',
    },
  },
  'enterprise_admin': {
    password: 'enterprise123',
    user: {
      id: 'u3',
      username: 'enterprise_admin',
      email: 'admin@enterprise.com',
      phone: '13800000003',
      role: 'enterprise_admin',
      status: 'enabled',
      enterpriseId: 'e1',
      departmentId: 'd1',
      quota: 1000000,
      usedQuota: 250000,
      createdAt: '2024-01-01',
      updatedAt: '2024-01-01',
    },
  },
  'employee': {
    password: 'employee123',
    user: {
      id: 'u4',
      username: 'employee',
      email: 'employee@enterprise.com',
      phone: '13800000004',
      role: 'employee',
      status: 'enabled',
      enterpriseId: 'e1',
      departmentId: 'd2',
      quota: 100000,
      usedQuota: 35000,
      createdAt: '2024-01-01',
      updatedAt: '2024-01-01',
    },
  },
};

export const useAuthStore = create<AuthState>()((set) => ({
  user: null,
  token: null,
  isLoggedIn: false,
  
  login: async (form: LoginForm) => {
    const mockUser = mockUsers[form.username];
    if (!mockUser || mockUser.password !== form.password) {
      throw new Error('用户名或密码错误');
    }
    const response: LoginResponse = {
      token: `token_${form.username}_${Date.now()}`,
      user: mockUser.user,
    };
    set({ user: mockUser.user, token: response.token, isLoggedIn: true });
    localStorage.setItem('token', response.token);
    localStorage.setItem('user', JSON.stringify(mockUser.user));
    return response;
  },
  
  logout: () => {
    set({ user: null, token: null, isLoggedIn: false });
    localStorage.removeItem('token');
    localStorage.removeItem('user');
  },
  
  setUser: (user: User) => {
    set({ user });
    localStorage.setItem('user', JSON.stringify(user));
  },
  
  setToken: (token: string) => {
    set({ token });
    localStorage.setItem('token', token);
  },
  
  setIsLoggedIn: (isLoggedIn: boolean) => {
    set({ isLoggedIn });
  },
}));

export const initAuth = () => {
  const token = localStorage.getItem('token');
  const userStr = localStorage.getItem('user');
  if (token && userStr) {
    try {
      const user = JSON.parse(userStr) as User;
      useAuthStore.getState().setUser(user);
      useAuthStore.getState().setToken(token);
      useAuthStore.getState().setIsLoggedIn(true);
    } catch {
      localStorage.removeItem('token');
      localStorage.removeItem('user');
    }
  }
};