import { Maximize2, MoreVertical, Plus, Trash2 } from "lucide-react";
import type { GetServerSideProps } from "next";
import { useState } from "react";
import toast from "react-hot-toast";
import { EmailAccordion } from "~/components/area-riservata/comunicazioni";
import { Confirm } from "~/components/confirm";
import { AreaRiservataLayoutUserView } from "~/components/Layout";
import { Button } from "~/components/ui/button";
import {
	Dialog,
	DialogContent,
	DialogDescription,
	DialogHeader,
	DialogTitle,
	DialogTrigger,
} from "~/components/ui/dialog";
import { Label } from "~/components/ui/label";
import {
	Popover,
	PopoverContent,
	PopoverTrigger,
} from "~/components/ui/popover";
import { Switch } from "~/components/ui/switch";
import { FormEditQueueMail } from "~/forms/FormEditQueueMail";
import { FormAddCodaEmail } from "~/forms/FormNewMail";
import type { NextPageWithLayout } from "~/pages/_app";
import { useEnforcedSession } from "~/providers/SessionProvider";
import type { UsersId } from "~/schemas/public/Users";
import type { Email_EventData } from "~/server/controllers/event_queue.controller";

import { TrpcAuthedFetchingIstance } from "~/server/utils/ssgHelper";
import { zUserId } from "~/server/utils/zod_types";
import { api } from "~/utils/api";

type ComunicazioniUserProps = {
	userId: UsersId;
};

/**
 * Pagina di visualizzazione comunicazioni per admin: /area-riservata/admin/user-view/comunicazioni/[userId]
 */
const ComunicazioniUser: NextPageWithLayout<ComunicazioniUserProps> = ({
	userId,
}: ComunicazioniUserProps) => {
	const { user } = useEnforcedSession();
	const utils = api.useUtils();
	const { mutate } = api.comunicazioni.deleteAllUserEmails.useMutation({
		onError: (error) => {
			console.error(error);
			toast.error("Errore durante l'eliminazione delle comunicazioni");
		},
		onSuccess: async () => {
			toast.success("Comunicazioni eliminate");
			await utils.comunicazioni.getEmails.invalidate({ userId });
		},
	});

	return (
		<main className="flex flex-1 flex-col items-start gap-4">
			<div className="flex w-full items-center justify-between">
				<h3 className="font-bold text-2xl">Comunicazioni</h3>
				<Popover>
					<PopoverTrigger asChild>
						<Button size="sm">
							<MoreVertical />
						</Button>
					</PopoverTrigger>
					<PopoverContent
						align="end"
						className="flex w-fit flex-col items-center gap-4 p-2"
					>
						<Confirm
							description="Sei sicuro di voler eliminare tutte le comunicazioni?"
							onConfirm={() => {
								mutate({ userId });
							}}
							title="Elimina tutte le comunicazioni"
						>
							<Button
								aria-label="Delete Comunicazioni"
								className="w-full"
								size="sm"
								variant="destructive"
							>
								<Trash2 />
								<span>Elimina tutto</span>
							</Button>
						</Confirm>
					</PopoverContent>
				</Popover>
			</div>
			<CommsSwitch userId={userId} />
			<Coda userId={userId} />
			<EmailAccordion isAdmin={user.isAdmin} userId={userId} />
		</main>
	);
};

export default ComunicazioniUser;

export const getServerSideProps = (async (context) => {
	const userId = context.params?.userId;
	if (typeof userId !== "string") {
		return {
			notFound: true,
		};
	}

	const parsed = zUserId.safeParse(userId);

	if (!parsed.success) {
		return {
			notFound: true,
		};
	}
	const access_token = context.req.cookies.access_token;

	const helpers = await TrpcAuthedFetchingIstance({ access_token });
	if (helpers) {
		await helpers.trpc.comunicazioni.getEmails.prefetch({
			userId: parsed.data,
		});
		await helpers.trpc.comunicazioni.getUserQueuedEmails.prefetch({
			userId: parsed.data,
		});
		return {
			props: {
				userId: parsed.data,
				trpcState: helpers.trpc.dehydrate(),
			},
		};
	}
	return {
		notFound: true,
	};
}) satisfies GetServerSideProps<ComunicazioniUserProps>;

ComunicazioniUser.getLayout = function getLayout(page) {
	return <AreaRiservataLayoutUserView>{page}</AreaRiservataLayoutUserView>;
};

const CommsSwitch = ({ userId }: { userId: UsersId }) => {
	const { data, isLoading } = api.users.getUser.useQuery({ id: userId });
	if (isLoading || !data) {
		return <div>Loading...</div>;
	}

	const utils = api.useUtils();
	const { mutate } = api.users.editUser.useMutation({
		onSuccess: async () => {
			toast.success("Impostazione modificata");
			await utils.users.getUser.invalidate({ id: userId });
		},
		onError: (error) => {
			console.error(error);
			toast.error("Errore durante la modifica dell'impostazione");
		},
	});

	return (
		<div className="flex items-center gap-2">
			<Label htmlFor="comms">Abilita comunicazioni</Label>
			<Switch
				className="data-[state=checked]:bg-neutral-700"
				defaultChecked={data.comms_enabled}
				id="comms"
				onCheckedChange={(checked) => {
					mutate({ id: userId, data: { comms_enabled: checked } });
				}}
			/>
		</div>
	);
};

const Coda = ({ userId }: { userId: UsersId }) => {
	const { data, isLoading } = api.comunicazioni.getUserQueuedEmails.useQuery({
		userId,
	});
	const utils = api.useUtils();
	const { mutate } = api.comunicazioni.clearUserEmailQueue.useMutation({
		onSuccess: async () => {
			toast.success("Coda email pulita");
			await utils.comunicazioni.getUserQueuedEmails.invalidate({ userId });
		},
		onError: (error) => {
			console.error(error);
			toast.error("Errore durante la pulizia della coda email");
		},
	});
	const { mutate: removeFromQueue } =
		api.comunicazioni.removeFromUserEmailQueue.useMutation({
			onSuccess: async () => {
				toast.success("Email rimossa dalla coda");
				await utils.comunicazioni.getUserQueuedEmails.invalidate({ userId });
			},
			onError: (error) => {
				console.error(error);
				toast.error("Errore durante la rimozione dell'email dalla coda");
			},
		});

	const { mutate: addToQueue } =
		api.comunicazioni.addToUserEmailQueue.useMutation({
			onSuccess: async () => {
				toast.success("Email aggiunta alla coda");
				await utils.comunicazioni.getUserQueuedEmails.invalidate({ userId });
			},
			onError: (error) => {
				console.error(error);
				toast.error("Errore durante l'aggiunta dell'email alla coda");
			},
		});

	const { mutate: updateEvent } = api.comunicazioni.updateEvent.useMutation({
		onSuccess: async () => {
			toast.success("Email aggiornata nella coda");
			await utils.comunicazioni.getUserQueuedEmails.invalidate({ userId });
		},
		onError: (error) => {
			console.error(error);
			toast.error("Errore durante l'aggiornamento dell'email nella coda");
		},
	});

	const [newOpen, setNewOpen] = useState(false);

	if (isLoading) {
		return <div>Loading...</div>;
	}
	if (!data) {
		return <div>Errore nel caricamento coda delle email</div>;
	}

	return (
		<div className="flex w-full flex-col gap-2">
			<h3>Email in coda:</h3>
			{data.length === 0 && <div>Nessuna email in coda</div>}
			{data.map((email) => {
				const mailData = email.data as Email_EventData;
				return (
					<div
						className="flex items-center gap-2 rounded-md border p-1.5"
						key={email.event_id}
					>
						<Dialog>
							<DialogTrigger asChild>
								<Button size="sm" variant="outline">
									<Maximize2 />
								</Button>
							</DialogTrigger>
							<DialogContent className="sm:max-w-xl">
								<DialogHeader>
									<DialogTitle>Dettagli</DialogTitle>
									<DialogDescription className="sr-only">
										dettagli dell'email in coda
									</DialogDescription>
								</DialogHeader>
								<FormEditQueueMail
									data={email}
									del={() => removeFromQueue({ eventId: email.event_id })}
									submitMutation={(values) => {
										updateEvent({ eventId: email.event_id, data: values });
									}}
								/>
							</DialogContent>
						</Dialog>

						<div className="font-semibold">
							{mailData.data.mail.subject ||
								mailData.data.template?.mailType ||
								"Nessun oggetto"}
						</div>
						<div className="text-muted-foreground text-sm">
							data invio:{" "}
							{new Date(email.lock_expires).toLocaleDateString("it-IT", {
								day: "2-digit",
								month: "2-digit",
								year: "numeric",
								hour: "2-digit",
								minute: "2-digit",
							})}
						</div>
					</div>
				);
			})}
			<div className="flex w-full justify-start gap-2">
				<Dialog onOpenChange={setNewOpen} open={newOpen}>
					<DialogTrigger asChild>
						<Button size="sm" variant="outline">
							<Plus /> Aggiungi email alla coda
						</Button>
					</DialogTrigger>
					<DialogContent className="sm:max-w-2xl">
						<DialogHeader>
							<DialogTitle>Aggiungi email alla coda</DialogTitle>
							<DialogDescription className="sr-only">
								aggiungi email alla coda
							</DialogDescription>
						</DialogHeader>
						<FormAddCodaEmail
							submitMutation={(values) => {
								addToQueue({ userId, ...values });
								setNewOpen(false);
							}}
						/>
					</DialogContent>
				</Dialog>

				<Confirm
					description="Sei sicuro di voler svuotare la coda email?"
					onConfirm={() => {
						mutate({ userId });
					}}
					title="Elimina"
				>
					<Button
						aria-label="Delete"
						disabled={data.length === 0}
						size="sm"
						variant="destructive"
					>
						<Trash2 />
						Pulisci coda email
					</Button>
				</Confirm>
			</div>
		</div>
	);
};
