import {
  jccGetImagesReq,
  jccGetResourcesReq,
  jccGetResourceTypesReq,
  jccLoginReq,
} from '@/services/external';
import { to } from '@/utils/promise';
import { proxy } from '@umijs/max';

export type JCCResourceRange = {
  type: string;
};

export type JCCResourceType = {
  label: string;
  value: string;
};

export interface JCCResourceImage {
  imageID: number;
  name: string;
  createTime: Date;
  clusterImages: JCCClusterImage[];
}

export interface JCCClusterImage {
  imageID: number;
  clusterID: string;
  originImageType: string;
  originImageID: string;
  originImageName: string;
  cards: JCCCard[];
}

export interface JCCCard {
  originImageID: string;
  card: string;
}

export interface JCCResourceStandard {
  id: number;
  sourceKey: string;
  type: string;
  name: string;
  totalCount: number;
  availableCount: number;
  changeType: number;
  status: number;
  region: string;
  clusterId: string;
  costPerUnit: number;
  costType: string;
  tag: string;
  userId: number;
  createTime: Date;
  updateTime: Date;
  baseResourceSpecs: JCCBaseResourceSpec[];
}

export interface JCCBaseResourceSpec {
  id: number;
  resourceSpecId: number;
  type: string;
  name: string;
  totalValue: number;
  totalUnit: string;
  availableValue: number;
  availableUnit: string;
  userId: number;
  createTime: Date;
  updateTime: Date;
}

type JCCResourceTypeStore = {
  token: string;
  types: JCCResourceType[];
  images: JCCResourceImage[];
  resources: JCCResourceStandard[];
  currentType: string | undefined | null;
  jccLogin: () => void;
  getResourceTypes: () => void;
  getImages: (cardTypes: string[]) => void;
  getResources: (cardType: string) => void;
  setCurrentType: (cardType: string) => void;
};

const state = proxy<JCCResourceTypeStore>({
  token: '',
  types: [],
  images: [],
  resources: [],
  currentType: undefined,
  jccLogin: async () => {
    const [res] = await to(jccLoginReq());
    if (res && res.code === 200 && res.data) {
      const { tokenHead, token } = res.data;
      state.token = tokenHead + token;
    }
  },
  getResourceTypes: async () => {
    const [loginRes] = await to(jccLoginReq());
    if (loginRes && loginRes.code === 200 && loginRes.data) {
      const { tokenHead, token, jsmUserInfo } = loginRes.data;
      state.token = tokenHead + token;
      const userID = jsmUserInfo?.data?.userID;
      const [res] = await to(jccGetResourceTypesReq(tokenHead + token, userID));
      if (res && res.code === 'OK' && res.data) {
        state.types = res.data.resourceRanges?.map((v: JCCResourceRange) => ({
          label: v.type,
          value: v.type,
        }));
      }
    }
  },
  getImages: async (cardTypes: string[]) => {
    const [res] = await to(jccGetImagesReq(state.token, cardTypes));
    if (res && res.code === 'OK' && res.data) {
      state.images = res.data.images;
    }
  },
  getResources: async (cardType: string) => {
    const [res] = await to(jccGetResourcesReq(state.token, cardType));
    if (res && res.code === 'OK' && res.data) {
      state.resources = res.data.resource;
    }
  },
  setCurrentType: (cardType: string | undefined | null) => {
    if (state.currentType !== cardType) {
      state.currentType = cardType;
      state.images = [];
      state.resources = [];
      if (cardType) {
        state.getImages([cardType]);
        state.getResources(cardType);
      }
    }
  },
});

export default state;