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, "เกิดข้อผิดพลาด ไม่สามารถแสดงรายการได้ กรุณาลองใหม่ในภายหลัง")
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) {
		let _workflow = await new permission().Workflow(request, personal_id, "SYS_PROBATION")
		if (_workflow == false) 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) {
		let _workflow = await new permission().Workflow(request, assign_id, "SYS_PROBATION")
		if (_workflow == false) 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",
				"reportPersonId"
			],
			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,
		})
	}
}