import { ref, computed } from "vue";
import { defineStore } from "pinia";
import { useQuasar } from "quasar";
import http from "@/plugins/http";
import config from "@/app.config";
import { useCounterMixin } from "@/stores/mixin";
import type { RequestItemsHistoryObject } from "@/modules/01_metadata/interface/request/person/Prefix";
import type { RequestItemsHistoryObject as InsigniaResponse } from "@/modules/01_metadata/interface/request/insignia/Insignia";
import type { RequestItemsHistoryObject as InsigniaTypeResponse } from "@/modules/01_metadata/interface/request/insignia/InsigniaType";
import type { RequestItemsHistoryObject as positionEmployeeResponse } from "@/modules/01_metadata/interface/request/positionEmployee/Position";
import type { RequestItemsHistoryObject as positionEmployeeSideResponse } from "@/modules/01_metadata/interface/request/positionEmployee/PositionSide";
import type { RequestItemsHistoryObject as positionEmployeeGroupResponse } from "@/modules/01_metadata/interface/request/positionEmployee/Group";
import type { RequestItemsHistoryObject as positionEmployeeLineResponse } from "@/modules/01_metadata/interface/request/positionEmployee/Line";
import type { RequestItemsHistoryObject as positionEmployeeLevelResponse } from "@/modules/01_metadata/interface/request/positionEmployee/Level";
import type { RequestItemsHistoryObject as positionEmployeeStatusResponse } from "@/modules/01_metadata/interface/request/positionEmployee/Status";

const $q = useQuasar();
const mixin = useCounterMixin();
const { success, messageError, showLoader, hideLoader } = mixin;

export const useManageDataStore = defineStore("manage", () => {
  const dataPrefix = ref<RequestItemsHistoryObject[]>([]); //list data table
  const draftPrefix = ref<RequestItemsHistoryObject[]>([]); //list data table
  const dataInsignia = ref<InsigniaResponse[]>([]); //list data table
  const draftInsignia = ref<InsigniaResponse[]>([]); //list data table
  const dataInsigniaType = ref<InsigniaTypeResponse[]>([]); //list data table
  const draftInsigniaType = ref<InsigniaTypeResponse[]>([]); //list data table
  const dataPositionEmployee = ref<positionEmployeeResponse[]>([]); //list data table
  const draftPositionEmployee = ref<positionEmployeeResponse[]>([]); //list data table
  const dataPositionEmployeeSide = ref<positionEmployeeSideResponse[]>([]); //list data table
  const draftPositionEmployeeSide = ref<positionEmployeeSideResponse[]>([]); //list data table
  const dataPositionEmployeeGroup = ref<positionEmployeeGroupResponse[]>([]); //list data table
  const draftPositionEmployeeGroup = ref<positionEmployeeGroupResponse[]>([]); //list data table
  const dataPositionEmployeeLine = ref<positionEmployeeLineResponse[]>([]); //list data table
  const draftPositionEmployeeLine = ref<positionEmployeeLineResponse[]>([]); //list data table
  const dataPositionEmployeeLevel = ref<positionEmployeeLevelResponse[]>([]); //list data table
  const draftPositionEmployeeLevel = ref<positionEmployeeLevelResponse[]>([]); //list data table
  const dataPositionEmployeeStatus = ref<positionEmployeeStatusResponse[]>([]); //list data table
  const draftPositionEmployeeStatus = ref<positionEmployeeStatusResponse[]>([]); //list data table

  const storeIdVersion = ref<string>(""); //id data ใน mongodb
  const storeVersion = ref<string>("published"); //รายการข้อมูลล่าสุดได้เผยแพร่หรือยัง published=เผยแพร่แล้ว draft=ยังไม่เผยแพร่
  interface manage {
    link: number;
    person: {
      name: string;
      prefix: { columns: String[] };
      blood: { columns: String[] };
      gender: { columns: String[] };
      religion: { columns: String[] };
      relationship: { columns: String[] };
      education: { columns: String[] };
      province: { columns: String[] };
      district: { columns: String[] };
      subDistrict: { columns: String[] };
    };
    organization: {
      name: string;
      organization: { columns: String[] };
      shortName: { columns: String[] };
      type: { columns: String[] };
      level: { columns: String[] };
      agency: { columns: String[] };
      governmentAgency: { columns: String[] };
      status: { columns: String[] };
      telInternal: { columns: String[] };
      telExternal: { columns: String[] };
      fax: { columns: String[] };
    };
    position: {
      name: string;
      path: { columns: String[] };
      executiveSide: { columns: String[] };
      type: { columns: String[] };
      line: { columns: String[] };
      pathSide: { columns: String[] };
      executive: { columns: String[] };
      level: { columns: String[] };
      status: { columns: String[] };
    };
    positionEmployee: {
      name: string;
      position: { columns: String[] };
      positionSide: { columns: String[] };
      group: { columns: String[] };
      line: { columns: String[] };
      level: { columns: String[] };
      status: { columns: String[] };
    };
    calendar: {
      name: string;
      tree: { columns: String[] };
      list: { columns: String[] };
    };
    insignia: {
      name: string;
      class: { columns: String[] };
      type: { columns: String[] };
      //   badge: { columns: String[] };
    };
  }

  const manageData = ref<manage>({
    link: 1,
    person: {
      name: "",
      prefix: { columns: [] },
      blood: { columns: [] },
      gender: { columns: [] },
      religion: { columns: [] },
      relationship: { columns: [] },
      education: { columns: [] },
      province: { columns: [] },
      district: { columns: [] },
      subDistrict: { columns: [] },
    },
    organization: {
      name: "",
      organization: { columns: [] },
      shortName: { columns: [] },
      type: { columns: [] },
      level: { columns: [] },
      agency: { columns: [] },
      governmentAgency: { columns: [] },
      status: { columns: [] },
      telInternal: { columns: [] },
      telExternal: { columns: [] },
      fax: { columns: [] },
    },
    position: {
      name: "",
      path: { columns: [] },
      executiveSide: { columns: [] },
      type: { columns: [] },
      line: { columns: [] },
      pathSide: { columns: [] },
      executive: { columns: [] },
      level: { columns: [] },
      status: { columns: [] },
    },
    positionEmployee: {
      name: "",
      position: { columns: [] },
      positionSide: { columns: [] },
      group: { columns: [] },
      line: { columns: [] },
      level: { columns: [] },
      status: { columns: [] },
    },
    calendar: {
      name: "",
      tree: { columns: [] },
      list: { columns: [] },
    },
    insignia: {
      name: "",
      class: { columns: [] },
      type: { columns: [] },
      //   badge: { columns: [] },
    },
  });

  const changeManageCurrentTab = (type: number, val: string) => {
    if (type == 1) manageData.value.person.name = val;
    if (type == 2) manageData.value.organization.name = val;
    if (type == 3) manageData.value.position.name = val;
    if (type == 4) manageData.value.positionEmployee.name = val;
    if (type == 5) manageData.value.calendar.name = val;
    if (type == 6) manageData.value.insignia.name = val;
    localStorage.setItem("manage", JSON.stringify(manageData.value));
  };

  const changeManageColumns = (type: number, tab: String, val: String[]) => {
    if (type == 1) {
      if (tab == "blood") manageData.value.person.blood.columns = val;
      if (tab == "district") manageData.value.person.district.columns = val;
      if (tab == "education") manageData.value.person.education.columns = val;
      if (tab == "gender") manageData.value.person.gender.columns = val;
      if (tab == "prefix") manageData.value.person.prefix.columns = val;
      if (tab == "province") manageData.value.person.province.columns = val;
      if (tab == "religion") manageData.value.person.religion.columns = val;
      if (tab == "relationship")
        manageData.value.person.relationship.columns = val;
      if (tab == "subDistrict")
        manageData.value.person.subDistrict.columns = val;
    }
    if (type == 2) {
      if (tab == "agency") manageData.value.organization.agency.columns = val;
      if (tab == "fax") manageData.value.organization.fax.columns = val;
      if (tab == "governmentAgency")
        manageData.value.organization.governmentAgency.columns = val;
      if (tab == "shortName")
        manageData.value.organization.shortName.columns = val;
      if (tab == "level") manageData.value.organization.level.columns = val;
      if (tab == "organization")
        manageData.value.organization.organization.columns = val;
      if (tab == "status") manageData.value.organization.status.columns = val;
      if (tab == "telExternal")
        manageData.value.organization.telExternal.columns = val;
      if (tab == "telInternal")
        manageData.value.organization.telInternal.columns = val;
      if (tab == "type") manageData.value.organization.type.columns = val;
    }
    if (type == 3) {
      if (tab == "executive") manageData.value.position.executive.columns = val;
      if (tab == "executiveSide")
        manageData.value.position.executiveSide.columns = val;
      if (tab == "level") manageData.value.position.level.columns = val;
      if (tab == "line") manageData.value.position.line.columns = val;
      if (tab == "path") manageData.value.position.path.columns = val;
      if (tab == "pathSide") manageData.value.position.pathSide.columns = val;
      if (tab == "status") manageData.value.position.status.columns = val;
      if (tab == "type") manageData.value.position.type.columns = val;
    }
    if (type == 4) {
      if (tab == "group") manageData.value.positionEmployee.group.columns = val;
      if (tab == "level") manageData.value.positionEmployee.level.columns = val;
      if (tab == "line") manageData.value.positionEmployee.line.columns = val;
      if (tab == "position")
        manageData.value.positionEmployee.position.columns = val;
      if (tab == "positionSide")
        manageData.value.positionEmployee.positionSide.columns = val;
      if (tab == "status")
        manageData.value.positionEmployee.status.columns = val;
    }
    if (type == 5) {
      if (tab == "tree") manageData.value.calendar.tree.columns = val;
      if (tab == "list") manageData.value.calendar.list.columns = val;
    }
    if (type == 6) {
      //   if (tab == "badge") manageData.value.insignia.badge.columns = val;
      if (tab == "class") manageData.value.insignia.class.columns = val;
      if (tab == "type") manageData.value.insignia.type.columns = val;
    }
    localStorage.setItem("manage", JSON.stringify(manageData.value));
  };

  const changeManageLink = (val: number) => {
    manageData.value.link = val;
    localStorage.setItem("manage", JSON.stringify(manageData.value));
  };

  if (localStorage.getItem("manage")) {
    const data = JSON.parse(localStorage.getItem("manage") || "{}");
    const isDataValid = Object.getOwnPropertyNames(manageData.value).every(
      (val1) => {
        const descriptor1 = Object.getOwnPropertyDescriptor(
          manageData.value,
          val1
        );
        return (
          descriptor1 &&
          descriptor1.configurable &&
          Object.getOwnPropertyNames(descriptor1.value).every((val2) => {
            return data[val1] && data[val1].hasOwnProperty(val2);
          })
        );
      }
    );

    if (isDataValid) {
      manageData.value = data;
    } else {
      localStorage.setItem("manage", JSON.stringify(manageData.value));
    }
  }

  const getPrefix = async (
    selector: boolean = false,
    newFetch: boolean = false
  ) => {
    if (dataPrefix.value.length === 0) {
      await fetchPrefix(true, selector);
      return {
        data: draftPrefix.value,
        version: storeVersion.value,
        idversion: storeIdVersion.value,
      };
    } else {
      if (newFetch) {
        await fetchPrefix(true, selector);
        return {
          data: draftPrefix.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      } else {
        return {
          data: draftPrefix.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      }
    }
  };

  const getInsigniaType = async (
    selector: boolean = false,
    newFetch: boolean = false
  ) => {
    if (dataInsignia.value.length === 0) {
      await fetchInsigniaType(true, selector);
      return {
        data: draftInsigniaType.value,
        version: storeVersion.value,
        idversion: storeIdVersion.value,
      };
    } else {
      if (newFetch) {
        await fetchInsigniaType(true, selector);
        return {
          data: draftInsigniaType.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      } else {
        return {
          data: draftInsigniaType.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      }
    }
  };

  const getInsignia = async (
    selector: boolean = false,
    newFetch: boolean = false
  ) => {
    if (dataInsignia.value.length === 0) {
      await fetchInsignia(true, selector);
      return {
        data: draftInsignia.value,
        version: storeVersion.value,
        idversion: storeIdVersion.value,
      };
    } else {
      if (newFetch) {
        await fetchInsignia(true, selector);
        return {
          data: draftInsignia.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      } else {
        return {
          data: draftInsignia.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      }
    }
  };

  const getPositionEmployee = async (
    selector: boolean = false,
    newFetch: boolean = false
  ) => {
    if (dataPositionEmployee.value.length === 0) {
      await fetchPositionEmployee(true, selector);
      return {
        data: draftPositionEmployee.value,
        version: storeVersion.value,
        idversion: storeIdVersion.value,
      };
    } else {
      if (newFetch) {
        await fetchPositionEmployee(true, selector);
        return {
          data: draftPositionEmployee.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      } else {
        return {
          data: draftPositionEmployee.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      }
    }
  };

  const getPositionEmployeeSide = async (
    selector: boolean = false,
    newFetch: boolean = false
  ) => {
    if (dataPositionEmployeeSide.value.length === 0) {
      await fetchPositionEmployeeSide(true, selector);
      return {
        data: draftPositionEmployeeSide.value,
        version: storeVersion.value,
        idversion: storeIdVersion.value,
      };
    } else {
      if (newFetch) {
        await fetchPositionEmployeeSide(true, selector);
        return {
          data: draftPositionEmployeeSide.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      } else {
        return {
          data: draftPositionEmployeeSide.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      }
    }
  };

  const getPositionEmployeeGroup = async (
    selector: boolean = false,
    newFetch: boolean = false
  ) => {
    if (dataPositionEmployeeGroup.value.length === 0) {
      await fetchPositionEmployeeGroup(true, selector);
      return {
        data: draftPositionEmployeeGroup.value,
        version: storeVersion.value,
        idversion: storeIdVersion.value,
      };
    } else {
      if (newFetch) {
        await fetchPositionEmployeeGroup(true, selector);
        return {
          data: draftPositionEmployeeGroup.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      } else {
        return {
          data: draftPositionEmployeeGroup.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      }
    }
  };

  const getPositionEmployeeLine = async (
    selector: boolean = false,
    newFetch: boolean = false
  ) => {
    if (dataPositionEmployeeLine.value.length === 0) {
      await fetchPositionEmployeeLine(true, selector);
      return {
        data: draftPositionEmployeeLine.value,
        version: storeVersion.value,
        idversion: storeIdVersion.value,
      };
    } else {
      if (newFetch) {
        await fetchPositionEmployeeLine(true, selector);
        return {
          data: draftPositionEmployeeLine.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      } else {
        return {
          data: draftPositionEmployeeLine.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      }
    }
  };

  const getPositionEmployeeLevel = async (
    selector: boolean = false,
    newFetch: boolean = false
  ) => {
    if (dataPositionEmployeeLevel.value.length === 0) {
      await fetchPositionEmployeeLevel(true, selector);
      return {
        data: draftPositionEmployeeLevel.value,
        version: storeVersion.value,
        idversion: storeIdVersion.value,
      };
    } else {
      if (newFetch) {
        await fetchPositionEmployeeLevel(true, selector);
        return {
          data: draftPositionEmployeeLevel.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      } else {
        return {
          data: draftPositionEmployeeLevel.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      }
    }
  };

  const getPositionEmployeeStatus = async (
    selector: boolean = false,
    newFetch: boolean = false
  ) => {
    if (dataPositionEmployeeStatus.value.length === 0) {
      await fetchPositionEmployeeStatus(true, selector);
      return {
        data: draftPositionEmployeeStatus.value,
        version: storeVersion.value,
        idversion: storeIdVersion.value,
      };
    } else {
      if (newFetch) {
        await fetchPositionEmployeeStatus(true, selector);
        return {
          data: draftPositionEmployeeStatus.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      } else {
        return {
          data: draftPositionEmployeeStatus.value,
          version: storeVersion.value,
          idversion: storeIdVersion.value,
        };
      }
    }
  };

  const fetchPrefix = async (loader: boolean, selector: boolean) => {
    let apiPrefix = "";
    if (loader) {
      showLoader();
    }
    if (selector) {
      apiPrefix = config.API.prefix;
    } else {
      apiPrefix = config.API.listPrefixHistory;
    }
    await http
      .get(apiPrefix)
      .then((res) => {
        const data = res.data.result;
        let rows: RequestItemsHistoryObject[] = [];
        if (selector) {
          data.map((e: RequestItemsHistoryObject) => {
            rows.push({
              ...e,
            });
          });
        } else {
          storeVersion.value = data.version; //ตัวแปรที่บอกว่าข้อมูลเผยแพร่ไปหรือยัง published=เผยแพร่แล้ว draft=ยังไม่เผยแพร่
          storeIdVersion.value = data.id; //เลข id ใน mongodb

          data.items.map((e: RequestItemsHistoryObject) => {
            rows.push({
              ...e,
            });
          });
        }

        draftPrefix.value = rows;
        if (loader) {
          dataPrefix.value = rows;
        }
      })
      .catch((e) => {
        messageError($q, e);
      })
      .finally(() => {
        if (loader) {
          hideLoader();
        }
      });
  };

  const fetchInsignia = async (loader: boolean, selector: boolean) => {
    let apiInsignia = "";
    if (loader) {
      showLoader();
    }
    if (selector) {
      apiInsignia = config.API.insignia;
    } else {
      apiInsignia = config.API.listInsigniaHistory;
    }
    await http
      .get(apiInsignia)
      .then((res) => {
        const data = res.data.result;
        let rows: InsigniaResponse[] = [];
        if (selector) {
          data.map((e: InsigniaResponse) => {
            rows.push({
              id: e.id,
              name: e.name,
              shortName: e.shortName,
              level: e.level,
              createdAt: e.createdAt,
              lastUpdatedAt: e.lastUpdatedAt,
              lastUpdateFullName: e.lastUpdateFullName,
              isActive: e.isActive,
              createdFullName: e.createdFullName,
              createdUserId: e.createdUserId,
              lastUpdateUserId: e.lastUpdateUserId,
              insigniaType: e.insigniaType,
              note: e.note,
            });
          });
        } else {
          storeVersion.value = data.version; //ตัวแปรที่บอกว่าข้อมูลเผยแพร่ไปหรือยัง published=เผยแพร่แล้ว draft=ยังไม่เผยแพร่
          storeIdVersion.value = data.id; //เลข id ใน mongodb

          data.items.map((e: InsigniaResponse) => {
            rows.push({
              id: e.id,
              name: e.name,
              shortName: e.shortName,
              level: e.level,
              createdAt: e.createdAt,
              lastUpdatedAt: e.lastUpdatedAt,
              lastUpdateFullName: e.lastUpdateFullName,
              isActive: e.isActive,
              createdFullName: e.createdFullName,
              createdUserId: e.createdUserId,
              lastUpdateUserId: e.lastUpdateUserId,
              insigniaType: e.insigniaType,
              note: e.note,
            });
          });
        }

        draftInsignia.value = rows;
        if (loader) {
          dataInsignia.value = rows;
        }
      })
      .catch((e) => {
        messageError($q, e);
      })
      .finally(() => {
        if (loader) {
          hideLoader();
        }
      });
  };

  const fetchInsigniaType = async (loader: boolean, selector: boolean) => {
    let apiInsigniaType = "";
    if (loader) {
      showLoader();
    }
    if (selector) {
      apiInsigniaType = config.API.insigniaType;
    } else {
      apiInsigniaType = config.API.listInsigniaTypeHistory;
    }
    await http
      .get(apiInsigniaType)
      .then((res) => {
        const data = res.data.result;
        let rows: InsigniaTypeResponse[] = [];
        if (selector) {
          data.map((e: InsigniaTypeResponse) => {
            rows.push({
              id: e.id,
              name: e.name,
              createdAt: e.createdAt,
              lastUpdatedAt: e.lastUpdatedAt,
              lastUpdateFullName: e.lastUpdateFullName,
              isActive: e.isActive,
              createdFullName: e.createdFullName,
              createdUserId: e.createdUserId,
              lastUpdateUserId: e.lastUpdateUserId,
            });
          });
        } else {
          storeVersion.value = data.version; //ตัวแปรที่บอกว่าข้อมูลเผยแพร่ไปหรือยัง published=เผยแพร่แล้ว draft=ยังไม่เผยแพร่
          storeIdVersion.value = data.id; //เลข id ใน mongodb

          data.items.map((e: InsigniaTypeResponse) => {
            rows.push({
              id: e.id,
              name: e.name,
              createdAt: e.createdAt,
              lastUpdatedAt: e.lastUpdatedAt,
              lastUpdateFullName: e.lastUpdateFullName,
              isActive: e.isActive,
              createdFullName: e.createdFullName,
              createdUserId: e.createdUserId,
              lastUpdateUserId: e.lastUpdateUserId,
            });
          });
        }

        draftInsigniaType.value = rows;
        if (loader) {
          dataInsigniaType.value = rows;
        }
      })
      .catch((e) => {
        messageError($q, e);
      })
      .finally(() => {
        if (loader) {
          hideLoader();
        }
      });
  };

  const fetchPositionEmployee = async (loader: boolean, selector: boolean) => {
    let apiPositionEmployee = "";
    if (loader) {
      showLoader();
    }
    if (selector) {
      apiPositionEmployee = config.API.positionEmployeePosition;
    } else {
      apiPositionEmployee = config.API.listPositionEmployeePositionHistory;
    }
    await http
      .get(apiPositionEmployee)
      .then((res) => {
        const data = res.data.result;
        let rows: positionEmployeeResponse[] = [];
        if (selector) {
          data.map((e: positionEmployeeResponse) => {
            rows.push({
              id: e.id,
              name: e.name,
              createdAt: e.createdAt,
              lastUpdatedAt: e.lastUpdatedAt,
              lastUpdateFullName: e.lastUpdateFullName,
              isActive: e.isActive,
              createdFullName: e.createdFullName,
              createdUserId: e.createdUserId,
              lastUpdateUserId: e.lastUpdateUserId,
              note: e.note,
            });
          });
        } else {
          storeVersion.value = data.version; //ตัวแปรที่บอกว่าข้อมูลเผยแพร่ไปหรือยัง published=เผยแพร่แล้ว draft=ยังไม่เผยแพร่
          storeIdVersion.value = data.id; //เลข id ใน mongodb

          data.items.map((e: positionEmployeeResponse) => {
            rows.push({
              id: e.id,
              name: e.name,
              createdAt: e.createdAt,
              lastUpdatedAt: e.lastUpdatedAt,
              lastUpdateFullName: e.lastUpdateFullName,
              isActive: e.isActive,
              createdFullName: e.createdFullName,
              createdUserId: e.createdUserId,
              lastUpdateUserId: e.lastUpdateUserId,
              note: e.note,
            });
          });
        }

        draftPositionEmployee.value = rows;
        if (loader) {
          dataPositionEmployee.value = rows;
        }
      })
      .catch((e) => {
        messageError($q, e);
      })
      .finally(() => {
        if (loader) {
          hideLoader();
        }
      });
  };

  const fetchPositionEmployeeSide = async (
    loader: boolean,
    selector: boolean
  ) => {
    let apiPositionEmployeeSide = "";
    if (loader) {
      showLoader();
    }
    if (selector) {
      apiPositionEmployeeSide = config.API.positionEmployeePositionSide;
    } else {
      apiPositionEmployeeSide =
        config.API.listPositionEmployeePositionSideHistory;
    }
    await http
      .get(apiPositionEmployeeSide)
      .then((res) => {
        const data = res.data.result;
        let rows: positionEmployeeSideResponse[] = [];
        if (selector) {
          data.map((e: positionEmployeeSideResponse) => {
            rows.push({
              id: e.id,
              name: e.name,
              createdAt: e.createdAt,
              lastUpdatedAt: e.lastUpdatedAt,
              lastUpdateFullName: e.lastUpdateFullName,
              isActive: e.isActive,
              createdFullName: e.createdFullName,
              createdUserId: e.createdUserId,
              lastUpdateUserId: e.lastUpdateUserId,
              note: e.note,
            });
          });
        } else {
          storeVersion.value = data.version; //ตัวแปรที่บอกว่าข้อมูลเผยแพร่ไปหรือยัง published=เผยแพร่แล้ว draft=ยังไม่เผยแพร่
          storeIdVersion.value = data.id; //เลข id ใน mongodb

          data.items.map((e: positionEmployeeSideResponse) => {
            rows.push({
              id: e.id,
              name: e.name,
              createdAt: e.createdAt,
              lastUpdatedAt: e.lastUpdatedAt,
              lastUpdateFullName: e.lastUpdateFullName,
              isActive: e.isActive,
              createdFullName: e.createdFullName,
              createdUserId: e.createdUserId,
              lastUpdateUserId: e.lastUpdateUserId,
              note: e.note,
            });
          });
        }

        draftPositionEmployeeSide.value = rows;
        if (loader) {
          dataPositionEmployeeSide.value = rows;
        }
      })
      .catch((e) => {
        messageError($q, e);
      })
      .finally(() => {
        if (loader) {
          hideLoader();
        }
      });
  };

  const fetchPositionEmployeeGroup = async (
    loader: boolean,
    selector: boolean
  ) => {
    let apiPositionEmployeeGroup = "";
    if (loader) {
      showLoader();
    }
    if (selector) {
      apiPositionEmployeeGroup = config.API.positionEmployeeGroup;
    } else {
      apiPositionEmployeeGroup = config.API.listPositionEmployeeGroupHistory;
    }
    await http
      .get(apiPositionEmployeeGroup)
      .then((res) => {
        const data = res.data.result;
        let rows: positionEmployeeGroupResponse[] = [];
        if (selector) {
          data.map((e: positionEmployeeGroupResponse) => {
            rows.push({
              id: e.id,
              name: e.name,
              createdAt: e.createdAt,
              lastUpdatedAt: e.lastUpdatedAt,
              lastUpdateFullName: e.lastUpdateFullName,
              isActive: e.isActive,
              createdFullName: e.createdFullName,
              createdUserId: e.createdUserId,
              lastUpdateUserId: e.lastUpdateUserId,
            });
          });
        } else {
          storeVersion.value = data.version; //ตัวแปรที่บอกว่าข้อมูลเผยแพร่ไปหรือยัง published=เผยแพร่แล้ว draft=ยังไม่เผยแพร่
          storeIdVersion.value = data.id; //เลข id ใน mongodb

          data.items.map((e: positionEmployeeGroupResponse) => {
            rows.push({
              id: e.id,
              name: e.name,
              createdAt: e.createdAt,
              lastUpdatedAt: e.lastUpdatedAt,
              lastUpdateFullName: e.lastUpdateFullName,
              isActive: e.isActive,
              createdFullName: e.createdFullName,
              createdUserId: e.createdUserId,
              lastUpdateUserId: e.lastUpdateUserId,
            });
          });
        }

        draftPositionEmployeeGroup.value = rows;
        if (loader) {
          dataPositionEmployeeGroup.value = rows;
        }
      })
      .catch((e) => {
        messageError($q, e);
      })
      .finally(() => {
        if (loader) {
          hideLoader();
        }
      });
  };

  const fetchPositionEmployeeLine = async (
    loader: boolean,
    selector: boolean
  ) => {
    let apiPositionEmployeeLine = "";
    if (loader) {
      showLoader();
    }
    if (selector) {
      apiPositionEmployeeLine = config.API.positionEmployeeLine;
    } else {
      apiPositionEmployeeLine = config.API.listPositionEmployeeLineHistory;
    }
    await http
      .get(apiPositionEmployeeLine)
      .then((res) => {
        const data = res.data.result;
        let rows: positionEmployeeLineResponse[] = [];
        if (selector) {
          data.map((e: positionEmployeeLineResponse) => {
            rows.push({
              id: e.id,
              name: e.name,
              createdAt: e.createdAt,
              lastUpdatedAt: e.lastUpdatedAt,
              lastUpdateFullName: e.lastUpdateFullName,
              isActive: e.isActive,
              createdFullName: e.createdFullName,
              createdUserId: e.createdUserId,
              lastUpdateUserId: e.lastUpdateUserId,
            });
          });
        } else {
          storeVersion.value = data.version; //ตัวแปรที่บอกว่าข้อมูลเผยแพร่ไปหรือยัง published=เผยแพร่แล้ว draft=ยังไม่เผยแพร่
          storeIdVersion.value = data.id; //เลข id ใน mongodb

          data.items.map((e: positionEmployeeLineResponse) => {
            rows.push({
              id: e.id,
              name: e.name,
              createdAt: e.createdAt,
              lastUpdatedAt: e.lastUpdatedAt,
              lastUpdateFullName: e.lastUpdateFullName,
              isActive: e.isActive,
              createdFullName: e.createdFullName,
              createdUserId: e.createdUserId,
              lastUpdateUserId: e.lastUpdateUserId,
            });
          });
        }

        draftPositionEmployeeLine.value = rows;
        if (loader) {
          dataPositionEmployeeLine.value = rows;
        }
      })
      .catch((e) => {
        messageError($q, e);
      })
      .finally(() => {
        if (loader) {
          hideLoader();
        }
      });
  };

  const fetchPositionEmployeeLevel = async (
    loader: boolean,
    selector: boolean
  ) => {
    let apiPositionEmployeeLevel = "";
    if (loader) {
      showLoader();
    }
    if (selector) {
      apiPositionEmployeeLevel = config.API.positionEmployeeLevel;
    } else {
      apiPositionEmployeeLevel = config.API.listPositionEmployeeLevelHistory;
    }
    await http
      .get(apiPositionEmployeeLevel)
      .then((res) => {
        const data = res.data.result;
        let rows: positionEmployeeLevelResponse[] = [];
        if (selector) {
          data.map((e: positionEmployeeLevelResponse) => {
            rows.push({
              id: e.id,
              name: e.name,
              createdAt: e.createdAt,
              lastUpdatedAt: e.lastUpdatedAt,
              lastUpdateFullName: e.lastUpdateFullName,
              isActive: e.isActive,
              createdFullName: e.createdFullName,
              createdUserId: e.createdUserId,
              lastUpdateUserId: e.lastUpdateUserId,
            });
          });
        } else {
          storeVersion.value = data.version; //ตัวแปรที่บอกว่าข้อมูลเผยแพร่ไปหรือยัง published=เผยแพร่แล้ว draft=ยังไม่เผยแพร่
          storeIdVersion.value = data.id; //เลข id ใน mongodb

          data.items.map((e: positionEmployeeLevelResponse) => {
            rows.push({
              id: e.id,
              name: e.name,
              createdAt: e.createdAt,
              lastUpdatedAt: e.lastUpdatedAt,
              lastUpdateFullName: e.lastUpdateFullName,
              isActive: e.isActive,
              createdFullName: e.createdFullName,
              createdUserId: e.createdUserId,
              lastUpdateUserId: e.lastUpdateUserId,
            });
          });
        }

        draftPositionEmployeeLevel.value = rows;
        if (loader) {
          dataPositionEmployeeLevel.value = rows;
        }
      })
      .catch((e) => {
        messageError($q, e);
      })
      .finally(() => {
        if (loader) {
          hideLoader();
        }
      });
  };

  const fetchPositionEmployeeStatus = async (
    loader: boolean,
    selector: boolean
  ) => {
    let apiPositionEmployeeStatus = "";
    if (loader) {
      showLoader();
    }
    if (selector) {
      apiPositionEmployeeStatus = config.API.positionEmployeeStatus;
    } else {
      apiPositionEmployeeStatus = config.API.listPositionEmployeeStatusHistory;
    }
    await http
      .get(apiPositionEmployeeStatus)
      .then((res) => {
        const data = res.data.result;
        let rows: positionEmployeeStatusResponse[] = [];
        if (selector) {
          data.map((e: positionEmployeeStatusResponse) => {
            rows.push({
              id: e.id,
              name: e.name,
              createdAt: e.createdAt,
              lastUpdatedAt: e.lastUpdatedAt,
              lastUpdateFullName: e.lastUpdateFullName,
              isActive: e.isActive,
              createdFullName: e.createdFullName,
              createdUserId: e.createdUserId,
              lastUpdateUserId: e.lastUpdateUserId,
            });
          });
        } else {
          storeVersion.value = data.version; //ตัวแปรที่บอกว่าข้อมูลเผยแพร่ไปหรือยัง published=เผยแพร่แล้ว draft=ยังไม่เผยแพร่
          storeIdVersion.value = data.id; //เลข id ใน mongodb

          data.items.map((e: positionEmployeeStatusResponse) => {
            rows.push({
              id: e.id,
              name: e.name,
              createdAt: e.createdAt,
              lastUpdatedAt: e.lastUpdatedAt,
              lastUpdateFullName: e.lastUpdateFullName,
              isActive: e.isActive,
              createdFullName: e.createdFullName,
              createdUserId: e.createdUserId,
              lastUpdateUserId: e.lastUpdateUserId,
            });
          });
        }

        draftPositionEmployeeStatus.value = rows;
        if (loader) {
          dataPositionEmployeeStatus.value = rows;
        }
      })
      .catch((e) => {
        messageError($q, e);
      })
      .finally(() => {
        if (loader) {
          hideLoader();
        }
      });
  };

  return {
    dataPrefix,
    dataInsignia,
    dataInsigniaType,
    dataPositionEmployee,
    dataPositionEmployeeSide,
    dataPositionEmployeeGroup,
    dataPositionEmployeeLine,
    dataPositionEmployeeLevel,
    dataPositionEmployeeStatus,
    storeIdVersion,
    storeVersion,
    manageData,
    getPrefix,
    changeManageCurrentTab,
    changeManageLink,
    changeManageColumns,
    getInsignia,
    getInsigniaType,
    getPositionEmployee,
    getPositionEmployeeSide,
    getPositionEmployeeGroup,
    getPositionEmployeeLine,
    getPositionEmployeeLevel,
    getPositionEmployeeStatus,
  };
});