import {
  Controller,
  Post,
  Put,
  Route,
  Security,
  Tags,
  Body,
  Request,
  SuccessResponse,
  Response,
  Get,
  Query,
} from "tsoa";
import { AppDataSource } from "../database/data-source";
import HttpSuccess from "../interfaces/http-success";
import HttpStatusCode from "../interfaces/http-status";
import HttpError from "../interfaces/http-error";
import { RequestWithUser } from "../middlewares/user";
import { findEndDate, setLogDataDiff } from "../interfaces/utils";
import { Personal } from "../entities/Personal";
import permission from "../interfaces/permission";
import { Assign, CreateAssign } from "../entities/Assign";
import { AssignDirector, CreateAssignDirector } from "../entities/AssignDirector";
import { AssignJob, CreateAssignJob } from "../entities/AssignJob";
import { AssignKnowledge, CreateAssignKnowledge } from "../entities/AssignKnowledge";
import { AssignLaw, CreateAssignLaw } from "../entities/AssignLaw";
import { AssignSkill, CreateAssignSkill } from "../entities/AssignSkill";
import { AssignCompetency, CreateAssignCompetency } from "../entities/AssignCompetency";
import {
  AssignCompetencyGroup,
  CreateAssignCompetencyGroup,
} from "../entities/AssignCompetencyGroup";
import { AssignOutput, CreateAssignOutput } from "../entities/AssignOutput";
import { Law } from "../entities/Law";
import CallAPI from "../interfaces/call-api";

@Route("api/v1/probation/assign")
@Tags("ฟอร์มมอบหมายงาน")
@Security("bearerAuth")
@Response(
  HttpStatusCode.INTERNAL_SERVER_ERROR,
  "เกิดข้อผิดพลาด ไม่สามารถแสดงรายการได้ กรุณาลองใหม่ในภายหลัง",
)
@SuccessResponse(HttpStatusCode.OK, "สำเร็จ")
export class AssignController extends Controller {
  private assignRepository = AppDataSource.getRepository(Assign);
  private personalRepository = AppDataSource.getRepository(Personal);
  private assignDirectorRepository = AppDataSource.getRepository(AssignDirector);
  private assignJobRepository = AppDataSource.getRepository(AssignJob);
  private assignKnowledgeRepository = AppDataSource.getRepository(AssignKnowledge);
  private assignLawRepository = AppDataSource.getRepository(AssignLaw);
  private assignSkillRepository = AppDataSource.getRepository(AssignSkill);
  private assignCompetencyRepository = AppDataSource.getRepository(AssignCompetency);
  private assignCompetencyGroupRepository = AppDataSource.getRepository(AssignCompetencyGroup);
  private assignOutputRepository = AppDataSource.getRepository(AssignOutput);
  private lawsRepository = AppDataSource.getRepository(Law);

  /**
   * API เพิ่มข้อมูลการมอบหมายงาน
   *
   * @summary เพิ่มข้อมูลการมอบหมายงาน
   *
   */
  @Post("")
  async AddAssign(@Request() request: RequestWithUser, @Body() requestBody: CreateAssign) {
    await new permission().PermissionUpdate(request, "SYS_PROBATION");
    const person = await this.personalRepository.findOne({
      where: {
        personal_id: requestBody.personalId,
      },
    });

    if (!person) {
      throw new HttpError(HttpStatusCode.NOT_FOUND, "ไม่พบข้อมูลบุคคล");
    }

    const roundNo = await this.assignRepository.count({
      where: {
        active: 1,
        personal_id: requestBody.personalId,
      },
    });

    const data: any = {
      ...requestBody,
      round_no: roundNo + 1,
      personal_id: requestBody.personalId,
      createdUserId: request.user.sub,
      createdFullName: request.user.name,
      updateUserId: request.user.sub,
      updateFullName: request.user.name,
    };
    const before = null;
    const assign = await this.assignRepository.save(data, { data: request });
    setLogDataDiff(request, { before, after: data });

    const jobs = await requestBody.assign_jobs.map((x: CreateAssignJob, index: number) => ({
      ...x,
      id: index + 1,
      assign_id: assign.id,
      createdUserId: request.user.sub,
      createdFullName: request.user.name,
      updateUserId: request.user.sub,
      updateFullName: request.user.name,
    }));
    await this.assignJobRepository.save(jobs, { data: request });
    setLogDataDiff(request, { before, after: jobs });

    const knowledges = await requestBody.assign_knowledges.map(
      (x: CreateAssignKnowledge, index: number) => ({
        knowledge_level: x.level,
        knowledge_id: x.id,
        assign_id: assign.id,
        createdUserId: request.user.sub,
        createdFullName: request.user.name,
        updateUserId: request.user.sub,
        updateFullName: request.user.name,
      }),
    );
    await this.assignKnowledgeRepository.save(knowledges, { data: request });
    setLogDataDiff(request, { before, after: knowledges });

    const laws = await requestBody.assign_law.map((x: CreateAssignLaw, index: number) => ({
      ordering: index + 1,
      law_id: x.id,
      assign_id: assign.id,
      createdUserId: request.user.sub,
      createdFullName: request.user.name,
      updateUserId: request.user.sub,
      updateFullName: request.user.name,
    }));
    await this.assignLawRepository.save(laws, { data: request });
    setLogDataDiff(request, { before, after: laws });

    const skills = await requestBody.assign_skill.map((x: CreateAssignSkill, index: number) => ({
      skill_id: index + 1,
      skill_level: x.level,
      assign_id: assign.id,
      createdUserId: request.user.sub,
      createdFullName: request.user.name,
      updateUserId: request.user.sub,
      updateFullName: request.user.name,
    }));
    await this.assignSkillRepository.save(skills, { data: request });
    setLogDataDiff(request, { before, after: skills });

    const competencise = await requestBody.assign_competency.map(
      (x: CreateAssignCompetency, index: number) => ({
        competency_id: x.id,
        competency_level: x.level,
        competency_name: x.name,
        competency_description: x.description,
        assign_id: assign.id,
        createdUserId: request.user.sub,
        createdFullName: request.user.name,
        updateUserId: request.user.sub,
        updateFullName: request.user.name,
      }),
    );
    await this.assignCompetencyRepository.save(competencise, { data: request });
    setLogDataDiff(request, { before, after: competencise });

    const competencyGroups = await requestBody.assign_competency_group.map(
      (x: CreateAssignCompetencyGroup, index: number) => ({
        competency_group_id: x.id,
        competency_group_level: x.level,
        competency_group_name: x.name,
        competency_group_description: x.description,
        assign_id: assign.id,
        createdUserId: request.user.sub,
        createdFullName: request.user.name,
        updateUserId: request.user.sub,
        updateFullName: request.user.name,
      }),
    );
    await this.assignCompetencyGroupRepository.save(competencyGroups, {
      data: request,
    });
    setLogDataDiff(request, { before, after: competencyGroups });

    const outputs = await requestBody.assign_outputs.map(
      (x: CreateAssignOutput, index: number) => ({
        ...x,
        id: index + 1,
        assign_id: assign.id,
        createdUserId: request.user.sub,
        createdFullName: request.user.name,
        updateUserId: request.user.sub,
        updateFullName: request.user.name,
      }),
    );
    await this.assignOutputRepository.save(outputs, { data: request });
    setLogDataDiff(request, { before, after: outputs });

    const directors = await requestBody.assign_director.map(
      (x: CreateAssignDirector, index: number) => ({
        ...x,
        assign_id: assign.id,
        fullname: x.name,
        ordering: index + 1,
        createdUserId: request.user.sub,
        createdFullName: request.user.name,
        updateUserId: request.user.sub,
        updateFullName: request.user.name,
      }),
    );
    await this.assignDirectorRepository.save(directors, { data: request });
    setLogDataDiff(request, { before, after: directors });

    return new HttpSuccess();
  }

  /**
   * API แก้ไขข้อมูลการมอบหมายงาน
   *
   * @summary แก้ไขแบบมอบหมายงานการทดลองปฏิบัติหน้าที่ราชการ
   *
   */
  @Put("")
  async EditAssign(
    @Query() assign_id: string,
    @Request() request: RequestWithUser,
    @Body() requestBody: CreateAssign,
  ) {
    await new permission().PermissionUpdate(request, "SYS_PROBATION");

    const assign = await this.assignRepository.findOne({
      where: { id: assign_id },
    });
    let before = assign;

    if (!assign) {
      throw new HttpError(HttpStatusCode.NOT_FOUND, "ไม่พบข้อมูลแบบมอบหมายงาน");
    }

    const person = await this.personalRepository.findOne({
      where: {
        personal_id: requestBody.personalId,
      },
    });

    if (!person) {
      throw new HttpError(HttpStatusCode.NOT_FOUND, "ไม่พบข้อมูลบุคคล");
    }

    const data: any = {
      ...requestBody,
      id: assign_id,
      updateUserId: request.user.sub,
      updateFullName: request.user.name,
    };

    await this.assignJobRepository.delete({ assign_id });
    const jobs = await requestBody.assign_jobs.map((x: CreateAssignJob, index: number) => ({
      ...x,
      id: index + 1,
      assign_id: assign.id,
      createdUserId: request.user.sub,
      createdFullName: request.user.name,
      updateUserId: request.user.sub,
      updateFullName: request.user.name,
    }));
    await this.assignJobRepository.save(jobs);

    await this.assignKnowledgeRepository.delete({ assign_id });
    const knowledges = await requestBody.assign_knowledges.map(
      (x: CreateAssignKnowledge, index: number) => ({
        knowledge_level: x.level,
        knowledge_id: x.id,
        assign_id: assign.id,
        createdUserId: request.user.sub,
        createdFullName: request.user.name,
        updateUserId: request.user.sub,
        updateFullName: request.user.name,
      }),
    );
    await this.assignKnowledgeRepository.save(knowledges);

    await this.assignLawRepository.delete({ assign_id });
    const laws = await requestBody.assign_law.map((x: CreateAssignLaw, index: number) => ({
      ordering: index + 1,
      law_id: x.id,
      assign_id: assign.id,
      createdUserId: request.user.sub,
      createdFullName: request.user.name,
      updateUserId: request.user.sub,
      updateFullName: request.user.name,
    }));
    await this.assignLawRepository.save(laws);

    await this.assignSkillRepository.delete({ assign_id });
    const skills = await requestBody.assign_skill.map((x: CreateAssignSkill, index: number) => ({
      skill_id: index + 1,
      skill_level: x.level,
      assign_id: assign.id,
      createdUserId: request.user.sub,
      createdFullName: request.user.name,
      updateUserId: request.user.sub,
      updateFullName: request.user.name,
    }));
    await this.assignSkillRepository.save(skills);

    await this.assignCompetencyRepository.delete({ assign_id });
    const competencise = await requestBody.assign_competency.map(
      (x: CreateAssignCompetency, index: number) => ({
        competency_id: x.id,
        competency_level: x.level,
        competency_name: x.name,
        competency_description: x.description,
        assign_id: assign.id,
        createdUserId: request.user.sub,
        createdFullName: request.user.name,
        updateUserId: request.user.sub,
        updateFullName: request.user.name,
      }),
    );
    await this.assignCompetencyRepository.save(competencise);

    await this.assignCompetencyGroupRepository.delete({ assign_id });
    const competencyGroups = await requestBody.assign_competency_group.map(
      (x: CreateAssignCompetencyGroup, index: number) => ({
        competency_group_id: x.id,
        competency_group_level: x.level,
        competency_group_name: x.name,
        competency_group_description: x.description,
        assign_id: assign.id,
        createdUserId: request.user.sub,
        createdFullName: request.user.name,
        updateUserId: request.user.sub,
        updateFullName: request.user.name,
      }),
    );
    await this.assignCompetencyGroupRepository.save(competencyGroups);

    await this.assignOutputRepository.delete({ assign_id });
    const outputs = await requestBody.assign_outputs.map(
      (x: CreateAssignOutput, index: number) => ({
        ...x,
        id: index + 1,
        assign_id: assign.id,
        createdUserId: request.user.sub,
        createdFullName: request.user.name,
        updateUserId: request.user.sub,
        updateFullName: request.user.name,
      }),
    );
    await this.assignOutputRepository.save(outputs);

    await this.assignDirectorRepository.delete({ assign_id });
    const directors = await requestBody.assign_director.map(
      (x: CreateAssignDirector, index: number) => ({
        ...x,
        assign_id: assign.id,
        fullname: x.name,
        ordering: index + 1,
        createdUserId: request.user.sub,
        createdFullName: request.user.name,
        updateUserId: request.user.sub,
        updateFullName: request.user.name,
      }),
    );
    await this.assignDirectorRepository.save(directors);

    await this.assignRepository.save(data, { data: request });
    setLogDataDiff(request, { before, after: data });

    // #noted cronjob
    // แจ้งผู้ดูแลและผู้บังคับบัญชาเข้ามาบันทึกผลทุก 2 เดือน
    const dateSaveForm = await findEndDate(2, requestBody.date_start);
    requestBody.assign_director
      .filter((x) => x.role == "mentor" || x.role == "commander")
      .map(async (director) => {
        await new CallAPI()
          .PostData(request, "/placement/noti", {
            subject: `ถึงกำหนดบันทึกผลการทดลองปฏิบัติหน้าที่ราชการครั้งที่ 1 ${requestBody.fullname}`,
            body: `ถึงกำหนดบันทึกผลการทดลองปฏิบัติหน้าที่ราชการครั้งที่ 1 ${requestBody.fullname}`,
            receiverUserId: director.personal_id,
            payload: "",
            isSendMail: true,
            isSendInbox: true,
            receiveDate: dateSaveForm,
          })
          .catch((error) => {
            console.error("Error calling API:", error);
          });
      });

    // แจ้งผู้บังคับบัญชา และคณะกรรมการเข้ามาประเมินทุก 3 เดือน
    const dateEvaluate = await findEndDate(3, requestBody.date_start);
    requestBody.assign_director
      .filter((x) => x.role == "commander" || x.role == "chairman")
      .map(async (director) => {
        await new CallAPI()
          .PostData(request, "/placement/noti", {
            subject: `ถึงกำหนดประเมินผลการทดลองปฏิบัติหน้าที่ราชการครั้งที่ 1 ${requestBody.fullname}`,
            body: `ถึงกำหนดประเมินผลการทดลองปฏิบัติหน้าที่ราชการครั้งที่ 1 ${requestBody.fullname}`,
            receiverUserId: director.personal_id,
            payload: "",
            isSendMail: true,
            isSendInbox: true,
            receiveDate: dateEvaluate,
          })
          .catch((error) => {
            console.error("Error calling API:", error);
          });
      });

    // แจ้งประธาน 6 เดือน
    const dateResult = await findEndDate(6, requestBody.date_start);
    requestBody.assign_director
      .filter((x) => x.role == "chairman")
      .map(async (director) => {
        await new CallAPI()
          .PostData(request, "/placement/noti", {
            subject: `ถึงกำหนดรายงานการประเมินผลการทดลองปฏิบัติหน้าที่ราชการ ${requestBody.fullname}`,
            body: `ถึงกำหนดรายงานการประเมินผลการทดลองปฏิบัติหน้าที่ราชการ ${requestBody.fullname}`,
            receiverUserId: director.personal_id,
            payload: "",
            isSendMail: true,
            isSendInbox: true,
            // isSendNotification: true
            receiveDate: dateResult,
          })
          .catch((error) => {
            console.error("Error calling API:", error);
          });
      });

    return new HttpSuccess();
  }

  /**
   * API รายการข้อมูลการมอบหมายงาน
   *
   * @summary รายการการมอบหมายงาน
   *
   */
  @Get("assign-list")
  async ListPersonal(@Request() request: RequestWithUser, @Query() personal_id: string) {
    await new permission().PermissionGet(request, "SYS_PROBATION");
    const lists = await this.assignRepository.find({
      select: ["id", "round_no", "date_start", "date_finish"],
      where: { personal_id },
      order: { round_no: "ASC" },
    });

    let result: any = [];

    await Promise.all(
      lists.map(async (item) => {
        const director = await this.assignDirectorRepository.find({
          where: { assign_id: item.id },
          order: { ordering: "ASC" },
        });

        let mentors = "";
        const mentorList = await director.filter((x) => x.role == "mentor");
        if (mentorList.length > 0) {
          for (let index = 0; index < mentorList.length; index++) {
            const e = await mentorList[index];
            mentors += e.fullname;
            if (index < mentorList.length - 1) {
              mentors += ", ";
            }
          }
        }

        const commanderData = await (director.find((x) => x.role == "commander") ?? null);
        const commander = commanderData ? commanderData.fullname : null;

        const chairmanData = await (director.find((x) => x.role == "chairman") ?? null);
        const chairman = chairmanData ? chairmanData.fullname : null;

        await result.push({
          ...item,
          mentors: mentors,
          commander: commander,
          chairman: chairman,
        });
      }),
    );

    return new HttpSuccess(result);
  }

  /**
   * API ดึงข้อมูลแบบมอบหมายงานการทดลองปฏิบัติหน้าที่ราชการ
   *
   * @summary ดึงข้อมูลแบบมอบหมายงานการทดลองปฏิบัติหน้าที่ราชการ
   *
   */
  @Get("")
  async GetAssign(@Query() assign_id: string, @Request() request: RequestWithUser) {
    await new permission().PermissionGet(request, "SYS_PROBATION");

    const assign = await this.assignRepository.findOne({
      select: [
        "id",
        "personal_id",
        "appointId",
        "round_no",
        "date_start",
        "date_finish",
        "other_desc",
        "other4_desc",
        "other5_no1_desc",
        "experimenter_dated",
        "active",
        "createdAt",
        "updatedAt",
      ],
      where: { id: assign_id },
    });

    if (!assign) {
      throw new HttpError(HttpStatusCode.NOT_FOUND, "ไม่พบข้อมูลแบบมอบหมายงาน");
    }

    const profileData = await this.personalRepository.findOne({
      select: [
        "personal_id",
        "prefixName",
        "firstName",
        "lastName",
        "positionName",
        "positionLevelName",
        "positionLineName",
        "orgRootName",
        "organization",
      ],
      where: {
        personal_id: assign.personal_id,
      },
    });

    if (!profileData) {
      throw new HttpError(HttpStatusCode.NOT_FOUND, "ไม่พบข้อมูลบุคคล");
    }

    const profile = {
      ...profileData,
      name: `${profileData.prefixName}${profileData.firstName} ${profileData.lastName}`,
      Position: profileData.positionName,
      Department: "-",
      OrganizationOrganization: profileData.orgRootName,
      Oc: profileData.organization,
    };

    const jobs = await this.assignJobRepository.find({
      select: ["id", "activity_desc", "goal_desc"],
      where: { assign_id },
    });

    const knowledgeData = await this.assignKnowledgeRepository.find({
      relations: ["knowledge"],
      where: { assign_id },
    });
    const knowledges = await knowledgeData.map((x) => ({
      id: x.knowledge_id,
      level: x.knowledge_level,
      title: x.knowledge.title,
      description:
        x.knowledge_level == 1
          ? x.knowledge.level1
          : x.knowledge_level == 2
            ? x.knowledge.level2
            : x.knowledge_level == 3
              ? x.knowledge.level3
              : x.knowledge_level == 4
                ? x.knowledge.level4
                : x.knowledge_level == 5
                  ? x.knowledge.level5
                  : "",
    }));

    const lawData = await this.lawsRepository.find({
      where: { active: 1 },
    });

    const laws = await Promise.all(
      lawData.map(async (x) => {
        const assignLaw = await this.assignLawRepository.countBy({
          assign_id: assign_id,
          law_id: x.id,
        });

        return {
          id: x.id,
          selected: assignLaw > 0 ? 1 : 0,
          description: x.description,
          status_select: x.status_select,
        };
      }),
    );

    const skillsData = await this.assignSkillRepository.find({
      relations: ["skill"],
      where: { assign_id },
    });

    const skills = await skillsData.map((x) => ({
      id: x.skill_id,
      level: x.skill_level,
      title: x.skill.title,
      description:
        x.skill_level == 1
          ? x.skill.level1
          : x.skill_level == 2
            ? x.skill.level2
            : x.skill_level == 3
              ? x.skill.level3
              : x.skill_level == 4
                ? x.skill.level4
                : x.skill_level == 5
                  ? x.skill.level5
                  : "",
    }));

    const competencyData = await this.assignCompetencyRepository.find({
      select: ["competency_id", "competency_level", "competency_name", "competency_description"],
      where: { assign_id },
    });

    const competencys = await competencyData.map((x) => ({
      id: x.competency_id,
      level: x.competency_level,
      name: x.competency_name,
      description: x.competency_description,
    }));

    const competencyGroupData = await this.assignCompetencyGroupRepository.find({
      select: [
        "competency_group_id",
        "competency_group_level",
        "competency_group_name",
        "competency_group_description",
      ],
      where: { assign_id },
    });
    const competency_groups = await competencyGroupData.map((x) => ({
      id: x.competency_group_id,
      level: x.competency_group_level,
      name: x.competency_group_name,
      description: x.competency_group_description,
    }));

    const outputs = await this.assignOutputRepository.find({
      select: ["id", "output_desc", "indicator_desc"],
      where: { assign_id },
    });

    const director = await this.assignDirectorRepository.find({
      where: { assign_id },
      order: { ordering: "ASC" },
    });

    let mentors = [];
    const mentorList = await director.filter((x) => x.role == "mentor");
    if (mentorList.length > 0) {
      for (let index = 0; index < mentorList.length; index++) {
        const e = await mentorList[index];
        mentors.push({
          ...e,
          name: e.fullname,
          label:
            e.fullname + " " + (e.position ? `(${e.position}, ${e.posType}: ${e.posLevel})` : ""),
          Position: e.position, // report
        });
      }
    }

    const commanderData = await (director.find((x) => x.role == "commander") ?? null);
    const commander = await (commanderData
      ? {
          ...commanderData,
          name: commanderData.fullname,
          label:
            commanderData.fullname +
            " " +
            (commanderData.position
              ? `(${commanderData.position}, ${commanderData.posType}: ${commanderData.posLevel})`
              : ""),
          Position: commanderData.position, // report
        }
      : null);

    const chairmanData = await (director.find((x) => x.role == "chairman") ?? null);
    const chairman = await (chairmanData
      ? {
          ...chairmanData,
          name: chairmanData.fullname,
          label:
            chairmanData.fullname +
            " " +
            (chairmanData.position
              ? `(${chairmanData.position}, ${chairmanData.posType}: ${chairmanData.posLevel})`
              : ""),
          Position: chairmanData.position, // report
        }
      : null);

    return new HttpSuccess({
      assign,
      profile,
      jobs,
      knowledges,
      laws,
      skills,
      competencys,
      competency_groups,
      outputs,
      mentors,
      commander,
      chairman,
    });
  }
}