import { useEffect, useMemo, useState, type ReactNode } from 'react';
import { Outlet, useLocation } from 'react-router-dom';
import { useAuthServiceContext } from '../../../../services/AuthService';
import { authSessionId } from '../../../../services/authStorage';
import { AgreementBlocks } from '../../../../components/FirstSignInGate/AgreementBlocks';
import { useMsaRecovery, type MsaRecoveryLocator, type MsaRecoveryOpening } from '../../../../hooks/useMsaRecovery';
import { heldMsaKey, msaOperationId, readHeldMsa, type HeldMsaOperation } from '../../../../utils/msaRecovery';
import { msaClosingLines, resolveMsaBlocks } from '../../../../utils/msaAgreement';
import { formatDayMonthYear } from '../../../../utils/dateUtils';
import type { BaaSignFormParts } from './BaaSignForm';

type Parts = (parts: BaaSignFormParts) => ReactNode;

const RecoveryView = ({ opening, children }: { opening: MsaRecoveryOpening; children: Parts }) => {
    const { read, busy, error, actorMatches, canResume, check, resume } = opening;
    const preview = actorMatches && read?.actorMayResume ? read.frozen?.preview : undefined;
    const request = read?.frozen?.request;
    const facts = preview && request ? { ...preview.facts, signerName: request.signerName, signerTitle: request.signerTitle, signDate: request.signDate } : undefined;
    const body = <div className="space-y-4">
        <p className="text-sm">This checks the acceptance you already started. It does not start a new agreement or change your Business Associate Agreement.</p>
        {busy && <p role="status">Checking your original acceptance…</p>}
        {error && <p role="status">{error}</p>}
        {!busy && read?.state === 'accepted' && actorMatches && <p role="status">Version {read.version} accepted on {formatDayMonthYear(read.acceptedAt ?? '')}. Your original acceptance is confirmed.</p>}
        {!busy && read?.state === 'absent' && <p role="status">Your original acceptance has not been found yet. Check again; a delayed request may still arrive.</p>}
        {!busy && read?.state === 'conflict' && <p role="status">This acceptance needs Akashic support. Its original reference has been kept.</p>}
        {!busy && read && read.state !== 'absent' && !actorMatches && <p role="status">This acceptance belongs to another sign-in. Use the original account to check it.</p>}
        {!busy && read?.state === 'admitted' && actorMatches && (!read.actorMayResume || !preview) && <p role="status">The original agreement could not be confirmed for recording. Check again before continuing.</p>}
        {!busy && read?.state === 'admitted' && actorMatches && read.actorMayResume && preview && <p role="status">Your acceptance could not be confirmed yet. Resume recording to finish that same acceptance.</p>}
        {preview && facts && <div className="baa-published space-y-3 rounded border border-border bg-muted p-4 text-sm">
            <p className="font-medium">{preview.title}</p>
            <AgreementBlocks blocks={resolveMsaBlocks(preview.blocks, facts)} />
            {msaClosingLines(facts).map((line) => <p key={line}>{line}</p>)}
        </div>}
    </div>;
    const actions = <div className="flex flex-wrap justify-end gap-2">
        <button type="button" className="btn btn-blue-ghost" disabled={busy} onClick={() => void check()}>Check again</button>
        {canResume && <button type="button" className="btn btn-green" onClick={() => void resume()}>Resume recording</button>}
    </div>;
    return <>{children({ body, actions, wide: true })}</>;
};

export const MsaRecoveryPage = ({ opening }: { opening: MsaRecoveryOpening }) => <div>
    <div className="text-start pb-2 px-2"><h1 className="ak-page-title">Master Subscription Agreement</h1></div>
    <div className="ak-page-body space-y-4"><RecoveryView opening={opening}>{({ body, actions }) => <>{body}{actions}</>}</RecoveryView></div>
</div>;

const HeldOpening = ({ locator, onAccepted, children }: { locator: MsaRecoveryLocator; onAccepted: () => void; children: Parts }) => {
    const opening = useMsaRecovery(locator, onAccepted);
    return <RecoveryView opening={opening}>{children}</RecoveryView>;
};

export const MsaHeldForm = ({ held, onAccepted, children }: { held: HeldMsaOperation; onAccepted: () => void; children: Parts }) => {
    const { currentUser, wpOrganization, actingAsSessionRef } = useAuthServiceContext();
    const practitionerId = currentUser?.fhir?.resourceType === 'Practitioner' ? currentUser.fhir.id : undefined;
    if (!practitionerId || currentUser?.cognito?.sub !== held.actorId || wpOrganization.current?.id !== held.organizationId) {
        return <p role="status">Use the original sign-in and practice to check this acceptance.</p>;
    }
    const key = [held.request.operationId, held.actorId, practitionerId, authSessionId(), actingAsSessionRef.current].join('|');
    return <HeldOpening key={key} locator={{ organizationId: held.organizationId, actorId: held.actorId, practitionerId, operationId: held.request.operationId, held }}
        onAccepted={onAccepted}>{children}</HeldOpening>;
};

const RouteOpening = ({ locator, renderOpening }: { locator: MsaRecoveryLocator; renderOpening?: (opening: MsaRecoveryOpening) => ReactNode }) => {
    const [captured] = useState(locator);
    const opening = useMsaRecovery(captured);
    return opening.canOpen
        ? <>{renderOpening ? renderOpening(opening) : <Outlet context={opening} />}</>
        : <MsaRecoveryPage opening={opening} />;
};

/** Only this MSA route receives the recovery opening; the existing fresh-owner sheet remains its fallback. */
export const MsaRecoveryAccess = ({ fallback, renderOpening }: { fallback: ReactNode; renderOpening?: (opening: MsaRecoveryOpening) => ReactNode }) => {
    const { currentUser, wpOrganization, actingAsSessionRef } = useAuthServiceContext();
    const { search } = useLocation();
    const organizationId = wpOrganization.current?.id;
    const actorId = currentUser?.cognito?.sub;
    const practitionerId = currentUser?.fhir?.resourceType === 'Practitioner' ? currentUser.fhir.id : undefined;
    const [revision, setRevision] = useState(0);
    useEffect(() => {
        const changed = (event: StorageEvent) => {
            if (organizationId && actorId && (event.key === null || event.key === heldMsaKey(organizationId, actorId)
                || event.key?.startsWith(heldMsaKey(organizationId, actorId) + '.op.'))) setRevision((n) => n + 1);
        };
        window.addEventListener('storage', changed);
        return () => window.removeEventListener('storage', changed);
    }, [organizationId, actorId]);
    const held = useMemo(() => organizationId && actorId ? readHeldMsa(organizationId, actorId) : undefined, [organizationId, actorId, revision]);
    const requested = new URLSearchParams(search).get('msaOperation');
    if (!held && requested === null) return <>{fallback}</>;
    const operationId = requested ?? (held && held !== 'unavailable' ? held.request.operationId : undefined);
    if (!organizationId || !actorId || !practitionerId || !msaOperationId(operationId)) return <div role="status">
        <p>Your previous acceptance could not be read safely. Contact Akashic support before starting another.</p>
        <button type="button" className="btn btn-blue-ghost" onClick={() => setRevision((n) => n + 1)}>Check again</button>
    </div>;
    const saved = held && held !== 'unavailable' && held.request.operationId === operationId ? held : undefined;
    const key = [organizationId, actorId, practitionerId, operationId, authSessionId(), actingAsSessionRef.current, saved ? JSON.stringify(saved.request) : 'discovered'].join('|');
    return <RouteOpening key={key} locator={{ organizationId, actorId, practitionerId, operationId, held: saved }} renderOpening={renderOpening} />;
};