import { TRPCError } from "@trpc/server";
import { z } from "zod/v4";
import { env } from "~/env.mjs";
import type { BannersIdbanner } from "~/schemas/public/Banners";
import {
	adminProcedure,
	createTRPCRouter,
	publicProcedure,
} from "~/server/api/trpc";
import {
	addEtichetta,
	getAllEtichette,
	removeEtichetta,
	updateEtichetta,
} from "~/server/controllers/etichette.controller";
import {
	AddFlagHandler,
	EditFlagHandler,
	GetFlagHandler,
	GetFlagValueHandler,
	RemoveFlagHandler,
} from "~/server/controllers/flags.controller";
import { db } from "~/server/db";
import {
	addBanner,
	deleteBanner,
	getAllBanners,
	getBanner,
	updateBanner,
} from "~/server/services/banners.service";
import {
	deleteStringa,
	getStringa,
	getStringhe,
	getStringheFiltered,
	newStringa,
	updateStringhe,
} from "~/server/services/testi_stringhe.service";
import {
	zEtichettaId,
	zFlagsId,
	zTestiEStringheStingaId,
} from "~/server/utils/zod_types";

export const settingsRouter = createTRPCRouter({
	AddFlag: adminProcedure
		.input(
			z.object({
				id: zFlagsId,
				value: z.string(),
			}),
		)
		.mutation(async ({ input }) => {
			return await AddFlagHandler({ db, input });
		}),
	addBanner: adminProcedure
		.input(
			z.object({
				color: z.string().nullable(),
				cta_href: z.string().nullable(),
				cta_icon: z.string().nullable(),
				cta_text: z.string().nullable(),
				has_cta: z.boolean(),
				hide_duration: z.number().nullable(),
				idbanner: z.custom<BannersIdbanner>(),
				is_active: z.boolean(),
				is_unskippable: z.boolean(),
				show_private: z.boolean(),
				show_public: z.boolean(),
				testo: z.string().nullable(),
				titolo: z.string().nullable(),
			}),
		)
		.mutation(async ({ input }) => {
			return await addBanner({ db, input });
		}),
	addEtichetta: adminProcedure
		.input(
			z.object({
				color_hex: z.string().max(7),
				title: z.string(),
			}),
		)
		.mutation(async ({ input }) => {
			return await addEtichetta({
				color_hex: input.color_hex,
				db,
				title: input.title,
			});
		}),
	deleteBanner: adminProcedure
		.input(z.object({ idbanner: z.custom<BannersIdbanner>() }))
		.mutation(async ({ input }) => {
			return await deleteBanner({ db, input });
		}),
	deleteStringa: adminProcedure
		.input(
			z.object({
				stringaId: zTestiEStringheStingaId,
			}),
		)
		.mutation(async ({ input }) => {
			return await deleteStringa({
				db,
				stringaId: input.stringaId,
			});
		}),

	EditFlag: adminProcedure
		.input(
			z.object({
				id: zFlagsId,
				value: z.string(),
			}),
		)
		.mutation(async ({ input }) => {
			return await EditFlagHandler({ db, input });
		}),
	// Flags routes
	GetFlags: adminProcedure.query(async () => {
		return await GetFlagHandler({ db });
	}),

	GetFlagValue: publicProcedure
		.input(z.object({ id: z.string() }))
		.query(async ({ input }) => {
			return await GetFlagValueHandler({ db, id: input.id });
		}),

	// Etichette routes
	getAllEtichette: adminProcedure.query(async () => {
		return await getAllEtichette({ db });
	}),
	getBannerAllData: publicProcedure.query(async () => {
		return await getAllBanners({ db });
	}),
	// Banner routes
	getBannerData: publicProcedure
		.input(
			z.object({
				area_riservata: z.boolean(),
			}),
		)
		.query(async ({ input }) => {
			return await getBanner({
				area_riservata: input.area_riservata,
				db,
			});
		}),
	getStringa: publicProcedure
		.input(
			z.object({
				stringaId: zTestiEStringheStingaId,
			}),
		)
		.query(async ({ input }) => {
			return await getStringa({
				db,
				stringaId: input.stringaId,
			});
		}),

	// Testi e stringhe routes
	getStringhe: adminProcedure.query(async () => {
		return await getStringhe({ db });
	}),
	getStringheCondizioni: adminProcedure.query(async () => {
		return await getStringheFiltered({ contains: "CONDIZIONI", db });
	}),
	newStringa: adminProcedure
		.input(
			z.object({
				stringaId: zTestiEStringheStingaId,
				stringaValue: z.string().nullable(),
			}),
		)
		.mutation(async ({ input }) => {
			return await newStringa({
				db,
				stringaId: input.stringaId,
				stringaValue: input.stringaValue,
			});
		}),
	RemoveFlag: adminProcedure

		.input(
			z.object({
				id: zFlagsId,
			}),
		)
		.mutation(async ({ input }) => {
			return await RemoveFlagHandler({ db, id: input.id });
		}),
	removeEtichetta: adminProcedure
		.input(z.object({ id_etichetta: zEtichettaId }))
		.mutation(async ({ input }) => {
			return await removeEtichetta({
				db,
				etichettaid: input.id_etichetta,
			});
		}),
	updateBanner: adminProcedure
		.input(
			z.object({
				color: z.string().nullable(),
				cta_href: z.string().nullable(),
				cta_icon: z.string().nullable(),
				cta_text: z.string().nullable(),
				has_cta: z.boolean(),
				hide_duration: z.number().nullable(),
				idbanner: z.custom<BannersIdbanner>(),
				is_active: z.boolean(),
				is_unskippable: z.boolean(),
				show_private: z.boolean(),
				show_public: z.boolean(),
				testo: z.string().nullable(),
				titolo: z.string().nullable(),
			}),
		)
		.mutation(async ({ input }) => {
			return await updateBanner({ db, input });
		}),
	updateEtichetta: adminProcedure
		.input(
			z.object({
				color_hex: z.string().max(7),
				id_etichetta: zEtichettaId,
				title: z.string(),
			}),
		)
		.mutation(async ({ input }) => {
			return await updateEtichetta({
				color_hex: input.color_hex,
				db,
				etichettaid: input.id_etichetta,
				title: input.title,
			});
		}),
	updateStringa: adminProcedure
		.input(
			z.object({
				stringaId: zTestiEStringheStingaId,
				stringaValue: z.string().nullable(),
			}),
		)
		.mutation(async ({ input }) => {
			return await updateStringhe({
				db,
				stringaId: input.stringaId,
				stringaValue: input.stringaValue,
			});
		}),

	revalidateAllAnnunci: adminProcedure.mutation(async () => {
		try {
			const response = await fetch(`${env.BACKENDSERVER_URL}/update`);

			if (!response.ok) {
				const errorData = await response.text().catch(() => "Unknown error");
				throw new Error(
					`Revalidation failed with status ${response.status}: ${errorData}`,
				);
			}

			const data = await response.json().catch(() => ({}));
			return {
				status: "success",
				details: data,
			};
		} catch (err) {
			console.error("Revalidation error:", err);
			throw new TRPCError({
				code: "INTERNAL_SERVER_ERROR",
				message: err instanceof Error ? err.message : "Revalidation failed",
				cause: err,
			});
		}
	}),
	revalidateAnnuncio: adminProcedure
		.input(
			z.object({
				cod: z.string(),
			}),
		)
		.mutation(async ({ input }) => {
			try {
				const response = await fetch(
					`${env.BACKENDSERVER_URL}/update-cod/${input.cod}`,
				);

				if (!response.ok) {
					const errorData = await response.text().catch(() => "Unknown error");
					throw new Error(
						`Revalidation failed with status ${response.status}: ${errorData}`,
					);
				}

				const data = await response.json().catch(() => ({}));
				return {
					status: "success",
					details: data,
				};
			} catch (err) {
				console.error("Revalidation error:", err);
				throw new TRPCError({
					code: "INTERNAL_SERVER_ERROR",
					message: err instanceof Error ? err.message : "Revalidation failed",
					cause: err,
				});
			}
		}),
});