import { isAsOfIncomplete } from '../utils/searchTruncation';
import { useEffect, useState, useCallback } from 'react';
import { usePatientServiceContext, useClinicalImpressionServiceContext } from '../services';

import { describeFetchFailure, isRefusedRead } from '../utils/fetchFailureMessage';
import { patientCacheGuard } from '../utils/cacheOwner';

interface UseFhirClinicalImpressionsOptions {
    autoLoad?: boolean;
    errorMessage?: string;
    forceReload?: boolean;
}

interface UseFhirClinicalImpressionsReturn {
    /** Served as of a cutoff and not in full: what it left out is unknown, never none. */
    incomplete: boolean;
    loading: boolean;
    error: string | undefined;
    /** The last load was answered with a 403: refused, not lost. */
    refused: boolean;
    /**
 * - was the server actually asked?
 *
 * This hook early-returns while `patientState` is unresolved, so `setLoading(true)` never runs and
 * the effect never fires. The caller is then holding `loading: false` - `error: undefined` - an
 * empty list - **indistinguishable from a load that succeeded and found nothing** - and
 * `ResourceListStatus` says *"No X found."* about a question nobody asked.
 * Only the hook knows which of the two it is in, so it reports it.
 */
    attempted: boolean;
    /** The service's list is this patient's. Anything else is another patient's, never this one's data. */
    listIsThisPatients: boolean;
    loadClinicalImpressions: () => Promise<void>;
    clearError: () => void;
    clinicalImpressionsBundle: ReturnType<typeof useClinicalImpressionServiceContext>['clinicalImpressionsBundle'];
    clinicalImpressionsList: ReturnType<typeof useClinicalImpressionServiceContext>['clinicalImpressionsList'];
}

export const useFhirClinicalImpressions = (options: UseFhirClinicalImpressionsOptions = {}): UseFhirClinicalImpressionsReturn => {
    const {
        autoLoad = true,
        errorMessage = "Failed to load clinical impressions",
        forceReload = false
    } = options;

    const { patientState } = usePatientServiceContext();
    const {
        cachedForPatientId,
        fetchClinicalImpressionsWithPolling,
        clinicalImpressionsBundle,
        clinicalImpressionsList
    } = useClinicalImpressionServiceContext();

    const [loading, setLoading] = useState(false);
    const [error, setError] = useState<string | undefined>();
    const [refused, setRefused] = useState(false);

    const loadClinicalImpressions = useCallback(async () => {
        if (!patientState) {
            return;
        }

        setLoading(true);
        setError(undefined);
        setRefused(false);

        try {
            await fetchClinicalImpressionsWithPolling(patientState);
        } catch (err) {
            console.error('Failed to load clinical impressions:', err);
            setError(describeFetchFailure(err, errorMessage));
            setRefused(isRefusedRead(err));
        } finally {
            setLoading(false);
        }
    }, [patientState, fetchClinicalImpressionsWithPolling, errorMessage]);

    const clearError = useCallback(() => {
        setError(undefined);
    }, []);

    useEffect(() => {
        if (!autoLoad) return;
        if (!patientState) return;

        // A bundle belonging to SOMEBODY ELSE is not a reason not to ask. This used to fire only when
        // there was no bundle at all, so moving between two charts left the previous patient's list in
        // place, with no request and nothing on screen to say it was not theirs.
        // NOT a refetch on every navigation: same patient, bundle loaded, no request.
        if (!clinicalImpressionsBundle || cachedForPatientId !== patientState.id || forceReload) {
            loadClinicalImpressions();
        }
    }, [autoLoad, patientState, clinicalImpressionsBundle, cachedForPatientId, forceReload, loadClinicalImpressions]);

    // The cache outlives a change of patient: hand out only the patient asked about.
    const guard = patientCacheGuard(cachedForPatientId, patientState?.id);

    return {
        loading: guard.loading(loading, Boolean(error) || refused),
        error,
        refused,
        // Derived from the SAME condition the early returns above test, never tracked separately: a
        // hand-set flag goes stale the first time somebody adds a third reason to bail, and silently.
        attempted: Boolean(patientState),
        listIsThisPatients: cachedForPatientId !== undefined && cachedForPatientId === patientState?.id,
        loadClinicalImpressions,
        clearError,
        // Served as of a cutoff and not in full: what it left out is unknown, never none.
        incomplete: isAsOfIncomplete(guard.bundle(clinicalImpressionsBundle, null)),
        clinicalImpressionsBundle: guard.bundle(clinicalImpressionsBundle, null),
        clinicalImpressionsList: guard.list(clinicalImpressionsList)
    };
};