/**
 * Auth Store
 *
 * 管理认证状态和用户会话（平台无关）
 */
import { defineStore } from 'pinia';
import { ref, computed, type Ref } from 'vue';
import type {
  User,
  LoginCredentials,
  RegisterData,
  AuthResponse,
  LoginResponse,
} from '../types/auth';
import type { IStorageAdapter } from '../adapters/storage/interface';
import type { IRequestAdapter } from '../adapters/request/interface';
import { StorageKey } from '../adapters/storage/interface';
import { logger } from '../utils/logger';

// 全局适配器实例
let storageAdapter: IStorageAdapter;
let requestAdapter: IRequestAdapter;

/**
 * 设置存储适配器
 */
export function setAuthStorageAdapter(adapter: IStorageAdapter) {
  storageAdapter = adapter;
}

/**
 * 设置请求适配器
 */
export function setAuthRequestAdapter(adapter: IRequestAdapter) {
  requestAdapter = adapter;
}

export const useAuthStore = defineStore('auth', () => {
  // State
  const user: Ref<User | null> = ref(null);
  const token: Ref<string | null> = ref(null);
  const isAuthenticated = ref(false);
  const loading = ref(false);

  // Computed
  const userRole = computed(() => {
    if (!user.value) return 'customer_user';
    // 兼容两种格式：is_superuser 字段或 role 字段
    if (user.value.is_superuser === true) return 'platform_admin';
    if (user.value.role === 'platform_admin') return 'platform_admin';
    return 'customer_user';
  });

  const userRoles = computed(() => {
    if (!user.value) return [];
    // Return roles array if available, otherwise fallback to single role
    return user.value.roles || (user.value.role ? [user.value.role] : []);
  });

  const isPlatformAdmin = computed(() => {
    if (!user.value) return false;
    // 兼容两种格式：is_superuser 字段或 role 字段或 roles 数组
    return (
      user.value.is_superuser === true ||
      user.value.role === 'platform_admin' ||
      userRoles.value.includes('platform_admin')
    );
  });
  const isVerified = computed(() => user.value?.is_verified === true);

  /**
   * Check if user has a specific role
   */
  const hasRole = (roleCode: string): boolean => {
    return userRoles.value.includes(roleCode);
  };

  /**
   * Check if user has any of the specified roles
   */
  const hasAnyRole = (roleCodes: string[]): boolean => {
    return roleCodes.some((code) => userRoles.value.includes(code));
  };

  /**
   * 登录
   */
  const login = async (credentials: LoginCredentials): Promise<AuthResponse> => {
    try {
      loading.value = true;
      const response = await requestAdapter.post<LoginResponse>('/api/v1/auth/login', credentials);

      token.value = response.data.access_token;
      user.value = response.data.user;
      isAuthenticated.value = true;

      // 保存到存储
      await storageAdapter.setItem(StorageKey.ACCESS_TOKEN, response.data.access_token);
      await storageAdapter.setItem(StorageKey.USER_INFO, response.data.user);

      return { success: true, message: '登录成功' };
    } catch (error: any) {
      // 从错误响应中提取友好的错误信息
      let errorMessage = '登录失败';

      // 检查是否是认证错误（邮箱或密码错误）
      if (error.response?.status === 401) {
        errorMessage = '邮箱或密码错误';
      } else if (error.response?.status === 500) {
        errorMessage = '服务器错误，请稍后重试';
      } else if (error.response?.data?.detail) {
        // 如果服务器返回的是英文错误信息，进行翻译
        const detail = error.response.data.detail;
        const detailStr = typeof detail === 'string' ? detail : String(detail);
        if (
          detailStr.toLowerCase().includes('incorrect') ||
          detailStr.toLowerCase().includes('password')
        ) {
          errorMessage = '邮箱或密码错误';
        } else {
          errorMessage = detailStr;
        }
      } else if (
        error.message &&
        !error.message.includes('AxiosError') &&
        !error.message.includes('Request failed')
      ) {
        errorMessage = error.message;
      }

      return { success: false, message: errorMessage };
    } finally {
      loading.value = false;
    }
  };

  /**
   * 注册
   */
  const register = async (userData: RegisterData): Promise<AuthResponse> => {
    try {
      loading.value = true;
      const response = await requestAdapter.post<AuthResponse>('/api/v1/auth/register', userData);

      return {
        success: response.data.success,
        message: response.data.message,
        needsVerification: response.data.needsVerification,
      };
    } catch (error: any) {
      return { success: false, message: error.message || '注册失败' };
    } finally {
      loading.value = false;
    }
  };

  /**
   * 验证邮箱
   */
  const verifyEmail = async (verifyToken: string): Promise<AuthResponse> => {
    try {
      loading.value = true;
      const response = await requestAdapter.get<AuthResponse>(
        `/api/v1/auth/verify-email?token=${verifyToken}`
      );

      return {
        success: response.data.success,
        message: response.data.message,
      };
    } catch (error: any) {
      return { success: false, message: error.message || '验证失败' };
    } finally {
      loading.value = false;
    }
  };

  /**
   * 重新发送验证邮件
   */
  const resendVerificationEmail = async (email: string): Promise<AuthResponse> => {
    try {
      loading.value = true;
      const response = await requestAdapter.post<AuthResponse>('/api/v1/auth/resend-verification', {
        email,
      });

      return {
        success: response.data.success,
        message: response.data.message,
      };
    } catch (error: any) {
      return { success: false, message: error.message || '发送失败' };
    } finally {
      loading.value = false;
    }
  };

  /**
   * 登出
   */
  const logout = async (): Promise<void> => {
    user.value = null;
    token.value = null;
    isAuthenticated.value = false;

    // 清除存储
    await storageAdapter.removeItem(StorageKey.ACCESS_TOKEN);
    await storageAdapter.removeItem(StorageKey.USER_INFO);
  };

  /**
   * 初始化认证状态
   */
  const initAuth = async (): Promise<void> => {
    logger.info('AuthStore', 'Initializing auth state');
    const storedToken = await storageAdapter.getItem<string>(StorageKey.ACCESS_TOKEN);
    const storedUser = await storageAdapter.getItem<User>(StorageKey.USER_INFO);

    logger.debug('AuthStore', 'Retrieved from storage', {
      hasToken: !!storedToken,
      hasUser: !!storedUser,
    });

    if (storedToken && storedUser) {
      token.value = storedToken;
      user.value = storedUser;
      isAuthenticated.value = true;
      logger.info('AuthStore', 'Auth state restored', {
        isAuthenticated: true,
        userEmail: storedUser.email,
      });
    } else {
      logger.info('AuthStore', 'No valid auth info found');
    }
  };

  /**
   * 更新用户信息
   */
  const updateUser = async (userData: Partial<User>): Promise<void> => {
    if (user.value) {
      user.value = { ...user.value, ...userData };
      await storageAdapter.setItem(StorageKey.USER_INFO, user.value);
    }
  };

  return {
    // State
    user,
    token,
    isAuthenticated,
    loading,

    // Computed
    userRole,
    userRoles,
    isPlatformAdmin,
    isVerified,

    // Actions
    login,
    register,
    verifyEmail,
    resendVerificationEmail,
    logout,
    initAuth,
    updateUser,
    hasRole,
    hasAnyRole,
  };
});