import { useEffect, useState } from "react";
import { useDidResolution } from "./useDidResolution";
import { usePdsEndpoint } from "./usePdsEndpoint";
import { createAtprotoClient } from "../utils/atproto-client";

/**
 * Shape of the state returned by {@link useLatestRecord}.
 */
export interface LatestRecordState<T = unknown> {
	/** Latest record value if one exists. */
	record?: T;
	/** Record key for the fetched record, when derivable. */
	rkey?: string;
	/** Error encountered while fetching. */
	error?: Error;
	/** Indicates whether a fetch is in progress. */
	loading: boolean;
	/** `true` when the collection has zero records. */
	empty: boolean;
}

/**
 * Fetches the most recent record from a collection using `listRecords(limit=1)`.
 *
 * @param handleOrDid - Handle or DID that owns the collection.
 * @param collection - NSID of the collection to query.
 * @returns {LatestRecordState<T>} Object reporting the latest record value, derived rkey, loading status, emptiness, and any error.
 */
export function useLatestRecord<T = unknown>(
	handleOrDid: string | undefined,
	collection: string,
): LatestRecordState<T> {
	const {
		did,
		error: didError,
		loading: resolvingDid,
	} = useDidResolution(handleOrDid);
	const {
		endpoint,
		error: endpointError,
		loading: resolvingEndpoint,
	} = usePdsEndpoint(did);
	const [state, setState] = useState<LatestRecordState<T>>({
		loading: !!handleOrDid,
		empty: false,
	});

	useEffect(() => {
		let cancelled = false;

		const assign = (next: Partial<LatestRecordState<T>>) => {
			if (cancelled) return;
			setState((prev) => ({ ...prev, ...next }));
		};

		if (!handleOrDid) {
			assign({
				loading: false,
				record: undefined,
				rkey: undefined,
				error: undefined,
				empty: false,
			});
			return () => {
				cancelled = true;
			};
		}

		if (didError) {
			assign({ loading: false, error: didError, empty: false });
			return () => {
				cancelled = true;
			};
		}

		if (endpointError) {
			assign({ loading: false, error: endpointError, empty: false });
			return () => {
				cancelled = true;
			};
		}

		if (resolvingDid || resolvingEndpoint || !did || !endpoint) {
			assign({ loading: true, error: undefined });
			return () => {
				cancelled = true;
			};
		}

		assign({ loading: true, error: undefined, empty: false });

		(async () => {
			try {
				const { rpc } = await createAtprotoClient({
					service: endpoint,
				});
				const res = await (
					rpc as unknown as {
						get: (
							nsid: string,
							opts: {
								params: Record<
									string,
									string | number | boolean
								>;
							},
						) => Promise<{
							ok: boolean;
							data: {
								records: Array<{
									uri: string;
									rkey?: string;
									value: T;
								}>;
							};
						}>;
					}
				).get("com.atproto.repo.listRecords", {
					params: { repo: did, collection, limit: 1, reverse: false },
				});
				if (!res.ok) throw new Error("Failed to list records");
				const list = res.data.records;
				if (list.length === 0) {
					assign({
						loading: false,
						empty: true,
						record: undefined,
						rkey: undefined,
					});
					return;
				}
				const first = list[0];
				const derivedRkey = first.rkey ?? extractRkey(first.uri);
				assign({
					record: first.value,
					rkey: derivedRkey,
					loading: false,
					empty: false,
				});
			} catch (e) {
				assign({ error: e as Error, loading: false, empty: false });
			}
		})();

		return () => {
			cancelled = true;
		};
	}, [
		handleOrDid,
		did,
		endpoint,
		collection,
		resolvingDid,
		resolvingEndpoint,
		didError,
		endpointError,
	]);

	return state;
}

function extractRkey(uri: string): string | undefined {
	if (!uri) return undefined;
	const parts = uri.split("/");
	return parts[parts.length - 1];
}