import { infiniteQueryOptions, keepPreviousData, queryOptions, type QueryClient } from "@tanstack/react-query";
import * as api from "@/lib/api";
import { setRefreshStatus } from "@/features/blocklists/refreshStore";
import type {
	BlocklistInput,
	ClientEdit,
	ClientPrefixInput,
	ForwardZoneInput,
	GroupInput,
	LocalRecordInput,
	PausePost,
	Period,
	QueriesFilter,
	QueriesPage,
	RuleInput,
	SettingsPatch,
	UpstreamInput,
} from "@/lib/types";

export const queryKeys = {
	health: ["health"] as const,
	version: ["version"] as const,
	stats: (period: Period) => ["stats", period] as const,
	timeseries: (period: Period) => ["stats", "timeseries", period] as const,
	queriesInfinite: (filter: QueriesFilter) => ["queries", "infinite", filter] as const,
	upstreamHealth: ["upstream-health"] as const,
	lookup: (domain: string, groupId?: number) => ["lookup", domain, groupId ?? null] as const,
	/** Prefix of every `lookup` entry; the invalidation target after any verdict input changes. */
	lookupAll: ["lookup"] as const,
	groups: ["groups"] as const,
	groupSources: (id: number) => ["groups", id, "sources"] as const,
	blocklists: ["blocklists"] as const,
	rules: ["rules"] as const,
	localRecords: ["local-records"] as const,
	forwardZones: ["forward-zones"] as const,
	clients: ["clients"] as const,
	clientPrefixes: ["client-prefixes"] as const,
	upstreams: ["upstreams"] as const,
	pause: ["pause"] as const,
	settings: ["settings"] as const,
};

export const healthQuery = () =>
	queryOptions({ queryKey: queryKeys.health, queryFn: api.getHealth, refetchInterval: 10_000 });

export const versionQuery = () =>
	queryOptions({ queryKey: queryKeys.version, queryFn: api.getVersion, staleTime: Infinity });

export const statsQuery = (period: Period = "24h") =>
	queryOptions({ queryKey: queryKeys.stats(period), queryFn: () => api.getStats(period), refetchInterval: 30_000 });

export const timeseriesQuery = (period: Period = "24h") =>
	queryOptions({
		queryKey: queryKeys.timeseries(period),
		queryFn: () => api.getStatsTimeseries(period),
		refetchInterval: 30_000,
	});

// Keyset pagination on `next_before` (handlers/queries.zig). A background
// refetch replays every page in cursor order, so newly logged rows shift the
// whole window instead of opening a gap between page 1 and page 2.
export const queriesInfiniteQuery = (filter: QueriesFilter = {}) =>
	infiniteQueryOptions({
		queryKey: queryKeys.queriesInfinite(filter),
		queryFn: ({ pageParam }: { pageParam: number | undefined }) =>
			api.getQueries(pageParam === undefined ? filter : { ...filter, before: pageParam }),
		initialPageParam: undefined as number | undefined,
		getNextPageParam: (last: QueriesPage) => last.next_before ?? undefined,
		placeholderData: keepPreviousData,
	});

export const upstreamHealthQuery = () =>
	queryOptions({ queryKey: queryKeys.upstreamHealth, queryFn: api.getUpstreamHealth, refetchInterval: 30_000 });

export const lookupQuery = (domain: string, groupId?: number) =>
	queryOptions({ queryKey: queryKeys.lookup(domain, groupId), queryFn: () => api.getLookup(domain, groupId) });

export const groupsQuery = () => queryOptions({ queryKey: queryKeys.groups, queryFn: api.listGroups });

export const groupSourcesQuery = (id: number) =>
	queryOptions({ queryKey: queryKeys.groupSources(id), queryFn: () => api.getGroupSources(id) });

export const blocklistsQuery = () => queryOptions({ queryKey: queryKeys.blocklists, queryFn: api.listBlocklists });

export const rulesQuery = () => queryOptions({ queryKey: queryKeys.rules, queryFn: api.listRules });

export const localRecordsQuery = () =>
	queryOptions({ queryKey: queryKeys.localRecords, queryFn: api.listLocalRecords });

export const forwardZonesQuery = () =>
	queryOptions({ queryKey: queryKeys.forwardZones, queryFn: api.listForwardZones });

export const clientsQuery = () => queryOptions({ queryKey: queryKeys.clients, queryFn: api.listClients });

export const clientPrefixesQuery = () =>
	queryOptions({ queryKey: queryKeys.clientPrefixes, queryFn: api.listClientPrefixes });

export const upstreamsQuery = () => queryOptions({ queryKey: queryKeys.upstreams, queryFn: api.listUpstreams });

export const pauseQuery = () => queryOptions({ queryKey: queryKeys.pause, queryFn: api.getPause });

export const settingsQuery = () => queryOptions({ queryKey: queryKeys.settings, queryFn: api.getSettings });

// Mutation option factories. Usage: useMutation(groupCreateMutation(useQueryClient())).
// Group membership and names feed lookup verdicts and the group columns on
// clients, prefixes and rules, hence the wide invalidation on group mutations.

function invalidateGroupWorld(qc: QueryClient): Promise<unknown> {
	return Promise.all([
		qc.invalidateQueries({ queryKey: queryKeys.groups }),
		qc.invalidateQueries({ queryKey: queryKeys.lookupAll }),
		qc.invalidateQueries({ queryKey: queryKeys.clients }),
		qc.invalidateQueries({ queryKey: queryKeys.clientPrefixes }),
		qc.invalidateQueries({ queryKey: queryKeys.rules }),
	]);
}

export const groupCreateMutation = (qc: QueryClient) => ({
	mutationFn: (input: GroupInput) => api.createGroup(input),
	onSuccess: () => invalidateGroupWorld(qc),
});

export const groupUpdateMutation = (qc: QueryClient) => ({
	mutationFn: ({ id, input }: { id: number; input: GroupInput }) => api.updateGroup(id, input),
	onSuccess: () => invalidateGroupWorld(qc),
});

export const groupDeleteMutation = (qc: QueryClient) => ({
	mutationFn: (id: number) => api.deleteGroup(id),
	onSuccess: () => invalidateGroupWorld(qc),
});

export const groupSourcesPutMutation = (qc: QueryClient) => ({
	mutationFn: ({ id, sourceIds }: { id: number; sourceIds: number[] }) => api.putGroupSources(id, sourceIds),
	onSuccess: (sourceIds: number[], { id }: { id: number; sourceIds: number[] }) => {
		qc.setQueryData(queryKeys.groupSources(id), sourceIds);
		return qc.invalidateQueries({ queryKey: queryKeys.lookupAll });
	},
});

function invalidateBlocklistWorld(qc: QueryClient): Promise<unknown> {
	return Promise.all([
		qc.invalidateQueries({ queryKey: queryKeys.blocklists }),
		qc.invalidateQueries({ queryKey: queryKeys.lookupAll }),
		qc.invalidateQueries({ queryKey: queryKeys.groups }),
	]);
}

export const blocklistCreateMutation = (qc: QueryClient) => ({
	mutationFn: (input: BlocklistInput) => api.createBlocklist(input),
	onSuccess: () => invalidateBlocklistWorld(qc),
});

export const blocklistUpdateMutation = (qc: QueryClient) => ({
	mutationFn: ({ id, input }: { id: number; input: BlocklistInput }) => api.updateBlocklist(id, input),
	onSuccess: () => invalidateBlocklistWorld(qc),
});

export const blocklistDeleteMutation = (qc: QueryClient) => ({
	mutationFn: (id: number) => api.deleteBlocklist(id),
	onSuccess: () => invalidateBlocklistWorld(qc),
});

/** Ruling 12: the 202 snapshot REPLACES the refresh store; counters refresh. */
export const blocklistsUpdateNowMutation = (qc: QueryClient) => ({
	mutationFn: () => api.updateBlocklistsNow(),
	onSuccess: (sources: Awaited<ReturnType<typeof api.updateBlocklistsNow>>) => {
		setRefreshStatus(sources);
		return Promise.all([
			qc.invalidateQueries({ queryKey: queryKeys.blocklists }),
			qc.invalidateQueries({ queryKey: queryKeys.lookupAll }),
		]);
	},
});

function invalidateRules(qc: QueryClient): Promise<unknown> {
	return Promise.all([
		qc.invalidateQueries({ queryKey: queryKeys.rules }),
		qc.invalidateQueries({ queryKey: queryKeys.lookupAll }),
	]);
}

export const ruleCreateMutation = (qc: QueryClient) => ({
	mutationFn: (input: RuleInput) => api.createRule(input),
	onSuccess: () => invalidateRules(qc),
});

export const ruleDeleteMutation = (qc: QueryClient) => ({
	mutationFn: (id: number) => api.deleteRule(id),
	onSuccess: () => invalidateRules(qc),
});

function invalidateLocalRecords(qc: QueryClient): Promise<unknown> {
	return Promise.all([
		qc.invalidateQueries({ queryKey: queryKeys.localRecords }),
		qc.invalidateQueries({ queryKey: queryKeys.lookupAll }),
	]);
}

export const localRecordCreateMutation = (qc: QueryClient) => ({
	mutationFn: (input: LocalRecordInput) => api.createLocalRecord(input),
	onSuccess: () => invalidateLocalRecords(qc),
});

export const localRecordUpdateMutation = (qc: QueryClient) => ({
	mutationFn: ({ id, input }: { id: number; input: LocalRecordInput }) => api.updateLocalRecord(id, input),
	onSuccess: () => invalidateLocalRecords(qc),
});

export const localRecordDeleteMutation = (qc: QueryClient) => ({
	mutationFn: (id: number) => api.deleteLocalRecord(id),
	onSuccess: () => invalidateLocalRecords(qc),
});

function invalidateForwardZones(qc: QueryClient): Promise<unknown> {
	return Promise.all([
		qc.invalidateQueries({ queryKey: queryKeys.forwardZones }),
		qc.invalidateQueries({ queryKey: queryKeys.lookupAll }),
	]);
}

export const forwardZoneCreateMutation = (qc: QueryClient) => ({
	mutationFn: (input: ForwardZoneInput) => api.createForwardZone(input),
	onSuccess: () => invalidateForwardZones(qc),
});

export const forwardZoneUpdateMutation = (qc: QueryClient) => ({
	mutationFn: ({ id, input }: { id: number; input: ForwardZoneInput }) => api.updateForwardZone(id, input),
	onSuccess: () => invalidateForwardZones(qc),
});

export const forwardZoneDeleteMutation = (qc: QueryClient) => ({
	mutationFn: (id: number) => api.deleteForwardZone(id),
	onSuccess: () => invalidateForwardZones(qc),
});

export const clientUpdateMutation = (qc: QueryClient) => ({
	mutationFn: ({ id, edit }: { id: number; edit: ClientEdit }) => api.updateClient(id, edit),
	onSuccess: () => qc.invalidateQueries({ queryKey: queryKeys.clients }),
});

export const clientDeleteMutation = (qc: QueryClient) => ({
	mutationFn: (id: number) => api.deleteClient(id),
	onSuccess: () => qc.invalidateQueries({ queryKey: queryKeys.clients }),
});

export const clientPrefixesPutMutation = (qc: QueryClient) => ({
	mutationFn: (prefixes: ClientPrefixInput[]) => api.putClientPrefixes(prefixes),
	onSuccess: (stored: Awaited<ReturnType<typeof api.putClientPrefixes>>) => {
		qc.setQueryData(queryKeys.clientPrefixes, stored);
	},
});

function invalidateUpstreams(qc: QueryClient): Promise<unknown> {
	return qc.invalidateQueries({ queryKey: queryKeys.upstreams });
}

export const upstreamCreateMutation = (qc: QueryClient) => ({
	mutationFn: (input: UpstreamInput) => api.createUpstream(input),
	onSuccess: () => invalidateUpstreams(qc),
});

export const upstreamUpdateMutation = (qc: QueryClient) => ({
	mutationFn: ({ id, input }: { id: number; input: UpstreamInput }) => api.updateUpstream(id, input),
	onSuccess: () => invalidateUpstreams(qc),
});

export const upstreamDeleteMutation = (qc: QueryClient) => ({
	mutationFn: (id: number) => api.deleteUpstream(id),
	onSuccess: () => invalidateUpstreams(qc),
});

export const pauseMutation = (qc: QueryClient) => ({
	mutationFn: (body: PausePost) => api.postPause(body),
	onSuccess: (state: Awaited<ReturnType<typeof api.postPause>>) => {
		qc.setQueryData(queryKeys.pause, state);
	},
});

export const settingsPutMutation = (qc: QueryClient) => ({
	mutationFn: (patch: SettingsPatch) => api.putSettings(patch),
	onSuccess: (envelope: Awaited<ReturnType<typeof api.putSettings>>) => {
		qc.setQueryData(queryKeys.settings, envelope);
		return qc.invalidateQueries({ queryKey: queryKeys.settings });
	},
});