import { computed, reactive } from 'vue';

import {
  getAuthPermissionInfoApi,
  getEnabledMenuListApi,
  getUserProfileApi,
  loginApi,
  logoutApi,
  type AuthMenu,
  type EnabledMenu,
  type LoginParams,
  type LoginResult,
  type UserProfile,
} from '../api/auth';

const TOKEN_KEY = 'mom_access_token';
const REFRESH_TOKEN_KEY = 'mom_refresh_token';
const USER_KEY = 'mom_user_profile';
const PERMISSIONS_KEY = 'mom_permissions';
const MENUS_KEY = 'mom_access_menus_api';
const ROLES_KEY = 'mom_user_roles';
const ENABLED_MENUS_KEY = 'mom_enabled_menus';
function readStorage<T>(key: string): T | null {
  try {
    return uni.getStorageSync(key) || null;
  } catch {
    return null;
  }
}

const state = reactive({
  accessToken: readStorage<string>(TOKEN_KEY),
  refreshToken: readStorage<string>(REFRESH_TOKEN_KEY),
  user: readStorage<UserProfile>(USER_KEY),
  permissions: readStorage<string[]>(PERMISSIONS_KEY) ?? [],
  menus: readStorage<AuthMenu[]>(MENUS_KEY) ?? [],
  roles: readStorage<string[]>(ROLES_KEY) ?? [],
  enabledMenus: readStorage<EnabledMenu[]>(ENABLED_MENUS_KEY) ?? [],
});

function saveUser(user: UserProfile | null) {
  state.user = user;
  if (user) {
    uni.setStorageSync(USER_KEY, user);
  } else {
    uni.removeStorageSync(USER_KEY);
  }
}

function savePermissionInfo(data: { permissions: string[]; menus: AuthMenu[]; roles: string[] }) {
  state.permissions = data.permissions || [];
  state.menus = data.menus || [];
  state.roles = data.roles || [];
  uni.setStorageSync(PERMISSIONS_KEY, state.permissions);
  uni.setStorageSync(MENUS_KEY, state.menus);
  uni.setStorageSync(ROLES_KEY, state.roles);
}

function saveEnabledMenus(menus: EnabledMenu[]) {
  state.enabledMenus = menus || [];
  uni.setStorageSync(ENABLED_MENUS_KEY, state.enabledMenus);
}

function clearPermissionInfo() {
  state.permissions = [];
  state.menus = [];
  state.roles = [];
  uni.removeStorageSync(PERMISSIONS_KEY);
  uni.removeStorageSync(MENUS_KEY);
  uni.removeStorageSync(ROLES_KEY);
  state.enabledMenus = [];
  uni.removeStorageSync(ENABLED_MENUS_KEY);
}

function clearSession() {
    state.accessToken = null;
    state.refreshToken = null;
    uni.removeStorageSync(TOKEN_KEY);
    uni.removeStorageSync(REFRESH_TOKEN_KEY);
    saveUser(null);
    clearPermissionInfo();
  }

  uni.$on('auth-expired', clearSession);

export function useAuth() {
  const isLoggedIn = computed(() => Boolean(state.accessToken));

  function hasPermission(code: string) {
    return state.permissions.includes(code);
  }

  async function initializeSession(result: LoginResult) {
    state.accessToken = result.accessToken;
    state.refreshToken = result.refreshToken;
    uni.setStorageSync(TOKEN_KEY, result.accessToken);
    uni.setStorageSync(REFRESH_TOKEN_KEY, result.refreshToken);

    try {
      const [user, permissionInfo, enabledMenus] = await Promise.all([
        getUserProfileApi(result.accessToken),
        getAuthPermissionInfoApi(result.accessToken),
        getEnabledMenuListApi(result.accessToken),
      ]);
      saveUser(user);
      savePermissionInfo(permissionInfo);
      saveEnabledMenus(enabledMenus);
    } catch (error) {
      clearSession();
      throw error;
    }
  }

  async function login(params: LoginParams) {
    await initializeSession(await loginApi(params));
  }

  async function restoreUser() {
    if (!state.accessToken) return;
    try {
      if (!state.user) {
        saveUser(await getUserProfileApi(state.accessToken));
      }
      if ((!state.menus.length && !state.permissions.length) || !state.enabledMenus.length) {
        const [permissionInfo, enabledMenus] = await Promise.all([
          getAuthPermissionInfoApi(state.accessToken),
          getEnabledMenuListApi(state.accessToken),
        ]);
        savePermissionInfo(permissionInfo);
        saveEnabledMenus(enabledMenus);
      }
    } catch {
      clearSession();
    }
  }

  async function refreshPermissionInfo() {
    if (!state.accessToken) {
      clearPermissionInfo();
      return;
    }
    const [permissionInfo, enabledMenus] = await Promise.all([
      getAuthPermissionInfoApi(state.accessToken),
      getEnabledMenuListApi(state.accessToken),
    ]);
    savePermissionInfo(permissionInfo);
    saveEnabledMenus(enabledMenus);
  }

  async function logout() {
    const accessToken = state.accessToken;
    clearSession();
    if (accessToken) {
      try {
        await logoutApi(accessToken);
      } catch {
        // 本地登录状态已经清理，无需阻断退出流程
      }
    }
  }

  return {
    state,
    isLoggedIn,
    hasPermission,
    login,
    logout,
    restoreUser,
    refreshPermissionInfo,
  };
}
