import { defineStore } from 'pinia';
import { store } from '@/store';
import { ACCESS_TOKEN, CURRENT_USER, IS_SCREENLOCKED } from '@/store/mutation-types';
import { ResultEnum } from '@/enums/httpEnum';

import { getUserInfo as getUserInfoApi, login, logout as logoutApi } from '@/api/system/user';
import type { LoginParams, LoginRes, UserInfoData } from '@/api/system/user';
import { encryptPassword } from '@/utils/encrypt';
import { storage } from '@/utils/Storage';

export type UserInfoType = Partial<UserInfoData> & {
  username: string;
  email?: string;
  permissions?: any[];
};

export interface IUserState {
  token: string;
  username: string;
  welcome: string;
  avatar: string;
  permissions: any[];
  info: UserInfoType;
}

export const useUserStore = defineStore({
  id: 'app-user',
  state: (): IUserState => ({
    token: storage.get(ACCESS_TOKEN, ''),
    username: '',
    welcome: '',
    avatar: '',
    permissions: [],
    info: storage.get(CURRENT_USER, {}),
  }),
  getters: {
    getToken(): string {
      return this.token;
    },
    getAvatar(): string {
      return this.avatar;
    },
    getNickname(): string {
      return this.username;
    },
    getPermissions(): [any][] {
      return this.permissions;
    },
    getUserInfo(): UserInfoType {
      return this.info;
    },
  },
  actions: {
    setToken(token: string) {
      this.token = token;
    },
    setAvatar(avatar: string) {
      this.avatar = avatar;
    },
    setPermissions(permissions) {
      this.permissions = permissions;
    },
    setUserInfo(info: UserInfoType) {
      this.info = info;
    },
    // 登录
    async login(params: LoginParams): Promise<LoginRes> {
      const encryptedPassword = encryptPassword(params.password);
      if (!encryptedPassword) {
        return {
          code: ResultEnum.ERROR,
          message: '密码加密失败',
        };
      }

      const response = await login({
        ...params,
        password: encryptedPassword,
      });
      const { code, data } = response;
      if (code === ResultEnum.SUCCESS && data) {
        const ex = data.tokenTimeout || 7 * 24 * 60 * 60;
        storage.set(ACCESS_TOKEN, data.token, ex);
        storage.set(CURRENT_USER, data, ex);
        storage.set(IS_SCREENLOCKED, false);
        this.setToken(data.token);
        this.setUserInfo({
          username: data.username,
          email: '',
        });
      }
      return response;
    },

    // 获取用户信息
    async getInfo() {
      const response = await getUserInfoApi();
      const { data } = response;
      if (!data) {
        throw new Error(response.message || 'getInfo: user info is empty');
      }

      const permissionsList = data.permissions ?? [];
      const userInfo: UserInfoType = {
        ...data,
        email: '',
        permissions: permissionsList,
      };
      this.setPermissions(permissionsList);
      this.setUserInfo(userInfo);
      this.setAvatar(data.avatarUrl || '');
      return userInfo;
    },

    // 登出
    async logout() {
      try {
        await logoutApi();
      } finally {
        this.setToken('');
        this.setPermissions([]);
        this.setAvatar('');
        this.setUserInfo({ username: '', email: '', permissions: [] });
        storage.remove(ACCESS_TOKEN);
        storage.remove(CURRENT_USER);
        storage.remove(IS_SCREENLOCKED);
      }
    },
  },
});

// Need to be used outside the setup
export function useUser() {
  return useUserStore(store);
}