import z from "zod";
import type {
	NewPotenziali,
	PotenzialiId,
	PotenzialiUpdate,
} from "~/schemas/public/Potenziali";
import type { PotenzialiGroupsId } from "~/schemas/public/PotenzialiGroups";
import { adminProcedure, createTRPCRouter } from "~/server/api/trpc";
import {
	addPotenziale,
	addPotenzialeGroup,
	deletePotenziale,
	deletePotenzialeGroup,
	getPotenziali,
	getPotenzialiGroups,
	type PotenzialeData,
	updatePotenziale,
	updatePotenziali,
} from "~/server/services/potenziali.service";

const zPotenzialiId = z.custom<PotenzialiId>(
	(val) => typeof val === "string" && val.length > 0,
	{ message: "Invalid PotenzialiId" },
);

const zNewPotenziali = z.custom<NewPotenziali>(
	(val) => {
		return typeof val === "object" && val !== null;
	},
	{ message: "Invalid NewPotenziali" },
);

const zPotenzialiUpdate = z.custom<PotenzialiUpdate>(
	(val) => {
		return typeof val === "object" && val !== null;
	},
	{ message: "Invalid PotenzialiUpdate" },
);

const zPotenzialiGroupId = z.custom<PotenzialiGroupsId>(
	(val) => typeof val === "string" && val.length > 0,
	{ message: "Invalid PotenzialiGroupsId" },
);

export const potenzialiRouter = createTRPCRouter({
	getPotenziali: adminProcedure.query(async () => {
		return await getPotenziali();
	}),
	getPotenzialiGroups: adminProcedure.query(async () => {
		return await getPotenzialiGroups();
	}),
	addPotenziale: adminProcedure
		.input(
			z.object({
				data: zNewPotenziali,
			}),
		)
		.mutation(async ({ input }) => {
			return await addPotenziale(input.data);
		}),
	updatePotenziali: adminProcedure
		.input(
			z.object({
				data: z.custom<PotenzialeData[]>(),
			}),
		)
		.mutation(async ({ input }) => {
			return await updatePotenziali(input.data);
		}),
	updatePotenziale: adminProcedure
		.input(
			z.object({
				potenzialiId: zPotenzialiId,
				data: zPotenzialiUpdate,
			}),
		)
		.mutation(async ({ input }) => {
			return await updatePotenziale(input.potenzialiId, input.data);
		}),
	deletePotenziale: adminProcedure
		.input(
			z.object({
				potenzialiId: zPotenzialiId,
			}),
		)
		.mutation(async ({ input }) => {
			return await deletePotenziale(input.potenzialiId);
		}),

	addPotenzialeGroup: adminProcedure
		.input(
			z.object({
				name: z.string().min(1).max(255),
			}),
		)
		.mutation(async ({ input }) => {
			return await addPotenzialeGroup({ name: input.name });
		}),

	deletePotenzialeGroup: adminProcedure
		.input(
			z.object({
				potenzialiGroupId: zPotenzialiGroupId,
			}),
		)
		.mutation(async ({ input }) => {
			return await deletePotenzialeGroup(input.potenzialiGroupId);
		}),
});
