infoalloggi-monorepo/apps/infoalloggi/src/providers/PotenzialiProvider.tsx

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

type PotenzialiContextType = {
	data: PotenzialeData[];
	columns: PotenzialiGroups[];
	editingItem: PotenzialeData | null;
	setData: (data: PotenzialeData[]) => void;
	updateCall: () => void;
	setEditing: (id: PotenzialiId | null) => void;
	addItem: (item: NewPotenziali) => void;
	removeItem: (id: PotenzialiId) => 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 } = api.potenziali.getPotenziali.useQuery();

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

	const [editingItem, setEditingItem] = useState<PotenzialeData | null>(null);

	const setEditing = (id: PotenzialiId | null) => {
		const item = data?.find((item) => item.id === id) || null;
		setEditingItem(item);
	};

	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) => {
		updateItemMutation({
			potenzialiId: item.id,
			data: item,
		});
	};

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