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

/**
 * Identifier trio required to address an AT Protocol record.
 */
export interface AtProtoRecordKey {
    /** Repository DID (or handle prior to resolution) containing the record. */
    did?: string;
    /** NSID collection in which the record resides. */
    collection?: string;
    /** Record key string uniquely identifying the record within the collection. */
    rkey?: string;
}

/**
 * Loading state returned by {@link useAtProtoRecord}.
 */
export interface AtProtoRecordState<T = unknown> {
    /** Resolved record value when fetch succeeds. */
    record?: T;
    /** Error thrown while loading, if any. */
    error?: Error;
    /** Indicates whether the hook is in a loading state. */
    loading: boolean;
}

/**
 * React hook that fetches a single AT Protocol record and tracks loading/error state.
 *
 * @param did - DID (or handle before resolution) that owns the record.
 * @param collection - NSID collection from which to fetch the record.
 * @param rkey - Record key identifying the record within the collection.
 * @returns {AtProtoRecordState<T>} Object containing the resolved record, any error, and a loading flag.
 */
export function useAtProtoRecord<T = unknown>({ did: handleOrDid, collection, rkey }: AtProtoRecordKey): AtProtoRecordState<T> {
    const { did, error: didError, loading: resolvingDid } = useDidResolution(handleOrDid);
    const { endpoint, error: endpointError, loading: resolvingEndpoint } = usePdsEndpoint(did);
    const [state, setState] = useState<AtProtoRecordState<T>>({ loading: !!(handleOrDid && collection && rkey) });

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

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

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

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

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

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

        assignState({ loading: true, error: undefined, record: undefined });

        (async () => {
            try {
                const { rpc } = await createAtprotoClient({ service: endpoint });
                const res = await (rpc as unknown as {
                    get: (
                        nsid: string,
                        opts: { params: { repo: string; collection: string; rkey: string } }
                    ) => Promise<{ ok: boolean; data: { value: T } }>;
                }).get('com.atproto.repo.getRecord', {
                    params: { repo: did, collection, rkey }
                });
                if (!res.ok) throw new Error('Failed to load record');
                const record = (res.data as { value: T }).value;
                assignState({ record, loading: false });
            } catch (e) {
                const err = e instanceof Error ? e : new Error(String(e));
                assignState({ error: err, loading: false });
            }
        })();

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

    return state;
}