import amqp from "amqplib";
import { AppDataSource } from "../database/data-source";
import { Command } from "../entities/Command";
import { commandTypePath } from "../interfaces/utils";
import CallAPI from "../interfaces/call-api";
import HttpError from "../interfaces/http-error";
import HttpStatusCode from "../interfaces/http-status";
import { RequestWithUser } from "../middlewares/user";
import { PosMaster } from "../entities/PosMaster";
import { Profile } from "../entities/Profile";
import { EmployeePosMaster } from "../entities/EmployeePosMaster";
import { EmployeeTempPosMaster } from "../entities/EmployeeTempPosMaster";
import { ProfileEmployee } from "../entities/ProfileEmployee";
import { OrgRevision } from "../entities/OrgRevision";
import { request } from "http";
import { EmployeePosition } from "../entities/EmployeePosition";
import { OrgChild1 } from "../entities/OrgChild1";
import { OrgChild2 } from "../entities/OrgChild2";
import { OrgChild3 } from "../entities/OrgChild3";
import { OrgChild4 } from "../entities/OrgChild4";
import { OrgRoot } from "../entities/OrgRoot";

export let sendToQueue: (payload: any) => void;
export let sendToQueueOrg: (payload: any) => void;
export async function init() {
  //----> (1) Producer
  if (!process.env.AMQ_URL || !process.env.AMQ_QUEUE || !process.env.AMQ_QUEUE_ORG) return;

  const { AMQ_URL: url, AMQ_QUEUE: queue, AMQ_QUEUE_ORG: queue_org } = process.env; //----> (1.2) get url and queue from .env

  const connection = await amqp.connect(url); //----> (1.3) set up url with amqp protocol

  console.log(connection ? "[AMQ] Connection success" : "[AMQ] Connection failed");

  const channel = await connection.createChannel(); //----> (1.4) create Channel

  console.log(channel ? "[AMQ] Create channel success" : "[AMQ] Create channel failed");

  channel.assertQueue(queue, { durable: true }), //----> (1.5) assert queue and set durable (if "true" save to disk on RabbitMQ)
    channel.assertQueue(queue_org, { durable: true }),
    channel.prefetch(1);

  sendToQueue = (payload: any, persistent = true) => {
    //----> (2) sendQueue To RabbitMQ and set persistent (if "true" redo the failed queue when server run again)
    channel.sendToQueue(queue, Buffer.from(JSON.stringify(payload)), {
      persistent,
    });
  };

  sendToQueueOrg = (payload: any, persistent = true) => {
    channel.sendToQueue(queue_org, Buffer.from(JSON.stringify(payload)), { persistent });
  };

  console.log("[AMQ] Listening for message...");
  createConsumer(queue, channel, handler), //----> (3) Process Consumer
    createConsumer(queue_org, channel, handler_org);
  // createConsumer(queue2, channel, handler2);
}

let retries = 0;

function createConsumer( //----> consumer
  queue: string,
  channel: amqp.Channel,
  handler: (msg: amqp.ConsumeMessage) => Promise<boolean> | boolean,
) {
  channel.consume(
    queue,
    async (msg) => {
      if (!msg) return;
      if ((await handler(msg)) || retries++ >= 3) {
        retries = 0;
        console.log("[AMQ] Process Consumer success");
        return channel.ack(msg);
      }
      console.log("[AMQ] Process Consumer failed");
      return await new Promise((resolve) => setTimeout(() => resolve(channel.nack(msg)), 3000));
    },
    { noAck: false },
  );
}

async function handler(msg: amqp.ConsumeMessage): Promise<boolean> {
  //----> condition before process consumer
  const repo = AppDataSource.getRepository(Command);
  const { data, token, user } = JSON.parse(msg.content.toString());
  const { id, status, lastUpdateUserId, lastUpdateFullName, lastUpdatedAt } = data;
  const command = await repo.findOne({
    where: { id: id },
    relations: ["commandType", "commandRecives"],
  });
  if (!command) return true;
  const path = commandTypePath(command.commandType.code);
  if (path == null) throw new HttpError(HttpStatusCode.NOT_FOUND, "ไม่พบประเภทคำสั่งนี้ในระบบ");
  return await new CallAPI()

    .PostData(
      {
        headers: { authorization: token },
      },
      path + "/excecute",
      {
        refIds: command.commandRecives
          .filter((x) => x.refId != null)
          .map((x) => ({
            refId: x.refId,
            commandNo: command.commandNo,
            commandYear: command.commandYear,
            commandId: command.id,
            remark: command.positionDetail,
            amount: x.amount,
            amountSpecial: x.amountSpecial,
            positionSalaryAmount: x.positionSalaryAmount,
            mouthSalaryAmount: x.mouthSalaryAmount,
            commandCode: command.commandType.commandCode,
            commandName: command.commandType.name,
            commandDateAffect: command.commandExcecuteDate,
            commandDateSign: command.commandAffectDate,
          })),
      },
      false,
    )
    .then(async (res) => {
      console.log("[AMQ] Excecute Command Success");
      Object.assign(command, { status, lastUpdateUserId, lastUpdateFullName, lastUpdatedAt });
      const result = await repo.save(command).catch((e) => console.log(e));
      if (result) return true;
      return false;
    })
    .catch((e) => {
      console.error(e);
      return false;
    });
}

async function handler_org(msg: amqp.ConsumeMessage): Promise<boolean> {
  //----> condition before process consume
  const repoPosmaster = AppDataSource.getRepository(PosMaster);
  const repoEmployeePosmaster = AppDataSource.getRepository(EmployeePosMaster);
  const repoEmployeeTempPosmaster = AppDataSource.getRepository(EmployeeTempPosMaster);
  const repoProfile = AppDataSource.getRepository(Profile);
  const repoProfileEmployee = AppDataSource.getRepository(ProfileEmployee);
  const employeePositionRepository = AppDataSource.getRepository(EmployeePosition);
  const repoOrgRevision = AppDataSource.getRepository(OrgRevision);
  const orgRootRepository = AppDataSource.getRepository(OrgRoot);
  const child1Repository = AppDataSource.getRepository(OrgChild1);
  const child2Repository = AppDataSource.getRepository(OrgChild2);
  const child3Repository = AppDataSource.getRepository(OrgChild3);
  const child4Repository = AppDataSource.getRepository(OrgChild4);

  const orgRevisionPublish = await repoOrgRevision
    .createQueryBuilder("orgRevision")
    .where("orgRevision.orgRevisionIsDraft = false")
    .andWhere("orgRevision.orgRevisionIsCurrent = true")
    .getOne();

  const orgRevisionDraft = await repoOrgRevision
    .createQueryBuilder("orgRevision")
    .where("orgRevision.orgRevisionIsDraft = true")
    .andWhere("orgRevision.orgRevisionIsCurrent = false")
    .getOne();
  if (orgRevisionPublish) {
    orgRevisionPublish.orgRevisionIsDraft = false;
    orgRevisionPublish.orgRevisionIsCurrent = false;
    await repoOrgRevision.save(orgRevisionPublish);
  }
  if (orgRevisionDraft) {
    orgRevisionDraft.orgRevisionIsCurrent = true;
    orgRevisionDraft.orgRevisionIsDraft = false;
    await repoOrgRevision.save(orgRevisionDraft);
  }

  const { data, token, user } = JSON.parse(msg.content.toString());
  const { id, status, lastUpdateUserId, lastUpdateFullName, lastUpdatedAt } = data;
  try {
    const posMaster = await repoPosmaster.find({
      where: { orgRevisionId: id },
      relations: [
        "orgRoot",
        "orgChild4",
        "orgChild3",
        "orgChild2",
        "orgChild1",
        "positions",
        "positions.posLevel",
        "positions.posType",
        "positions.posExecutive",
      ],
    });
    for (const item of posMaster) {
      if (item.next_holderId != null && status == "NOW") {
        const profile = await repoProfile.findOne({
          where: { id: item.next_holderId == null ? "" : item.next_holderId },
        });
        const position = await item.positions.find((x) => x.positionIsSelected == true);
        const _null: any = null;
        if (profile != null) {
          profile.posLevelId = position?.posLevelId ?? _null;
          profile.posTypeId = position?.posTypeId ?? _null;
          profile.position = position?.positionName ?? _null;
          await repoProfile.save(profile);
        }
      }
      item.current_holderId = item.next_holderId;
      item.next_holderId = null;
      item.lastUpdateUserId = lastUpdateUserId;
      item.lastUpdateFullName = lastUpdateFullName;
      item.lastUpdatedAt = lastUpdatedAt;
      await repoPosmaster.save(item).catch((e) => console.log(e));
    }
    console.log(orgRevisionPublish);
    console.log("zzzzzzzzzzzzzzzz");
    if (orgRevisionPublish != null) {
      console.log("cccccccccccccccccccccc");
      //new main revision
      const before = null;

      //cone tree
      // if (
      //   orgRevisionPublish.typeDraft.toUpperCase() == "ORG" ||
      //   orgRevisionPublish.typeDraft.toUpperCase() == "ORG_POSITION" ||
      //   orgRevisionPublish.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
      //   orgRevisionPublish.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
      //   orgRevisionPublish.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
      // ) {
      //หา dna tree
      const orgRoot = await orgRootRepository.find({
        where: { orgRevisionId: orgRevisionPublish.id },
      });

      const orgChild1 = await child1Repository.find({
        where: { orgRevisionId: orgRevisionPublish.id },
      });

      const orgChild2 = await child2Repository.find({
        where: { orgRevisionId: orgRevisionPublish.id },
      });

      const orgChild3 = await child3Repository.find({
        where: { orgRevisionId: orgRevisionPublish.id },
      });

      const orgChild4 = await child4Repository.find({
        where: { orgRevisionId: orgRevisionPublish.id },
      });

      console.log("xxxxxxxxxxxxxxxxxxx");
      //หา dna posmaster ถ้าไม่มีให้เอาตัวเองเป็น dna
      const orgemployeePosMaster = await repoEmployeePosmaster.find({
        where: { orgRevisionId: orgRevisionPublish.id },
        relations: ["positions"],
      });

      console.log("vvvvvvvvvvvvvvvvvvv");
      let _orgemployeePosMaster: EmployeePosMaster[];
      //   if (
      //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
      //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
      //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
      //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
      //   ) {
      _orgemployeePosMaster = orgemployeePosMaster.map((x) => ({
        ...x,
        ancestorDNA:
          x.ancestorDNA == null || x.ancestorDNA == "00000000-0000-0000-0000-000000000000"
            ? x.id
            : x.ancestorDNA,
      }));
      console.log("aaaaaaaaaaaaaaaaaa");
      await repoEmployeePosmaster.save(_orgemployeePosMaster);
      console.log("sssssssssssssss");
      //   }
      //หา dna posmaster ถ้าไม่มีให้เอาตัวเองเป็น dna
      const orgemployeeTempPosMaster = await repoEmployeeTempPosmaster.find({
        where: { orgRevisionId: orgRevisionPublish.id },
        relations: ["positions"],
      });

      console.log("ddddddddddddddddf");
      let _orgemployeeTempPosMaster: EmployeeTempPosMaster[];
      //   if (
      //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
      //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
      //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
      //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
      //   ) {
      _orgemployeeTempPosMaster = orgemployeeTempPosMaster.map((x) => ({
        ...x,
        ancestorDNA:
          x.ancestorDNA == null || x.ancestorDNA == "00000000-0000-0000-0000-000000000000"
            ? x.id
            : x.ancestorDNA,
      }));
      console.log("ffffffffffffffffff");
      await repoEmployeeTempPosmaster.save(_orgemployeeTempPosMaster);
      console.log("gggggggggggggggggg");
      //   }

      //create org
      orgRoot.forEach(async (x: any) => {
        console.log("qqqqqqqqqqqqqqqqq");
        var dataId = x.id;
        // if (
        //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
        //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
        //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
        //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
        // ) {
        //create employeePosmaster
        await Promise.all(
          _orgemployeePosMaster
            .filter((x: EmployeePosMaster) => x.orgRootId == dataId && x.orgChild1Id == null)
            .map(async (item: any) => {
              console.log("ttttttttttttttttttttt");
              delete item.id;
              const employeePosMaster = Object.assign(new EmployeePosMaster(), item);
              employeePosMaster.positions = [];
              // if (
              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
              // ) {
              //   employeePosMaster.current_holderId = item.current_holderId;
              // } else {
              //   // employeePosMaster.next_holderId = null;
              //   employeePosMaster.isSit = false;
              // }
              // if (
              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
              // ) {
              //   employeePosMaster.authRoleId = item.authRoleId;
              // } else {
              //   employeePosMaster.authRoleId = null;
              // }
              //   employeePosMaster.current_holderId = null;
              employeePosMaster.orgRevisionId = orgRevisionPublish.id;
              employeePosMaster.orgRootId = dataId;
              employeePosMaster.createdUserId = "";
              employeePosMaster.createdFullName = "System Administrator";
              employeePosMaster.createdAt = new Date();
              employeePosMaster.lastUpdateUserId = "";
              employeePosMaster.lastUpdateFullName = "System Administrator";
              employeePosMaster.lastUpdatedAt = new Date();
              await repoEmployeePosmaster.save(employeePosMaster);

              //create employeePosition
              item.positions.map(async (pos: any) => {
                delete pos.id;
                const employeePosition: EmployeePosition = Object.assign(
                  new EmployeePosition(),
                  pos,
                );
                employeePosition.posMasterId = employeePosMaster.id;
                //   if (
                //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                //   ) {
                //     employeePosition.positionIsSelected = false;
                //   }
                employeePosition.createdUserId = "";
                employeePosition.createdFullName = "System Administrator";
                employeePosition.createdAt = new Date();
                employeePosition.lastUpdateUserId = "";
                employeePosition.lastUpdateFullName = "System Administrator";
                employeePosition.lastUpdatedAt = new Date();
                await employeePositionRepository.save(employeePosition);
              });
            }),
        );
        //create employeeTempPosmaster
        await Promise.all(
          _orgemployeeTempPosMaster
            .filter((x: EmployeeTempPosMaster) => x.orgRootId == dataId && x.orgChild1Id == null)
            .map(async (item: any) => {
              delete item.id;
              const employeeTempPosMaster = Object.assign(new EmployeeTempPosMaster(), item);
              employeeTempPosMaster.positions = [];
              // if (
              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
              // ) {
              //   employeeTempPosMaster.current_holderId = item.current_holderId;
              // } else {
              //   // employeeTempPosMaster.next_holderId = null;
              //   employeeTempPosMaster.isSit = false;
              // }
              // if (
              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
              // ) {
              //   employeeTempPosMaster.authRoleId = item.authRoleId;
              // } else {
              //   employeeTempPosMaster.authRoleId = null;
              // }
              //   employeeTempPosMaster.current_holderId = null;
              employeeTempPosMaster.orgRevisionId = orgRevisionPublish.id;
              employeeTempPosMaster.orgRootId = dataId;
              employeeTempPosMaster.createdUserId = "";
              employeeTempPosMaster.createdFullName = "System Administrator";
              employeeTempPosMaster.createdAt = new Date();
              employeeTempPosMaster.lastUpdateUserId = "";
              employeeTempPosMaster.lastUpdateFullName = "System Administrator";
              employeeTempPosMaster.lastUpdatedAt = new Date();
              await repoEmployeeTempPosmaster.save(employeeTempPosMaster);

              //create employeePosition
              item.positions.map(async (pos: any) => {
                delete pos.id;
                const employeePosition: EmployeePosition = Object.assign(
                  new EmployeePosition(),
                  pos,
                );
                //   employeePosition.posMasterTempId = employeeTempPosMaster.id;
                //   if (
                //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                //   ) {
                //     employeePosition.positionIsSelected = false;
                //   }
                employeePosition.createdUserId = "";
                employeePosition.createdFullName = "System Administrator";
                employeePosition.createdAt = new Date();
                employeePosition.lastUpdateUserId = "";
                employeePosition.lastUpdateFullName = "System Administrator";
                employeePosition.lastUpdatedAt = new Date();
                await employeePositionRepository.save(employeePosition);
              });
            }),
        );
        // }

        //create org
        orgChild1
          .filter((x: OrgChild1) => x.orgRootId == dataId)
          .forEach(async (x: any) => {
            var data1Id = x.id;
            // if (
            //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
            //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
            //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
            //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
            // ) {
            //create employeePosmaster
            await Promise.all(
              _orgemployeePosMaster
                .filter((x: EmployeePosMaster) => x.orgChild1Id == data1Id && x.orgChild2Id == null)
                .map(async (item: any) => {
                  delete item.id;
                  const employeePosMaster = Object.assign(new EmployeePosMaster(), item);
                  employeePosMaster.positions = [];
                  // if (
                  //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                  //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                  // ) {
                  //   employeePosMaster.current_holderId = item.current_holderId;
                  // } else {
                  //   // employeePosMaster.next_holderId = null;
                  //   employeePosMaster.isSit = false;
                  // }
                  // if (
                  //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                  //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                  // ) {
                  //   employeePosMaster.authRoleId = item.authRoleId;
                  // } else {
                  //   employeePosMaster.authRoleId = null;
                  // }
                  //   employeePosMaster.current_holderId = null;
                  employeePosMaster.orgRevisionId = orgRevisionPublish.id;
                  employeePosMaster.orgRootId = dataId;
                  employeePosMaster.orgChild1Id = data1Id;
                  employeePosMaster.createdUserId = "";
                  employeePosMaster.createdFullName = "System Administrator";
                  employeePosMaster.createdAt = new Date();
                  employeePosMaster.lastUpdateUserId = "";
                  employeePosMaster.lastUpdateFullName = "System Administrator";
                  employeePosMaster.lastUpdatedAt = new Date();
                  await repoEmployeePosmaster.save(employeePosMaster);

                  //create employeePosition
                  item.positions.map(async (pos: any) => {
                    delete pos.id;
                    const employeePosition: EmployeePosition = Object.assign(
                      new EmployeePosition(),
                      pos,
                    );
                    employeePosition.posMasterId = employeePosMaster.id;
                    //   if (
                    //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                    //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                    //   ) {
                    //     employeePosition.positionIsSelected = false;
                    //   }
                    employeePosition.createdUserId = "";
                    employeePosition.createdFullName = "System Administrator";
                    employeePosition.createdAt = new Date();
                    employeePosition.lastUpdateUserId = "";
                    employeePosition.lastUpdateFullName = "System Administrator";
                    employeePosition.lastUpdatedAt = new Date();
                    await employeePositionRepository.save(employeePosition);
                  });
                }),
            );
            // create employeeTempPosmaster
            await Promise.all(
              _orgemployeeTempPosMaster
                .filter(
                  (x: EmployeeTempPosMaster) => x.orgChild1Id == data1Id && x.orgChild2Id == null,
                )
                .map(async (item: any) => {
                  delete item.id;
                  const employeeTempPosMaster = Object.assign(new EmployeeTempPosMaster(), item);
                  employeeTempPosMaster.positions = [];
                  // if (
                  //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                  //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                  // ) {
                  //   employeeTempPosMaster.current_holderId = item.current_holderId;
                  // } else {
                  //   // employeeTempPosMaster.next_holderId = null;
                  //   employeeTempPosMaster.isSit = false;
                  // }
                  // if (
                  //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                  //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                  // ) {
                  //   employeeTempPosMaster.authRoleId = item.authRoleId;
                  // } else {
                  //   employeeTempPosMaster.authRoleId = null;
                  // }
                  //   employeeTempPosMaster.current_holderId = null;
                  employeeTempPosMaster.orgRevisionId = orgRevisionPublish.id;
                  employeeTempPosMaster.orgRootId = dataId;
                  employeeTempPosMaster.orgChild1Id = data1Id;
                  employeeTempPosMaster.createdUserId = "";
                  employeeTempPosMaster.createdFullName = "System Administrator";
                  employeeTempPosMaster.createdAt = new Date();
                  employeeTempPosMaster.lastUpdateUserId = "";
                  employeeTempPosMaster.lastUpdateFullName = "System Administrator";
                  employeeTempPosMaster.lastUpdatedAt = new Date();
                  await repoEmployeeTempPosmaster.save(employeeTempPosMaster);

                  //create employeePosition
                  item.positions.map(async (pos: any) => {
                    delete pos.id;
                    const employeePosition: EmployeePosition = Object.assign(
                      new EmployeePosition(),
                      pos,
                    );
                    employeePosition.posMasterTempId = employeeTempPosMaster.id;
                    //   if (
                    //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                    //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                    //   ) {
                    //     employeePosition.positionIsSelected = false;
                    //   }
                    employeePosition.createdUserId = "";
                    employeePosition.createdFullName = "System Administrator";
                    employeePosition.createdAt = new Date();
                    employeePosition.lastUpdateUserId = "";
                    employeePosition.lastUpdateFullName = "System Administrator";
                    employeePosition.lastUpdatedAt = new Date();
                    await employeePositionRepository.save(employeePosition);
                  });
                }),
            );
            // }

            //create org
            orgChild2
              .filter((x: OrgChild2) => x.orgChild1Id == data1Id)
              .forEach(async (x: any) => {
                var data2Id = x.id;
                // if (
                //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                // ) {
                //create employeePosmaster
                await Promise.all(
                  _orgemployeePosMaster
                    .filter(
                      (x: EmployeePosMaster) => x.orgChild2Id == data2Id && x.orgChild3Id == null,
                    )
                    .map(async (item: any) => {
                      delete item.id;
                      const employeePosMaster = Object.assign(new EmployeePosMaster(), item);
                      employeePosMaster.positions = [];
                      // if (
                      //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                      //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                      // ) {
                      //   employeePosMaster.current_holderId = item.current_holderId;
                      // } else {
                      //   // employeePosMaster.next_holderId = null;
                      //   employeePosMaster.isSit = false;
                      // }
                      // if (
                      //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                      //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                      // ) {
                      //   employeePosMaster.authRoleId = item.authRoleId;
                      // } else {
                      //   employeePosMaster.authRoleId = null;
                      // }
                      //   employeePosMaster.current_holderId = null;
                      employeePosMaster.orgRevisionId = orgRevisionPublish.id;
                      employeePosMaster.orgRootId = dataId;
                      employeePosMaster.orgChild1Id = data1Id;
                      employeePosMaster.orgChild2Id = data2Id;
                      employeePosMaster.createdUserId = "";
                      employeePosMaster.createdFullName = "System Administrator";
                      employeePosMaster.createdAt = new Date();
                      employeePosMaster.lastUpdateUserId = "";
                      employeePosMaster.lastUpdateFullName = "System Administrator";
                      employeePosMaster.lastUpdatedAt = new Date();
                      await repoEmployeePosmaster.save(employeePosMaster);

                      //create employeePosition
                      item.positions.map(async (pos: any) => {
                        delete pos.id;
                        const employeePosition: EmployeePosition = Object.assign(
                          new EmployeePosition(),
                          pos,
                        );
                        employeePosition.posMasterId = employeePosMaster.id;
                        //   if (
                        //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                        //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                        //   ) {
                        //     employeePosition.positionIsSelected = false;
                        //   }
                        employeePosition.createdUserId = "";
                        employeePosition.createdFullName = "System Administrator";
                        employeePosition.createdAt = new Date();
                        employeePosition.lastUpdateUserId = "";
                        employeePosition.lastUpdateFullName = "System Administrator";
                        employeePosition.lastUpdatedAt = new Date();
                        await employeePositionRepository.save(employeePosition);
                      });
                    }),
                );
                // create employeeTempPosmaster
                await Promise.all(
                  _orgemployeeTempPosMaster
                    .filter(
                      (x: EmployeeTempPosMaster) =>
                        x.orgChild2Id == data2Id && x.orgChild3Id == null,
                    )
                    .map(async (item: any) => {
                      delete item.id;
                      const employeeTempPosMaster = Object.assign(
                        new EmployeeTempPosMaster(),
                        item,
                      );
                      employeeTempPosMaster.positions = [];
                      // if (
                      //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                      //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                      // ) {
                      //   employeeTempPosMaster.current_holderId = item.current_holderId;
                      // } else {
                      //   // employeeTempPosMaster.next_holderId = null;
                      //   employeeTempPosMaster.isSit = false;
                      // }
                      // if (
                      //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                      //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                      // ) {
                      //   employeeTempPosMaster.authRoleId = item.authRoleId;
                      // } else {
                      //   employeeTempPosMaster.authRoleId = null;
                      // }
                      //   employeeTempPosMaster.current_holderId = null;
                      employeeTempPosMaster.orgRevisionId = orgRevisionPublish.id;
                      employeeTempPosMaster.orgRootId = dataId;
                      employeeTempPosMaster.orgChild1Id = data1Id;
                      employeeTempPosMaster.orgChild2Id = data2Id;
                      employeeTempPosMaster.createdUserId = "";
                      employeeTempPosMaster.createdFullName = "System Administrator";
                      employeeTempPosMaster.createdAt = new Date();
                      employeeTempPosMaster.lastUpdateUserId = "";
                      employeeTempPosMaster.lastUpdateFullName = "System Administrator";
                      employeeTempPosMaster.lastUpdatedAt = new Date();
                      await repoEmployeeTempPosmaster.save(employeeTempPosMaster);

                      //create employeePosition
                      item.positions.map(async (pos: any) => {
                        delete pos.id;
                        const employeePosition: EmployeePosition = Object.assign(
                          new EmployeePosition(),
                          pos,
                        );
                        employeePosition.posMasterTempId = employeeTempPosMaster.id;
                        //   if (
                        //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                        //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                        //   ) {
                        //     employeePosition.positionIsSelected = false;
                        //   }
                        employeePosition.createdUserId = "";
                        employeePosition.createdFullName = "System Administrator";
                        employeePosition.createdAt = new Date();
                        employeePosition.lastUpdateUserId = "";
                        employeePosition.lastUpdateFullName = "System Administrator";
                        employeePosition.lastUpdatedAt = new Date();
                        await employeePositionRepository.save(employeePosition);
                      });
                    }),
                );
                // }

                //create org
                orgChild3
                  .filter((x: OrgChild3) => x.orgChild2Id == data2Id)
                  .forEach(async (x: any) => {
                    var data3Id = x.id;
                    // if (
                    //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                    //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                    //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                    //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                    // ) {
                    //create employeePosmaster
                    await Promise.all(
                      _orgemployeePosMaster
                        .filter(
                          (x: EmployeePosMaster) =>
                            x.orgChild3Id == data3Id && x.orgChild4Id == null,
                        )
                        .map(async (item: any) => {
                          delete item.id;
                          const employeePosMaster = Object.assign(new EmployeePosMaster(), item);
                          employeePosMaster.positions = [];
                          // if (
                          //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                          //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                          // ) {
                          //   employeePosMaster.current_holderId = item.current_holderId;
                          // } else {
                          //   // employeePosMaster.next_holderId = null;
                          //   employeePosMaster.isSit = false;
                          // }
                          // if (
                          //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                          //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                          // ) {
                          //   employeePosMaster.authRoleId = item.authRoleId;
                          // } else {
                          //   employeePosMaster.authRoleId = null;
                          // }
                          //   employeePosMaster.current_holderId = null;
                          employeePosMaster.orgRevisionId = orgRevisionPublish.id;
                          employeePosMaster.orgRootId = dataId;
                          employeePosMaster.orgChild1Id = data1Id;
                          employeePosMaster.orgChild2Id = data2Id;
                          employeePosMaster.orgChild3Id = data3Id;
                          employeePosMaster.createdUserId = "";
                          employeePosMaster.createdFullName = "System Administrator";
                          employeePosMaster.createdAt = new Date();
                          employeePosMaster.lastUpdateUserId = "";
                          employeePosMaster.lastUpdateFullName = "System Administrator";
                          employeePosMaster.lastUpdatedAt = new Date();
                          await repoEmployeePosmaster.save(employeePosMaster);

                          //create employeePosition
                          item.positions.map(async (pos: any) => {
                            delete pos.id;
                            const employeePosition: EmployeePosition = Object.assign(
                              new EmployeePosition(),
                              pos,
                            );
                            employeePosition.posMasterId = employeePosMaster.id;
                            //   if (
                            //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                            //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                            //   ) {
                            //     employeePosition.positionIsSelected = false;
                            //   }
                            employeePosition.createdUserId = "";
                            employeePosition.createdFullName = "System Administrator";
                            employeePosition.createdAt = new Date();
                            employeePosition.lastUpdateUserId = "";
                            employeePosition.lastUpdateFullName = "System Administrator";
                            employeePosition.lastUpdatedAt = new Date();
                            await employeePositionRepository.save(employeePosition);
                          });
                        }),
                    );
                    // create employeeTempPosmaster
                    await Promise.all(
                      _orgemployeeTempPosMaster
                        .filter(
                          (x: EmployeeTempPosMaster) =>
                            x.orgChild3Id == data3Id && x.orgChild4Id == null,
                        )
                        .map(async (item: any) => {
                          delete item.id;
                          const employeeTempPosMaster = Object.assign(
                            new EmployeeTempPosMaster(),
                            item,
                          );
                          employeeTempPosMaster.positions = [];
                          // if (
                          //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                          //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                          // ) {
                          //   employeeTempPosMaster.current_holderId = item.current_holderId;
                          // } else {
                          //   // employeeTempPosMaster.next_holderId = null;
                          //   employeeTempPosMaster.isSit = false;
                          // }
                          // if (
                          //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                          //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                          // ) {
                          //   employeeTempPosMaster.authRoleId = item.authRoleId;
                          // } else {
                          //   employeeTempPosMaster.authRoleId = null;
                          // }
                          //   employeeTempPosMaster.current_holderId = null;
                          employeeTempPosMaster.orgRevisionId = orgRevisionPublish.id;
                          employeeTempPosMaster.orgRootId = dataId;
                          employeeTempPosMaster.orgChild1Id = data1Id;
                          employeeTempPosMaster.orgChild2Id = data2Id;
                          employeeTempPosMaster.orgChild3Id = data3Id;
                          employeeTempPosMaster.createdUserId = "";
                          employeeTempPosMaster.createdFullName = "System Administrator";
                          employeeTempPosMaster.createdAt = new Date();
                          employeeTempPosMaster.lastUpdateUserId = "";
                          employeeTempPosMaster.lastUpdateFullName = "System Administrator";
                          employeeTempPosMaster.lastUpdatedAt = new Date();
                          await repoEmployeeTempPosmaster.save(employeeTempPosMaster);

                          //create employeePosition
                          item.positions.map(async (pos: any) => {
                            delete pos.id;
                            const employeePosition: EmployeePosition = Object.assign(
                              new EmployeePosition(),
                              pos,
                            );
                            employeePosition.posMasterTempId = employeeTempPosMaster.id;
                            //   if (
                            //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                            //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                            //   ) {
                            //     employeePosition.positionIsSelected = false;
                            //   }
                            employeePosition.createdUserId = "";
                            employeePosition.createdFullName = "System Administrator";
                            employeePosition.createdAt = new Date();
                            employeePosition.lastUpdateUserId = "";
                            employeePosition.lastUpdateFullName = "System Administrator";
                            employeePosition.lastUpdatedAt = new Date();
                            await employeePositionRepository.save(employeePosition);
                          });
                        }),
                    );
                    // }

                    //create org
                    orgChild4
                      .filter((x: OrgChild4) => x.orgChild3Id == data3Id)
                      .forEach(async (x: any) => {
                        var data4Id = x.id;
                        // if (
                        //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                        //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                        //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                        //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                        // ) {
                        //create employeePosmaster
                        await Promise.all(
                          _orgemployeePosMaster
                            .filter((x: EmployeePosMaster) => x.orgChild4Id == data4Id)
                            .map(async (item: any) => {
                              delete item.id;
                              const employeePosMaster = Object.assign(
                                new EmployeePosMaster(),
                                item,
                              );
                              employeePosMaster.positions = [];
                              // if (
                              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                              // ) {
                              //   employeePosMaster.current_holderId = item.current_holderId;
                              // } else {
                              //   // employeePosMaster.next_holderId = null;
                              //   employeePosMaster.isSit = false;
                              // }
                              // if (
                              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                              // ) {
                              //   employeePosMaster.authRoleId = item.authRoleId;
                              // } else {
                              //   employeePosMaster.authRoleId = null;
                              // }
                              //   employeePosMaster.current_holderId = null;
                              employeePosMaster.orgRevisionId = orgRevisionPublish.id;
                              employeePosMaster.orgRootId = dataId;
                              employeePosMaster.orgChild1Id = data1Id;
                              employeePosMaster.orgChild2Id = data2Id;
                              employeePosMaster.orgChild3Id = data3Id;
                              employeePosMaster.orgChild4Id = data4Id;
                              employeePosMaster.createdUserId = "";
                              employeePosMaster.createdFullName = "System Administrator";
                              employeePosMaster.createdAt = new Date();
                              employeePosMaster.lastUpdateUserId = "";
                              employeePosMaster.lastUpdateFullName = "System Administrator";
                              employeePosMaster.lastUpdatedAt = new Date();
                              await repoEmployeePosmaster.save(employeePosMaster);

                              //create employeePosition
                              item.positions.map(async (pos: any) => {
                                delete pos.id;
                                const employeePosition: EmployeePosition = Object.assign(
                                  new EmployeePosition(),
                                  pos,
                                );
                                employeePosition.posMasterId = employeePosMaster.id;
                                //   if (
                                //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                                //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                                //   ) {
                                //     employeePosition.positionIsSelected = false;
                                //   }
                                employeePosition.createdUserId = "";
                                employeePosition.createdFullName = "System Administrator";
                                employeePosition.createdAt = new Date();
                                employeePosition.lastUpdateUserId = "";
                                employeePosition.lastUpdateFullName = "System Administrator";
                                employeePosition.lastUpdatedAt = new Date();
                                await employeePositionRepository.save(employeePosition);
                              });
                            }),
                        );
                        //create employeeTempPosmaster
                        await Promise.all(
                          _orgemployeeTempPosMaster
                            .filter((x: EmployeeTempPosMaster) => x.orgChild4Id == data4Id)
                            .map(async (item: any) => {
                              delete item.id;
                              const employeeTempPosMaster = Object.assign(
                                new EmployeeTempPosMaster(),
                                item,
                              );
                              employeeTempPosMaster.positions = [];
                              // if (
                              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON" ||
                              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                              // ) {
                              //   employeeTempPosMaster.current_holderId = item.current_holderId;
                              // } else {
                              //   // employeeTempPosMaster.next_holderId = null;
                              //   employeeTempPosMaster.isSit = false;
                              // }
                              // if (
                              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE" ||
                              //   requestBody.typeDraft.toUpperCase() == "ORG_POSITION_PERSON_ROLE"
                              // ) {
                              //   employeeTempPosMaster.authRoleId = item.authRoleId;
                              // } else {
                              //   employeeTempPosMaster.authRoleId = null;
                              // }
                              //   employeeTempPosMaster.current_holderId = null;
                              employeeTempPosMaster.orgRevisionId = orgRevisionPublish.id;
                              employeeTempPosMaster.orgRootId = dataId;
                              employeeTempPosMaster.orgChild1Id = data1Id;
                              employeeTempPosMaster.orgChild2Id = data2Id;
                              employeeTempPosMaster.orgChild3Id = data3Id;
                              employeeTempPosMaster.orgChild4Id = data4Id;
                              employeeTempPosMaster.createdUserId = "";
                              employeeTempPosMaster.createdFullName = "System Administrator";
                              employeeTempPosMaster.createdAt = new Date();
                              employeeTempPosMaster.lastUpdateUserId = "";
                              employeeTempPosMaster.lastUpdateFullName = "System Administrator";
                              employeeTempPosMaster.lastUpdatedAt = new Date();
                              await repoEmployeeTempPosmaster.save(employeeTempPosMaster);

                              //create employeePosition
                              item.positions.map(async (pos: any) => {
                                delete pos.id;
                                const employeePosition: EmployeePosition = Object.assign(
                                  new EmployeePosition(),
                                  pos,
                                );
                                employeePosition.posMasterTempId = employeeTempPosMaster.id;
                                //   if (
                                //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION" ||
                                //     requestBody.typeDraft.toUpperCase() == "ORG_POSITION_ROLE"
                                //   ) {
                                //     employeePosition.positionIsSelected = false;
                                //   }
                                employeePosition.createdUserId = "";
                                employeePosition.createdFullName = "System Administrator";
                                employeePosition.createdAt = new Date();
                                employeePosition.lastUpdateUserId = "";
                                employeePosition.lastUpdateFullName = "System Administrator";
                                employeePosition.lastUpdatedAt = new Date();
                                await employeePositionRepository.save(employeePosition);
                              });
                            }),
                        );
                        // }
                      });
                  });
              });
          });
      });
      // }

      const employeePosMaster = await repoEmployeePosmaster.find({
        where: { orgRevisionId: orgRevisionPublish.id },
        relations: ["positions", "positions.posLevel", "positions.posType"],
      });
      for (const item of employeePosMaster) {
        if (item.next_holderId != null && status == "NOW") {
          const profile = await repoProfileEmployee.findOne({
            where: { id: item.next_holderId == null ? "" : item.next_holderId },
          });
          const position = await item.positions.find((x) => x.positionIsSelected == true);
          const _null: any = null;
          if (profile != null) {
            profile.posLevelId = position?.posLevelId ?? _null;
            profile.posTypeId = position?.posTypeId ?? _null;
            profile.position = position?.positionName ?? _null;
            await repoProfileEmployee.save(profile);
          }
        }
        // item.current_holderId = item.next_holderId;
        // item.next_holderId = null;
        item.lastUpdateUserId = lastUpdateUserId;
        item.lastUpdateFullName = lastUpdateFullName;
        item.lastUpdatedAt = lastUpdatedAt;
        await repoEmployeePosmaster.save(item).catch((e) => console.log(e));
      }
      const employeeTempPosMaster = await repoEmployeeTempPosmaster.find({
        where: { orgRevisionId: orgRevisionPublish.id },
        relations: ["positions", "positions.posLevel", "positions.posType"],
      });
      for (const item of employeeTempPosMaster) {
        if (item.next_holderId != null && status == "NOW") {
          const profile = await repoProfileEmployee.findOne({
            where: { id: item.next_holderId == null ? "" : item.next_holderId },
          });
          const position = await item.positions.find((x) => x.positionIsSelected == true);
          const _null: any = null;
          if (profile != null) {
            profile.posLevelId = position?.posLevelId ?? _null;
            profile.posTypeId = position?.posTypeId ?? _null;
            profile.position = position?.positionName ?? _null;
            await repoProfileEmployee.save(profile);
          }
        }
        // item.current_holderId = item.next_holderId;
        // item.next_holderId = null;
        item.lastUpdateUserId = lastUpdateUserId;
        item.lastUpdateFullName = lastUpdateFullName;
        item.lastUpdatedAt = lastUpdatedAt;
        await repoEmployeeTempPosmaster.save(item).catch((e) => console.log(e));
      }
    }
    console.log("[AMQ] Excecute Organization Success");
    return true;
  } catch (error) {
    console.error(error);
    return false;
  }
}