import { eq, inArray, type Database } from "@pkg/db";
import { passengerInfo, passengerPII } from "@pkg/db/schema";
import { getError, Logger } from "@pkg/logger";
import { ERROR_CODES, type Result } from "@pkg/result";
import {
	passengerInfoModel,
	type CustomerInfoModel,
	type PassengerInfo,
} from "./entities";

export class PassengerInfoRepository {
	private db: Database;

	constructor(db: Database) {
		this.db = db;
	}

	async createPassengerPii(
		payload: CustomerInfoModel,
	): Promise<Result<number>> {
		try {
			const out = await this.db
				.insert(passengerPII)
				.values({
					firstName: payload.firstName,
					middleName: payload.middleName,
					lastName: payload.lastName,
					email: payload.email,
					phoneCountryCode: payload.phoneCountryCode,
					phoneNumber: payload.phoneNumber,
					nationality: payload.nationality,
					gender: payload.gender,
					dob: payload.dob,
					passportNo: payload.passportNo,
					passportExpiry: payload.passportExpiry,

					country: payload.country,
					state: payload.state,
					city: payload.city,
					address: payload.address,
					zipCode: payload.zipCode,
					address2: payload.address2,

					createdAt: new Date(),
					updatedAt: new Date(),
				})
				.returning({ id: passengerInfo.id })
				.execute();

			if (!out || out.length === 0) {
				Logger.error("Failed to create passenger info");
				Logger.debug(out);
				Logger.debug(payload);
				return {
					error: getError({
						code: ERROR_CODES.INTERNAL_SERVER_ERROR,
						message: "Failed to create passenger info",
						userHint: "Please try again",
						detail: "Failed to create passenger info",
					}),
				};
			}
			return { data: out[0].id };
		} catch (e) {
			return {
				error: getError(
					{
						code: ERROR_CODES.INTERNAL_SERVER_ERROR,
						message: "An error occured while creating passenger info",
						userHint: "Please try again later",
						actionable: false,
						detail: "An error occured while creating passenger info",
					},
					e,
				),
			};
		}
	}

	async createPassengerInfo(payload: PassengerInfo): Promise<Result<number>> {
		try {
			const out = await this.db
				.insert(passengerInfo)
				.values({
					passengerType: payload.passengerType,
					passengerPiiId: payload.passengerPiiId,
					paymentInfoId: payload.paymentInfoId,
					seatSelection: payload.seatSelection,
					bagSelection: payload.bagSelection,
					agentsInfo: payload.agentsInfo,

					flightTicketInfoId: payload.flightTicketInfoId,
					orderId: payload.orderId,

					createdAt: new Date(),
					updatedAt: new Date(),
				})
				.returning({ id: passengerInfo.id })
				.execute();

			if (!out || out.length === 0) {
				Logger.error("Failed to create passenger info");
				Logger.debug(out);
				Logger.debug(payload);
				return {
					error: getError({
						code: ERROR_CODES.INTERNAL_SERVER_ERROR,
						message: "Failed to create passenger info",
						userHint: "Please try again",
						detail: "Failed to create passenger info",
					}),
				};
			}
			return { data: out[0].id };
		} catch (e) {
			return {
				error: getError(
					{
						code: ERROR_CODES.INTERNAL_SERVER_ERROR,
						message: "An error occured while creating passenger info",
						userHint: "Please try again later",
						actionable: false,
						detail: "An error occured while creating passenger info",
					},
					e,
				),
			};
		}
	}

	async getPassengerInfo(id: number): Promise<Result<PassengerInfo>> {
		try {
			const out = await this.db.query.passengerInfo.findFirst({
				where: eq(passengerInfo.id, id),
				with: { passengerPii: true },
			});
			if (!out) {
				Logger.error("Failed to get passenger info");
				Logger.debug(out);
				return {
					error: getError({
						code: ERROR_CODES.INTERNAL_SERVER_ERROR,
						message: "Failed to get passenger info",
						userHint: "Please try again",
						detail: "Failed to get passenger info",
					}),
				};
			}
			return { data: out as any as PassengerInfo };
		} catch (e) {
			return {
				error: getError(
					{
						code: ERROR_CODES.INTERNAL_SERVER_ERROR,
						message: "An error occured while getting passenger info",
						userHint: "Please try again later",
						actionable: false,
						detail: "An error occured while getting passenger info",
					},
					e,
				),
			};
		}
	}

	async getPassengerInfosByRefOId(
		refOIds: number[],
	): Promise<Result<PassengerInfo[]>> {
		try {
			const out = await this.db.query.passengerInfo.findMany({
				where: inArray(passengerInfo.orderId, refOIds),
				with: { passengerPii: true },
			});
			const res = [] as PassengerInfo[];
			for (const each of out) {
				const parsed = passengerInfoModel.safeParse(each);
				if (!parsed.success) {
					Logger.warn(`Error while parsing passenger info`);
					Logger.debug(parsed.error?.errors);
					continue;
				}
				res.push(parsed.data);
			}
			Logger.info(`Returning ${res.length} passenger info by ref OID`);
			return { data: res };
		} catch (e) {
			return {
				error: getError(
					{
						code: ERROR_CODES.INTERNAL_SERVER_ERROR,
						message: "An error occured while getting passenger info",
						userHint: "Please try again later",
						actionable: false,
						detail: "An error occured while getting passenger info",
					},
					e,
				),
			};
		}
	}

	async deleteAll(ids: number[]): Promise<Result<number>> {
		Logger.info(`Deleting ${ids.length} passenger info`);
		const out = await this.db
			.delete(passengerInfo)
			.where(inArray(passengerInfo.id, ids));
		Logger.debug(out);
		Logger.info(`Deleted ${out.count} passenger info`);
		return { data: out.count };
	}
}