import authHandler from "@App/middlewares/AuthHandler";
import roleHandler from "@App/middlewares/RolesHandler";
import ApiController from "@Common/system/controller-pattern/ApiController";
import { Controller, Post } from "@ControllerPattern/index";
import { EAppointmentStatus } from "@prisma/client";
import AppointmentService from "@Services/super-admin/AppointmentsService/AppointmentsService";
import LiveVoteService from "@Services/super-admin/LiveVoteService/LiveVoteService";
import UsersService from "@Services/super-admin/UsersService/UsersService";
import VotesService from "@Services/super-admin/VotesService/VotesService";
import { validateOrReject } from "class-validator";
import { Request, Response } from "express";
import { Vote } from "le-coffre-resources/dist/SuperAdmin";
import { Service } from "typedi";

@Controller()
@Service()
export default class LiveVoteController extends ApiController {
	constructor(
		private liveVoteService: LiveVoteService,
		private votesService: VotesService,
		private usersService: UsersService,
		private appointmentService: AppointmentService,
	) {
		super();
	}

	/**
	 * @description Create a new vote
	 */
	@Post("/api/v1/super-admin/live-votes", [authHandler, roleHandler])
	protected async post(req: Request, response: Response) {
		try {
			const userId = req.body.user.userId;
			//init IUser resource with request body values
			const voteEntity = Vote.hydrate<Vote>(req.body);
			//validate user
			await validateOrReject(voteEntity, { groups: ["createVote"] });

			let voteFound = [];
			if (voteEntity.appointment.uid) {
				const appointment = await this.appointmentService.getByUid(voteEntity.appointment.uid);
				if (!appointment) {
					this.httpNotFoundRequest(response, "Appointment not found");
					return;
				}
				if (appointment.status === EAppointmentStatus.CLOSED) {
					this.httpBadRequest(response, "Appointment is closed");
					return;
				}
				voteFound = await this.votesService.get({
					where: { AND: [{ appointment: { uid: voteEntity.appointment.uid } }, { voter: { uid: userId } }] },
				});
			} else {
				voteFound = await this.votesService.get({
					where: {
						AND: [
							{
								appointment: {
									AND: [{ user_uid: voteEntity.appointment.targeted_user.uid }, { status: EAppointmentStatus.OPEN }],
								},
							},
							{ voter: { uid: userId } },
						],
					},
				});
			}

			if (voteFound.length) {
				this.httpBadRequest(response, "Voter already voted for this appointment");
				return;
			}

			const voter = await this.usersService.getByUid(userId);

			voteEntity.voter = voter!;
			//call service to get prisma entity
			const voteEntityCreated = await this.liveVoteService.create(voteEntity);

			if (!voteEntityCreated) {
				this.httpBadRequest(response, "Appointment choice is not valid");
				return;
			}
			//Hydrate ressource with prisma entity
			const vote = Vote.hydrate<Vote>(voteEntityCreated, {
				strategy: "excludeAll",
			});

			//success
			this.httpCreated(response, vote);
		} catch (error) {
			this.httpInternalError(response, error);
			return;
		}
	}
}