import { ReactNode, useState, useCallback, createContext, useContext } from 'react';
import { environment } from '../environments/environment.ts';
import { useHttpService } from './HttpService.tsx';

const API_URL = environment.fhirIdentityApi;

export interface DuplicateMatchSummary {
    matchId: string;
    matchedOn: string[];
    status: 'open' | 'challenge-sent' | 'confirmed-linked' | 'dismissed-family' | 'dismissed-not-me';
    linkStatus?: 'pending' | 'linked';
    continuation?: 'verification-required' | 'resume' | 'support-required';
    supportRequired?: boolean;
    createdAt: string;
}

export interface DuplicateMatchChallengeResponse {
    maskedEmail: string;
}

export interface DuplicateMatchConfirmResponse {
    status: 'linked' | 'link-pending';
    reLogin?: boolean;
    survivorMaskedEmail?: string;
    continuation?: 'verification-required' | 'resume' | 'support-required' | 'complete';
    duplicateDisablePending?: boolean;
    pendingDuties?: ('notice' | 'relink' | 'audit')[];
    supportRequired?: boolean;
}

export interface DuplicateMatchDismissResponse {
    status: string;
}

export const useDuplicateMatchService = () => {
    const { get, post } = useHttpService();

    const [openMatches, setOpenMatches] = useState<DuplicateMatchSummary[]>([]);

    const fetchOpenMatches = useCallback(async (): Promise<DuplicateMatchSummary[]> => {
        const matches = await get<DuplicateMatchSummary[]>(`${API_URL}/DuplicateMatch`);

        setOpenMatches(matches);

        return matches;
    }, [get]);

    const requestChallenge = useCallback((matchId: string): Promise<DuplicateMatchChallengeResponse> => {
        return post<DuplicateMatchChallengeResponse>(`${API_URL}/DuplicateMatch/challenge`, { matchId });
    }, [post]);

    const confirmMatch = useCallback((matchId: string, code?: string): Promise<DuplicateMatchConfirmResponse> => {
        return post<DuplicateMatchConfirmResponse>(`${API_URL}/DuplicateMatch/confirm`, { matchId, ...(code ? { code } : {}) });
    }, [post]);

    const dismissMatch = useCallback((matchId: string, reason: 'family' | 'not-me'): Promise<DuplicateMatchDismissResponse> => {
        return post<DuplicateMatchDismissResponse>(`${API_URL}/DuplicateMatch/dismiss`, { matchId, reason });
    }, [post]);

    return {
        openMatches,
        setOpenMatches,

        fetchOpenMatches,
        requestChallenge,
        confirmMatch,
        dismissMatch
    };
};

const DuplicateMatchServiceContext = createContext<ReturnType<typeof useDuplicateMatchService> | undefined>(undefined);

export const DuplicateMatchServiceProvider: React.FC<{ children: ReactNode }> = ({ children }) => {
    const duplicateMatchService = useDuplicateMatchService();

    return (
        <DuplicateMatchServiceContext.Provider value={duplicateMatchService}>
            {children}
        </DuplicateMatchServiceContext.Provider>
    );
};

export const useDuplicateMatchServiceContext = () => {
    const context = useContext(DuplicateMatchServiceContext);

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

    return context;
};