import { defineStore } from "pinia";
import http from "@/plugins/http";
import config from "@/app.config";

import { useCounterMixin } from "@/stores/mixin";

import type {
  DataBackup,
  BackUpRunning,
} from "@/modules/04_system/interface/response/Main";

import { ref } from "vue";

const mixin = useCounterMixin();
const {
  dialogRemove,
  messageError,
  showLoader,
  hideLoader,
  success,
  dialogConfirm,
} = mixin;

export const useDataStore = defineStore("systemStore", () => {
  const dataBackUp = ref<DataBackup[]>([]);
  const prevBackupRunTotal = ref<number>(-1);
  const backupRunTotal = ref<number>(0);

  const prevRestoreRunTotal = ref<number>(-1);
  const restoreRunTotal = ref<number>(0);

  const recordRestore = ref<Record<string, DataBackup>>({});

  async function fetchListBackup() {
    showLoader();
    await http
      .get(config.API.backup)
      .then((res) => {
        dataBackUp.value = res.data;

        dataBackUp.value = dataBackUp.value.map((item) => {
          return {
            ...item,
            status: "สำเร็จ",
          };
        });
      })
      .finally(() => {
        hideLoader();
      });
  }

  async function createBackUp() {
    showLoader();
    await http
      .post(config.API.backup + "/create")
      .then(async (res) => {
        await backupRunningList();
      })
      .finally(() => {
        hideLoader();
      });
  }

  async function deleteBackUp(filename: string) {
    showLoader();
    await http
      .delete(config.API.backup + "/delete", {
        data: { name: filename },
      })
      .then(async (res) => {
        await fetchListBackup();
      })
      .finally(() => {
        hideLoader();
      });
  }

  async function restore(filename: string) {
    await http
      .post<string>(config.API.restore, {
        name: filename,
      })
      .then(async (res) => {
        const tempValue = dataBackUp.value.find((item) => {
          if (item.name === filename) {
            return true;
          }
        });

        if (tempValue) {
          recordRestore.value[res.data] = tempValue;
        }

        restoreRunningList();
      });
  }

  async function backupRunningList() {
    await http
      .get<BackUpRunning[]>(config.API.backup + "/backup-running-list")
      .then(async (res) => {
        backupRunTotal.value = res.data.length;

        if (backupRunTotal.value == 0) {
          fetchListBackup();
          prevBackupRunTotal.value = backupRunTotal.value;
          return;
        }

        setTimeout(async () => {
          backupRunningList();
        }, 3000);

        if (prevBackupRunTotal.value !== backupRunTotal.value) {
          res.data.forEach((item) => {
            const index = dataBackUp.value.findIndex((data) => {
              if (data.name === item.created_at.toString()) return true;
            });

            if (index === -1) {
              dataBackUp.value.unshift({
                id: item.created_at.toString(),
                name: "-",
                databaseSize: 0,
                storageSize: 0,
                timestamp: item.created_at,
                status: item.running ? "running" : "success",
              });
            }
          });

          prevBackupRunTotal.value = backupRunTotal.value;
        }
      });
  }

  async function restoreRunningList() {
    await http
      .get<BackUpRunning[]>(config.API.backup + "/restore-running-list")
      .then(async (res) => {
        console.log(res.data);

        restoreRunTotal.value = res.data.length;

        if (restoreRunTotal.value == 0) {
          fetchListBackup();
          prevRestoreRunTotal.value = restoreRunTotal.value;
          return;
        }

        setTimeout(async () => {
          restoreRunningList();
        }, 3000);

        if (prevRestoreRunTotal.value !== restoreRunTotal.value) {
          for (const [key, value] of Object.entries(recordRestore.value)) {
            if (!res.data.find((v) => v.id === key))
              delete recordRestore.value[key];
            else value.status = "running";
          }

          prevRestoreRunTotal.value = restoreRunTotal.value;
        }
      });
  }

  function getSize(size: number): string {
    if (size === undefined) return "Unknow size";

    const units = ["B", "KB", "MB", "GB", "TB"];

    let i = 0;
    let sizeNumber = typeof size === "string" ? parseFloat(size) : size;
    while (sizeNumber >= 1024 && i++ < units.length - 1) {
      sizeNumber /= 1024;
    }
    return sizeNumber.toFixed(2) + " " + units[i];
  }

  return {
    dataBackUp,
    backupRunTotal,
    restoreRunTotal,

    fetchListBackup,
    createBackUp,
    restore,
    deleteBackUp,

    backupRunningList,
    restoreRunningList,

    getSize,
  };
});