import type { ReadOptions } from '../hooks/anchorView/readOptions';
import { isHeld, overlayHeldBundle, refersToPatient, writtenSince } from '../utils/writeThroughHold';
import { useState, useCallback, createContext, useContext, ReactNode, useEffect, useRef } from 'react';
import {
    Bundle,
    ImmunizationEvaluation,
    Patient,
    Reference
} from 'fhir/r4';
import { environment } from '../environments/environment.ts';
import { useFhirServiceContext } from './FhirService.tsx';
import { useHttpService } from './HttpService.tsx';
import { formatFhirHumanName } from '../utils/fhirHumanName.tsx';
import { usePatientServiceContext } from './PatientService.tsx';
import { formatFhirCodeableConcept } from '../utils/fhirCodeableConcept.tsx';
import { applyArchive, isArchived, type ArchiveReason } from '../utils/archivedResource';
import { statusLabel } from '../utils/fhirStatusVocabulary';
import { fetchAllPagesAsBundle } from '../utils/fetchAllPagesAsBundle';
import { searchPageSize } from '../utils/pageSizeOverride';
import { useCacheOwner } from '../utils/cacheOwner';

const API_URL = environment.fhirClinicalApi;

export const useImmunizationEvaluationService = () => {
    const { get, post, put, delete: del } = useHttpService();
    const { patientState } = usePatientServiceContext();
    const {
        transformToCodeableConcept,
        transformFromCodeableConcept,
        createReferenceObject,
        formatDateTime,
        formatDateTimeForInput,
        formatDateTimeForDisplay,
        unpackBundle,
        extractReferenceId
    } = useFhirServiceContext();

    const [immunizationEvaluationsList, setImmunizationEvaluationsList] = useState<ImmunizationEvaluation[]>([]);
    const [shouldReload, setShouldReload] = useState<boolean>(false);
    const [lastUpserted, setLastUpserted] = useState<string | null | undefined>(null);
    const [unsaved, setUnsaved] = useState<boolean>(false);

    const [immunizationEvaluationsBundle, setImmunizationEvaluationsBundle] = useState<Bundle<ImmunizationEvaluation> | null>(null);
    const immunizationEvaluationsBundleRef = useRef<Bundle<ImmunizationEvaluation> | null>(null);
    const lastFetchTimeRef = useRef<number>(0);

    useEffect(() => {
        immunizationEvaluationsBundleRef.current = immunizationEvaluationsBundle;
    }, [immunizationEvaluationsBundle]);

    // WHOSE RECORDS ARE THESE? The reset below fires only when there is NO patient, which moving
    // between two charts never is - so the previous patient's bundle survived the switch and was
    // served as a cache hit, with no request and nothing on screen to say the list was not theirs.
    const cacheOwner = useCacheOwner('ImmunizationEvaluation', () => {
        setLastUpserted(null);
        setImmunizationEvaluationsBundle(null);
        setImmunizationEvaluationsList([]);
        lastFetchTimeRef.current = 0;
    });

    useEffect(() => {
        if (!patientState) {
            setImmunizationEvaluationsBundle(null);
            setImmunizationEvaluationsList([]);
            lastFetchTimeRef.current = 0;
            cacheOwner.release();
        }
    }, [patientState, cacheOwner.release]);

    const fetchImmunizationEvaluations = useCallback(async (patient: Patient, options?: ReadOptions): Promise<Bundle<ImmunizationEvaluation>> => {
        return overlayHeldBundle('ImmunizationEvaluation', await fetchAllPagesAsBundle<ImmunizationEvaluation>((pageParam) => {
            let params = new URLSearchParams();

            params.append('_count', searchPageSize('100'));
            params.append('patient', patient.id as string);
            if (pageParam) params.set('page', pageParam);

            return get<Bundle<ImmunizationEvaluation>>(`${API_URL}/ImmunizationEvaluation?${params.toString()}`, options);
        }), (resource) => refersToPatient(resource, patient.id)) as Bundle<ImmunizationEvaluation>;
    }, [get]);

    const fetchImmunizationEvaluationsWithPolling = useCallback(async (patient: Patient, forceReload = false): Promise<Bundle<ImmunizationEvaluation>> => {
        const now = Date.now();
        const cacheAge = now - lastFetchTimeRef.current;
        const cacheFresh = cacheAge < 5 * 60 * 1000;

        // cacheOwner.isFor is the load-bearing clause: a fresh bundle belonging to the PREVIOUS
        // patient satisfies every other condition here and would be returned as a hit.
        if (!forceReload && !shouldReload && !writtenSince('ImmunizationEvaluation', lastFetchTimeRef.current) && immunizationEvaluationsBundleRef.current && cacheFresh && cacheOwner.isCurrentFor(patient.id)) {
            return immunizationEvaluationsBundleRef.current;
        }

        const operation = cacheOwner.begin();

        let retries = 10;
        const delay = 3000;
        let found = false;
        let bundle: Bundle<ImmunizationEvaluation> | null = null;
        let entries: ImmunizationEvaluation[];

        do {
            bundle = await fetchImmunizationEvaluations(patient);
            entries = unpackBundle(bundle);
            found = lastUpserted ? entries.some(e => e.id === lastUpserted) || isHeld('ImmunizationEvaluation', lastUpserted) : true;

            if (!found) {
                await new Promise(resolve => setTimeout(resolve, delay));
            }
            retries--;
        } while (!found && retries > 0 && cacheOwner.publishes(operation));


        if (!cacheOwner.publishes(operation)) return cacheOwner.answerFor(operation, bundle);
        setImmunizationEvaluationsBundle(bundle);
        setImmunizationEvaluationsList(entries.filter((r) => !isArchived(r)));
        setLastUpserted(null);
        setShouldReload(false);
        lastFetchTimeRef.current = now;
        // Stamped WITH the data, never before it - on a throw the owner must still name the list
        // that is actually in state.
        cacheOwner.claim(patient.id, operation);

        return bundle;
    }, [fetchImmunizationEvaluations, unpackBundle, lastUpserted, shouldReload]);

    const fetchImmunizationEvaluation = useCallback(async (id: string): Promise<ImmunizationEvaluation> => {
        const cachedEvaluation = cacheOwner.isCurrent(cacheOwner.claimed) ? immunizationEvaluationsList.find(evaluation => evaluation.id === id) : undefined;
        if (cachedEvaluation) {
            return cachedEvaluation;
        }

        return get<ImmunizationEvaluation>(`${API_URL}/ImmunizationEvaluation/${id}`);
    }, [get, immunizationEvaluationsList]);

    const fetchImmunizationEvaluationHistory = useCallback(async (id: string, options?: ReadOptions): Promise<Bundle<ImmunizationEvaluation>> => {
        return get<Bundle<ImmunizationEvaluation>>(`${API_URL}/ImmunizationEvaluation/${id}/_history`, options);
    }, [get]);

    const createImmunizationEvaluation = useCallback(async (immunizationEvaluation: ImmunizationEvaluation): Promise<ImmunizationEvaluation> => {
        let params = new URLSearchParams();

        params.append('patient', extractReferenceId(immunizationEvaluation.patient) as string);

        return post<ImmunizationEvaluation>(`${API_URL}/ImmunizationEvaluation?${params.toString()}`, immunizationEvaluation);
    }, [post, extractReferenceId]);

    const updateImmunizationEvaluation = useCallback(async (immunizationEvaluation: ImmunizationEvaluation): Promise<ImmunizationEvaluation> => {
        return put<ImmunizationEvaluation>(`${API_URL}/ImmunizationEvaluation/${immunizationEvaluation.id}`, immunizationEvaluation);
    }, [put]);

    const deleteImmunizationEvaluation = useCallback(async (immunizationEvaluation: ImmunizationEvaluation): Promise<ImmunizationEvaluation> => {
        return del<ImmunizationEvaluation>(`${API_URL}/ImmunizationEvaluation/${immunizationEvaluation.id}`);
    }, [del]);

    const archiveImmunizationEvaluation = useCallback(
        async (immunizationEvaluation: ImmunizationEvaluation, reason: ArchiveReason, note?: string): Promise<ImmunizationEvaluation> =>
            put<ImmunizationEvaluation>(`${API_URL}/ImmunizationEvaluation/${immunizationEvaluation.id}`, applyArchive(immunizationEvaluation, reason, note)),
        [put],
    );

    const transformToFhirImmunizationEvaluation = useCallback((item: any, patient: Patient): ImmunizationEvaluation => {
        const {
            status,
            patient: patientRef,
            date,
            authority,
            targetDisease,
            immunizationEvent,
            doseStatus,
            doseStatusReason,
            description,
            series,
            doseNumberPositiveInt,
            seriesDosesPositiveInt
        } = item;

        const patientReference: Reference = createReferenceObject('Patient', patient.id as string, formatFhirHumanName(patient.name));

        let immunizationEvaluation: ImmunizationEvaluation = {
            resourceType: 'ImmunizationEvaluation',
            patient: patientReference,
            immunizationEvent: immunizationEvent,
            targetDisease: transformToCodeableConcept(targetDisease),
            status: status,
            doseStatus: transformToCodeableConcept(doseStatus),
            ...(date && { date: formatDateTime(date) }),
            ...(authority && { authority: createReferenceObject('Organization', authority.id) }),
            ...(doseStatusReason && doseStatusReason.length !== 0 && { doseStatusReason: transformToCodeableConcept(doseStatusReason) }),
            ...(description && { description: description }),
            ...(series && { series: series }),
            ...(doseNumberPositiveInt && { doseNumberPositiveInt: parseInt(doseNumberPositiveInt) }),
            ...(seriesDosesPositiveInt && { seriesDosesPositiveInt: parseInt(seriesDosesPositiveInt) })
        };

        return immunizationEvaluation;
    }, [createReferenceObject, transformToCodeableConcept, formatDateTime]);

    const transformFromFhirImmunizationEvaluation = useCallback((immunizationEvaluation: ImmunizationEvaluation): any => {
        const {
            status,
            date,
            authority,
            targetDisease,
            immunizationEvent,
            doseStatus,
            doseStatusReason,
            description,
            series,
            doseNumberPositiveInt,
            seriesDosesPositiveInt,
        } = immunizationEvaluation;

        const formData = {
            status: status,
            date: formatDateTimeForInput(date),
            authority: authority,
            targetDisease: transformFromCodeableConcept(targetDisease),
            immunizationEvent: immunizationEvent,
            doseStatus: transformFromCodeableConcept(doseStatus),
            doseStatusReason: transformFromCodeableConcept(doseStatusReason ?? []),
            description: description ?? '',
            series: series ?? '',
            doseNumberPositiveInt: doseNumberPositiveInt?.toString() ?? '',
            seriesDosesPositiveInt: seriesDosesPositiveInt?.toString() ?? ''
        };

        return formData;
    }, [transformFromCodeableConcept, formatDateTimeForInput]);

    const getImmunizationEvaluationDisplay = (immunizationEvaluation: ImmunizationEvaluation): string => {
        if (!immunizationEvaluation) {
            return 'Unknown Immunization Evaluation';
        }

        const targetDisease = formatFhirCodeableConcept(immunizationEvaluation.targetDisease) || 'Immunization Evaluation';
        // - the human label, never the code. `statusLabel` returns `undefined` for a code we
        // have no words for, and this omits the status entirely in that case rather than falling back to
        // the raw value - the fallback IS the defect. `utils/fhirStatusVocabulary.ts`
        const statusText = statusLabel(immunizationEvaluation.status);
        const status = statusText ? ` · ${statusText}` : '';

        let dateSuffix = '';
        if (immunizationEvaluation.date) {
            dateSuffix = ` (${formatDateTimeForDisplay(immunizationEvaluation.date)})`;
        }

        return `${targetDisease}${status}${dateSuffix}`;
    };

    return {
        // WHO THE CACHED LIST IS FOR, so a consumer can ask whether it belongs to the patient on
        // screen rather than trusting an app-wide context with no patient in its name.
        cachedForPatientId: cacheOwner.ownerId,
        immunizationEvaluationsBundle,
        immunizationEvaluationsList,
        setImmunizationEvaluationsList,
        shouldReload,
        setShouldReload,
        lastUpserted,
        setLastUpserted,
        unsaved,
        setUnsaved,

        fetchImmunizationEvaluations,
        fetchImmunizationEvaluationsWithPolling,
        fetchImmunizationEvaluation,
        fetchImmunizationEvaluationHistory,
        createImmunizationEvaluation,
        updateImmunizationEvaluation,
        deleteImmunizationEvaluation,
        archiveImmunizationEvaluation,

        transformToFhirImmunizationEvaluation,
        transformFromFhirImmunizationEvaluation,
        getImmunizationEvaluationDisplay
    };
};

const ImmunizationEvaluationServiceContext = createContext<ReturnType<typeof useImmunizationEvaluationService> | undefined>(undefined);

export const ImmunizationEvaluationServiceProvider: React.FC<{ children: ReactNode }> = ({ children }) => {
    const immunizationEvaluationService = useImmunizationEvaluationService();

    return (
        <ImmunizationEvaluationServiceContext.Provider value={immunizationEvaluationService}>
            {children}
        </ImmunizationEvaluationServiceContext.Provider>
    );
};

export const useImmunizationEvaluationServiceContext = () => {
    const context = useContext(ImmunizationEvaluationServiceContext);

    if (context === undefined) {
        throw new Error('useImmunizationEvaluationServiceContext must be used within a ImmunizationEvaluationServiceProvider');
    }

    return context;
};