import {
  Controller,
  Post,
  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 { setLogDataDiff } from "../interfaces/utils";
import { Personal, PostPersonal } from "../entities/Personal";
import permission from "../interfaces/permission";
import { Assign } from "../entities/Assign";
import { Brackets } from "typeorm";

@Route("api/v1/probation/personal")
@Tags("Personal")
@Security("bearerAuth")
@Response(
  HttpStatusCode.INTERNAL_SERVER_ERROR,
  "เกิดข้อผิดพลาด ไม่สามารถแสดงรายการได้ กรุณาลองใหม่ในภายหลัง",
)
export class PersonalController extends Controller {
  private personalRepository = AppDataSource.getRepository(Personal);
  private assignRepository = AppDataSource.getRepository(Assign);

  /**
   * API ข้อมูลบุคคลในระบบทดลองงาน
   *
   * @summary เพิ่มคนเข้าระบบทดลองงาน
   *
   */
  @Post("add")
  async AddPersonal(@Body() requestBody: PostPersonal, @Request() request: RequestWithUser) {
    try {
      await new permission().PermissionCreate(request, "SYS_PROBATION");

      const checkPersonal: number = await this.personalRepository.count({
        where: { personal_id: requestBody.id },
      });
      if (checkPersonal > 0) {
        throw new HttpError(
          HttpStatusCode.BAD_REQUEST,
          "ผู้ทดลองปฏิบัติหน้าที่ราชการนี้มีอยู่แล้ว",
        );
      }

      let organization = await (requestBody.orgChild4Name ? requestBody.orgChild4Name + "\n" : "");
      organization += await (requestBody.orgChild3Name ? requestBody.orgChild3Name + "\n" : "");
      organization += await (requestBody.orgChild2Name ? requestBody.orgChild2Name + "\n" : "");
      organization += await (requestBody.orgChild1Name ? requestBody.orgChild1Name + "\n" : "");
      organization += await (requestBody.orgRootName ? requestBody.orgRootName : "");

      const personalData = Object.assign(new Personal());
      personalData.personal_id = requestBody.id;
      personalData.order_number = requestBody.order_number ? requestBody.order_number : "";
      personalData.probation_status = 1;
      personalData.createdUserId = request.user.sub;
      personalData.createdFullName = request.user.name;
      personalData.updateUserId = request.user.sub;
      personalData.updateFullName = request.user.name;

      personalData.idcard = requestBody.idcard;
      personalData.prefixName = requestBody.prefix;
      personalData.firstName = requestBody.firstName;
      personalData.lastName = requestBody.lastName;
      personalData.isProbation = requestBody.isProbation ? 1 : 0;
      personalData.positionLevelName = requestBody.posLevelName ? requestBody.posLevelName : "";
      personalData.positionName = requestBody.position ? requestBody.position : "";
      personalData.positionLineName = requestBody.posLineName;
      personalData.positionTypeName = requestBody.posTypeName;
      personalData.posNo = requestBody.posNo ? requestBody.posNo : "";
      personalData.orgRootName = requestBody.orgRootName;
      personalData.organization = organization;

      personalData.root = requestBody.root;
      personalData.child1 = requestBody.child1;
      personalData.child2 = requestBody.child2;
      personalData.child3 = requestBody.child3;
      personalData.child4 = requestBody.child4;

      personalData.rootDna = requestBody.rootDna;
      personalData.child1Dna = requestBody.child1Dna;
      personalData.child2Dna = requestBody.child2Dna;
      personalData.child3Dna = requestBody.child3Dna;
      personalData.child4Dna = requestBody.child4Dna;

      const before = null;
      const personal = await this.personalRepository.save(personalData, {
        data: request,
      });
      setLogDataDiff(request, { before, after: personal });

      return new HttpSuccess();
    } catch (error: any) {
      if (error instanceof HttpError) {
        throw error;
      } else throw new HttpError(HttpStatusCode.INTERNAL_SERVER_ERROR, error);
    }
  }

  /**
   * API รายการบุคคลในระบบทดลองงาน
   *
   * @summary รายชื่อคนที่อยู่ในระบบทดลองงาน
   *
   */
  @Get("list")
  async ListPersonal(
    @Query() status: string = "",
    @Query() keyword: string = "",
    @Query("page") page: number = 1,
    @Query("pageSize") pageSize: number = 10,
    @Request() request: RequestWithUser,
  ) {
    try {
      await new permission().PermissionList(request, "SYS_PROBATION");
      const _data = await new permission().PermissionOrgList(request, "SYS_PROBATION");

      const conditions: any = {};
      if (status) {
        conditions.probation_status = status;
      }

      if (_data.root != undefined && _data.root != null && _data.root[0] != null) {
        conditions.root = _data.root;
      }

      if (_data.child1 != undefined && _data.child1 != null && _data.child1[0] != null) {
        conditions.child1 = _data.child1;
      }

      if (_data.child2 != undefined && _data.child2 != null && _data.child2[0] != null) {
        conditions.child2 = _data.child2;
      }

      if (_data.child3 != undefined && _data.child3 != null && _data.child3[0] != null) {
        conditions.child3 = _data.child3;
      }

      if (_data.child4 != undefined && _data.child4 != null && _data.child4[0] != null) {
        conditions.child4 = _data.child4;
      }

      const searchKeyword = await (keyword ? keyword.trim() : null);

      const [lists, total] = await AppDataSource.getRepository(Personal)
        .createQueryBuilder("personal")
        .where(conditions)
        .andWhere(
          new Brackets((qb) => {
            qb.orWhere(
              searchKeyword
                ? `CONCAT(prefixName, firstName," ",lastName)  like '%${keyword}%'`
                : "1=1",
              {
                keyword: `%${searchKeyword}%`,
              },
            );
            qb.orWhere(searchKeyword ? `positionName  like '%${keyword}%'` : "1=1", {
              keyword: `%${searchKeyword}%`,
            });
            qb.orWhere(searchKeyword ? `positionLevelName  like '%${keyword}%'` : "1=1", {
              keyword: `%${searchKeyword}%`,
            });
            qb.orWhere(searchKeyword ? `organization  like '%${keyword}%'` : "1=1", {
              keyword: `%${searchKeyword}%`,
            });
            qb.orWhere(searchKeyword ? `order_number  like '%${keyword}%'` : "1=1", {
              keyword: `%${searchKeyword}%`,
            });
          }),
        )
        .orderBy("updatedAt", "DESC")
        .skip((page - 1) * pageSize)
        .take(pageSize)
        .getManyAndCount();

      if (!lists) {
        throw new HttpError(HttpStatusCode.INTERNAL_SERVER_ERROR, "ไม่สามารถแสดงข้อมูลได้");
      }

      let result: any = [];

      for (let i = 0; i < lists.length; i++) {
        const probation_no = await this.assignRepository.count({
          where: { personal_id: lists[i].personal_id },
        });

        await result.push({
          personal_id: lists[i].personal_id,
          ordering: i + 1,
          name: lists[i].prefixName + lists[i].firstName + " " + lists[i].lastName,
          prefixName: lists[i].prefixName,
          firstName: lists[i].firstName,
          lastName: lists[i].lastName,
          idcard: lists[i].idcard,
          position_line: lists[i].positionName,
          position_level: lists[i].positionLevelName,
          position_type: lists[i].positionTypeName,
          organization: lists[i].organization,
          probation_no: probation_no,
          order_number: lists[i].order_number,
          probation_status: lists[i].probation_status,
        });
      }
      // await Promise.all(
      //   lists.map(async (item, index) => {
      //     const probation_no = await this.assignRepository.count({
      //       where: {
      //         personal_id: item.personal_id,
      //       },
      //     });

      //     await result.push({
      //       personal_id: item.personal_id,
      //       ordering: index + 1,
      //       name: item.prefixName + item.firstName + " " + item.lastName,
      //       idcard: item.idcard,
      //       // prefixName: item.prefixName,
      //       // firstName: item.firstName,
      //       // lastName: item.lastName,
      //       position_line: item.positionName,
      //       position_level: item.positionLevelName,
      //       position_type: item.positionTypeName,
      //       organization: item.organization,
      //       probation_no: probation_no,
      //       order_number: item.order_number,
      //       probation_status: item.probation_status,
      //     });
      //   }),
      // );

      return new HttpSuccess({ data: result, total: total });
    } catch (error: any) {
      if (error instanceof HttpError) {
        throw error;
      } else throw new HttpError(HttpStatusCode.INTERNAL_SERVER_ERROR, error);
    }
  }

  /**
   * API ข้อมูลบุคคลในระบบทดลองงาน
   *
   * @summary ข้อมูลคนที่อยูาในระบบทดลองงาน
   *
   */
  @Get("")
  async GetPersonal(@Request() request: RequestWithUser, @Query() personal_id: string) {
    try {
      let _workflow = await new permission().Workflow(request, personal_id, "SYS_PROBATION");
      if (_workflow == false) await new permission().PermissionGet(request, "SYS_PROBATION");
      const person = await this.personalRepository.findOne({
        where: { personal_id: personal_id },
      });

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

      const probation_no = await this.assignRepository.count({
        where: { personal_id: person.personal_id },
      });

      const result = await {
        personal_id: person.personal_id,
        name: person.prefixName + person.firstName + " " + person.lastName,
        position_line: person.positionName,
        position_level: person.positionLevelName,
        position_type: person.positionTypeName,
        organization: person.organization,
        probation_no: probation_no,
        order_number: person.order_number,
        probation_status: person.probation_status,
      };

      return new HttpSuccess(result);
    } catch (error: any) {
      if (error instanceof HttpError) {
        throw error;
      } else throw new HttpError(HttpStatusCode.INTERNAL_SERVER_ERROR, error);
    }
  }
}