import { TFunction } from "i18next";
import { runInAction } from "mobx";
import { sprintf } from "sprintf-js";
import { getMillis } from "taehui-ts/date";

import { Note } from "src/avatar/Avatar";
import { formatText, toDate } from "src/Utility";
import { wwwAXIOS } from "src/Www";
import {
  AvatarAPIWantAvatar,
  AvatarWwwLevelsAPI,
  GetAvatarAPI,
  GetAvatarFavoritesAPI,
  GetAvatarLastsAPI,
  GetAvatarWwwLevelsAPI,
} from "src/wwwAPI";

export default function setAvatarStore() {
  let lastMillisAvatar = getMillis();
  let lastMillisFavorites = getMillis();
  let lastMillisLasts = getMillis();
  let lastMillisWwwLevels = getMillis();

  return {
    input: "",
    wantAvatars: [] as AvatarAPIWantAvatar[],
    avatarID: "",
    avatarName: "",
    avatarIntro: "",
    totalCount: "",
    totalLength: "",
    highestCount: "",
    date: "",
    avatarLevels: [] as number[],
    avatarAbility5K: 0,
    avatarAbility5KClass: 0,
    avatarAbility5KPlace: 0,
    avatarAbility5KCount: 0,
    avatarAbility7K: 0,
    avatarAbility7KClass: 0,
    avatarAbility7KPlace: 0,
    avatarAbility7KCount: 0,
    avatarAbility9K: 0,
    avatarAbility9KClass: 0,
    avatarAbility9KPlace: 0,
    avatarAbility9KCount: 0,
    wwwLevels: [] as AvatarWwwLevelsAPI[],
    lasts: [] as Note[],
    favorites: [] as Note[],
    dateSet: [] as string[],
    dateValues: [] as number[],
    quitStatusValues: [] as number[],
    isFavoritesLoading: false,
    isLastsLoading: false,
    isWwwLevelLoading: false,

    get isLoading() {
      return (
        this.isFavoritesLoading || this.isLastsLoading || this.isWwwLevelLoading
      );
    },

    setInput(input: string) {
      this.input = input;
    },

    async getAvatar(
      t: TFunction,
      { avatarID, avatarName }: { avatarID?: string; avatarName?: string },
    ) {
      this.wantAvatars = [];
      this.avatarID = "";
      if (avatarID || avatarName) {
        const millis = getMillis();
        lastMillisAvatar = millis;
        const { status, data } = await wwwAXIOS.get<GetAvatarAPI>("/avatar", {
          params: { avatarID, avatarName },
        });
        if (millis >= lastMillisAvatar) {
          switch (status) {
            case 200:
              if (Array.isArray(data)) {
                runInAction(() => {
                  this.wantAvatars = data;
                });
              } else {
                runInAction(() => {
                  this.avatarID = data.avatarID;
                  this.avatarName = data.avatarName;
                  this.avatarIntro = data.avatarIntro;
                  this.totalCount = formatText(data.totalCount);
                  this.totalLength = sprintf(
                    t("totalLengthText"),
                    Math.floor(data.totalLength / 1000 / 60 / 60),
                    Math.floor((data.totalLength / 1000 / 60) % 60),
                    Math.floor((data.totalLength / 1000) % 60),
                  );
                  this.highestCount = formatText(data.highestCount);
                  this.date = toDate(data.date);
                  this.avatarLevels = data.avatarLevels;
                  this.avatarAbility5K = data.avatarAbility5K;
                  this.avatarAbility5KClass = data.avatarAbility5KClass;
                  this.avatarAbility5KPlace = data.avatarAbility5KPlace;
                  this.avatarAbility5KCount = data.avatarAbility5KCount;
                  this.avatarAbility7K = data.avatarAbility7K;
                  this.avatarAbility7KClass = data.avatarAbility7KClass;
                  this.avatarAbility7KPlace = data.avatarAbility7KPlace;
                  this.avatarAbility7KCount = data.avatarAbility7KCount;
                  this.avatarAbility9K = data.avatarAbility9K;
                  this.avatarAbility9KClass = data.avatarAbility9KClass;
                  this.avatarAbility9KPlace = data.avatarAbility9KPlace;
                  this.avatarAbility9KCount = data.avatarAbility9KCount;
                  this.dateSet = data.dateSet.map((date) =>
                    new Date(date).toLocaleDateString(),
                  );
                  this.dateValues = data.dateValues;
                  this.quitStatusValues = data.quitStatusValues;
                });
              }
              break;
          }
        }
      }
    },

    async getAvatarFavorites(t: TFunction) {
      const millis = getMillis();
      lastMillisFavorites = millis;
      this.isFavoritesLoading = true;
      const { status, data } = await wwwAXIOS.get<GetAvatarFavoritesAPI>(
        "/avatar/favorites",
        {
          params: { avatarID: this.avatarID },
        },
      );
      if (millis >= lastMillisFavorites) {
        switch (status) {
          case 200:
            runInAction(() => {
              this.favorites = data.map((favorite) => ({
                ...favorite,
                fittedText: sprintf(t("textHandled"), favorite.totalCount),
              }));
              this.isFavoritesLoading = false;
            });
            break;
        }
      }
    },

    async getAvatarLasts() {
      const millis = getMillis();
      lastMillisLasts = millis;
      this.isLastsLoading = true;
      const { status, data } = await wwwAXIOS.get<GetAvatarLastsAPI>(
        "/avatar/lasts",
        {
          params: { avatarID: this.avatarID },
        },
      );
      if (millis >= lastMillisLasts) {
        switch (status) {
          case 200:
            runInAction(() => {
              this.lasts = data.map((last) => ({
                ...last,
                fittedText: toDate(last.date),
              }));
              this.isLastsLoading = false;
            });
            break;
        }
      }
    },

    async getAvatarWwwLevels() {
      const millis = getMillis();
      lastMillisWwwLevels = millis;
      this.isWwwLevelLoading = true;
      const { status, data } = await wwwAXIOS.get<GetAvatarWwwLevelsAPI>(
        "/avatar/wwwLevels",
        {
          params: { avatarID: this.avatarID },
        },
      );
      if (millis >= lastMillisWwwLevels) {
        switch (status) {
          case 200:
            runInAction(() => {
              this.wwwLevels = data;
              this.isWwwLevelLoading = false;
            });
            break;
        }
      }
    },
  };
}