import { createContext, useContext } from "react";
import toast from "react-hot-toast";
import type { NewPotenziali, PotenzialiId } from "~/schemas/public/Potenziali";
import type {
	PotenzialiGroups,
	PotenzialiGroupsId,
} from "~/schemas/public/PotenzialiGroups";
import type { PotenzialeData } from "~/server/services/potenziali.service";
import { api } from "~/utils/api";

type PotenzialiContextType = {
	data: PotenzialeData[];
	columns: PotenzialiGroups[];
	setData: (data: PotenzialeData[]) => void;
	updateCall: () => void;
	addItem: (item: NewPotenziali) => void;
	removeItem: (id: PotenzialiId) => void;
	removeColumn: (id: PotenzialiGroupsId) => void;
	addColumn: (name: string) => void;
	updateItem: (item: PotenzialeData) => void;
};

const PotenzialiContext = createContext<PotenzialiContextType | null>(null);

type PotenzialiProviderProps = {
	children: React.ReactNode;
};
export const PotenzialiProvider = ({ children }: PotenzialiProviderProps) => {
	const { data, isError } = api.potenziali.getPotenziali.useQuery(undefined, {
		refetchInterval: 30000,
		refetchIntervalInBackground: true,
		refetchOnWindowFocus: true,
	});

	if (isError) {
		console.error("Errore nel caricamento dei potenziali");
		window.location.reload();
	}

	const { data: columns } = api.potenziali.getPotenzialiGroups.useQuery();

	const utils = api.useUtils();
	const { mutate: addItemMutation } = api.potenziali.addPotenziale.useMutation({
		onSuccess: async () => {
			toast.success("Elemento aggiunto con successo");
			await utils.potenziali.getPotenziali.invalidate();
			await utils.potenziali.getPotenzialiGroups.invalidate();
		},
	});

	const addItem = (item: NewPotenziali) => {
		addItemMutation({
			data: item,
		});
	};
	const { mutate: removeItemMutation } =
		api.potenziali.deletePotenziale.useMutation({
			onSuccess: async () => {
				toast.success("Elemento rimosso con successo");
				await utils.potenziali.getPotenziali.invalidate();
				await utils.potenziali.getPotenzialiGroups.invalidate();
			},
		});
	const removeItem = (id: PotenzialiId) => {
		removeItemMutation({
			potenzialiId: id,
		});
	};
	const setData = (newData: PotenzialeData[]) => {
		utils.potenziali.getPotenziali.setData(undefined, newData);
	};

	const { mutate: updatePotenzialiMutation } =
		api.potenziali.updatePotenziali.useMutation({
			onSuccess: async () => {
				await utils.potenziali.getPotenziali.invalidate();
			},
		});

	const updateCall = () => {
		updatePotenzialiMutation({
			data: utils.potenziali.getPotenziali.getData() || [],
		});
	};

	const { mutate: addColumnMutation } =
		api.potenziali.addPotenzialeGroup.useMutation({
			onSuccess: async () => {
				toast.success("Colonna aggiunta con successo");
				await utils.potenziali.getPotenziali.invalidate();
				await utils.potenziali.getPotenzialiGroups.invalidate();
			},
		});
	const addColumn = (name: string) => {
		addColumnMutation({
			name,
		});
	};
	const { mutate: updateItemMutation } =
		api.potenziali.updatePotenziale.useMutation({
			onSuccess: async () => {
				toast.success("Elemento aggiornato con successo");
				await utils.potenziali.getPotenziali.invalidate();
			},
		});
	const updateItem = (item: PotenzialeData) => {
		const { column, username: _username, ...rest } = item;
		updateItemMutation({
			potenzialiId: item.id,
			data: {
				...rest,
				potenziali_group_id: column as PotenzialiGroupsId,
			},
		});
	};

	const { mutate: removeColumnMutation } =
		api.potenziali.deletePotenzialeGroup.useMutation({
			onSuccess: async () => {
				toast.success("Colonna rimossa con successo");
				await utils.potenziali.getPotenziali.invalidate();
				await utils.potenziali.getPotenzialiGroups.invalidate();
			},
		});
	const removeColumn = (id: PotenzialiGroupsId) => {
		removeColumnMutation({
			potenzialiGroupId: id,
		});
	};

	return (
		<PotenzialiContext.Provider
			value={{
				data: data || [],
				columns: columns || [],
				setData,
				updateCall,
				addItem,
				removeItem,
				addColumn,
				updateItem,
				removeColumn,
			}}
		>
			{children}
		</PotenzialiContext.Provider>
	);
};
export const usePotenziali = () => {
	const context = useContext(PotenzialiContext);
	if (!context) {
		throw new Error("usePotenziali must be used within a PotenzialiProvider");
	}
	return context;
};
