import { eq } from "drizzle-orm";
import { Hono } from "hono";
import { z } from "zod";
import db from "../../drizzle";
import { respondents } from "../../drizzle/schema/respondents";
import { assessments } from "../../drizzle/schema/assessments";
import { users } from "../../drizzle/schema/users";
import { rolesToUsers } from "../../drizzle/schema/rolesToUsers";
import { rolesSchema } from "../../drizzle/schema/roles";
import HonoEnv from "../../types/HonoEnv";
import authInfo from "../../middlewares/authInfo";
import { notFound } from "../../errors/DashboardError";
import checkPermission from "../../middlewares/checkPermission";
import requestValidator from "../../utils/requestValidator";
import { HTTPException } from "hono/http-exception";
import { createId } from "@paralleldrive/cuid2";

const assessmentRequestRoute = new Hono<HonoEnv>()
    .use(authInfo)

    // Get assessment request by user ID
    .get(
        "/:id",
        checkPermission("assessmentRequest.read"),
        requestValidator(
            "query",
            z.object({
                includeTrashed: z.string().default("false"),
            })
        ),
        async (c) => {
            const userId = c.req.param("id");

            const queryResult = await db
                .select({
                    userId: users.id,
                    createdAt: assessments.createdAt,
                    name: users.name,
                    code: rolesSchema.code,
                    status: assessments.status,
                })
                .from(users)
                .leftJoin(rolesToUsers, eq(users.id, rolesToUsers.userId))
                .leftJoin(rolesSchema, eq(rolesToUsers.roleId, rolesSchema.id))
                .leftJoin(respondents, eq(users.id, respondents.userId))
                .leftJoin(assessments, eq(respondents.id, assessments.respondentId))
                .where(eq(users.id, userId));

            if (!queryResult[0]) throw notFound();

            const assessmentRequestData = {
                ...queryResult,
            };

            return c.json(assessmentRequestData);
        }
    )

    // Post assessment request by user ID
    .post(
        "/:id",
        checkPermission("assessmentRequest.create"),
        requestValidator(
            "json",
            z.object({
                respondentId: z.string().min(1),
            })
        ),
        async (c) => {
            const { respondentId } = c.req.valid("json");
            const userId = c.req.param("id");

            // Make sure the userId exists
            if (!userId) {
                throw new HTTPException(400, { message: "User ID is required." });
            }

            // Validate if respondent exists
            const respondent = await db
                .select()
                .from(respondents)
                .where(eq(respondents.id, respondentId));

            if (!respondent.length) {
                throw new HTTPException(404, { message: "Respondent not found." });
            }

            // Create the assessment request
            const newAssessment = await db
                .insert(assessments)
                .values({
                    id: createId(),
                    respondentId,
                    status: "menunggu konfirmasi",
                    validatedBy: null,
                    validatedAt: null,
                    createdAt: new Date(),
                })
                .returning();

            return c.json({ message: "Successfully submitted the assessment request" }, 201);
        }
    );

export default assessmentRequestRoute;