import { Sheet, SheetContent, SheetDescription, SheetHeader, SheetTitle } from '../ui/sheet';
import { useCallback, useEffect, useRef, useState } from 'react';
import { CheckboxControl } from '../ui/checkbox-control';
import { useSandboxEntry } from './useSandboxEntry';
import { CHECK_FAILED_COPY } from './sandboxLifecycle';
import RestoreSetupSheet from './RestoreSetupSheet';
import { PREPARING_LABEL } from './prepareSandbox';
import { readSandboxAgreement, type SandboxAgreementAnswer } from './sandboxAgreement';
import { AgreementBlocks } from '../FirstSignInGate/AgreementBlocks';
import { environment } from '../../environments/environment';
import { useHttpService } from '../../services';
import type { SaveTransport } from '../../utils/saveOperation';
import './SandboxEntryDialog.css';

type SandboxEntryDialogProps = {
    onClose: () => void;
    beforeEnter?: (transport: SaveTransport) => Promise<void>;
};

export const AGREEMENT_LOADING_COPY = 'Loading the Sandbox agreement...';
export const AGREEMENT_NONE_COPY = 'Sandbox Mode is not available yet: no Sandbox agreement has been published.';
export const AGREEMENT_UNREADABLE_COPY = 'The Sandbox agreement could not be loaded, so Sandbox Mode cannot open. Try again.';

// The agreement and entry flow, opened from the header's mode menu and from the setup row - every door into the
// sandbox. The copy is the Sandbox agreement published on the live stack, read fresh on each opening; the box
// starts unchecked each time and again whenever the copy changes, and only the copy on screen is agreed to.
const SandboxEntryDialog = ({ onClose, beforeEnter }: SandboxEntryDialogProps) => {
    const {
        enter, owner, pending, refusal, notice, restore, canRestore,
        restoreHeld, restoreStatus, checkFailed, canResume, checkRestore, resumeRestore,
    } = useSandboxEntry(beforeEnter);
    const { get } = useHttpService();
    const [confirmingRestore, setConfirmingRestore] = useState(false);
    // Copy and choice belong to the owner they were read and made under; another owner sees neither.
    const [agreement, setAgreement] = useState<{ owner: number; answer: SandboxAgreementAnswer | 'loading' }>({ owner, answer: 'loading' });
    const [choice, setChoice] = useState<{ owner: number; agreed: boolean }>({ owner, agreed: false });
    const readRef = useRef<AbortController | null>(null);
    // The latest transport, read at call time: a new `get` on a render is not a new opening and asks nothing again.
    const getRef = useRef(get);
    getRef.current = get;

    // Each read retires the one before it, and closing the sheet retires the last, so a late answer never shows.
    const read = useCallback((forOwner: number) => {
        readRef.current?.abort();
        const controller = new AbortController();
        readRef.current = controller;
        setAgreement({ owner: forOwner, answer: 'loading' });
        setChoice({ owner: forOwner, agreed: false });
        const deliver = (answer: SandboxAgreementAnswer) => {
            if (readRef.current === controller && !controller.signal.aborted) setAgreement({ owner: forOwner, answer });
        };
        readSandboxAgreement(getRef.current, environment.liveFhirFoundationApi, controller.signal)
            .then(deliver)
            .catch(() => deliver({ kind: 'unreadable' }));
    }, []);

    useEffect(() => {
        read(owner);
        return () => { readRef.current?.abort(); readRef.current = null; };
    }, [read, owner]);

    const answer = agreement.owner === owner ? agreement.answer : 'loading';
    const agreed = choice.owner === owner && choice.agreed;
    const setAgreed = (next: boolean) => setChoice({ owner, agreed: next });
    const copy = answer !== 'loading' && answer.kind === 'ready' ? answer.copy : undefined;
    const agree = async () => {
        if (!copy) return;
        const askedBy = owner;
        if (await enter(copy, askedBy) === 'changed') read(askedBy);
    };

    return (
        <>
            {confirmingRestore && (
                <RestoreSetupSheet
                    pending={pending}
                    error={null}
                    onConfirm={() => { setConfirmingRestore(false); void restore(); }}
                    onClose={() => setConfirmingRestore(false)}
                />
            )}
            <Sheet open onOpenChange={(open) => !open && !pending && onClose()}>
                <SheetContent
                    className="ak-panel gap-0 sm:max-w-none"
                    showCloseButton={!pending}
                    onEscapeKeyDown={(event) => pending && event.preventDefault()}
                    onInteractOutside={(event) => pending && event.preventDefault()}
                >
                    <SheetHeader className="ak-overlay__header">
                        <SheetTitle>You are entering Sandbox Mode</SheetTitle>
                        <SheetDescription className="ak-overlay__description">
                            Sandbox is a practice copy for training and trying things out. Everything in it is made-up sample data.
                        </SheetDescription>
                    </SheetHeader>
                    <div className="ak-overlay__body flex-1">
                        {answer === 'loading' && <p role="status" className="ak-field-help">{AGREEMENT_LOADING_COPY}</p>}
                        {answer !== 'loading' && answer.kind === 'none' && <p role="alert" className="ak-field-error">{AGREEMENT_NONE_COPY}</p>}
                        {answer !== 'loading' && answer.kind === 'unreadable' && <p role="alert" className="ak-field-error">{AGREEMENT_UNREADABLE_COPY}</p>}
                        {copy && (
                            <>
                            <section className="max-h-[50vh] sm:max-h-[60vh] space-y-3 overflow-y-auto rounded border border-border bg-muted p-4 text-sm text-foreground" aria-label={copy.title}>
                                {copy.blocks ? <AgreementBlocks blocks={copy.blocks} /> : (
                                    <>
                                        <h2>{copy.title}</h2>
                                        {copy.body.split('\n').filter((line) => line.trim()).map((line, i) => <p key={i}>{line}</p>)}
                                    </>
                                )}
                            </section>
                            <p className="ak-field-help">Sandbox agreement, version {copy.version}</p>
                            </>
                        )}
                        <p className="ak-field-help">Entering takes about a minute the first time, and you accept the Terms once inside.</p>
                        <CheckboxControl
                            label="I understand. I will use only made-up information in Sandbox."
                            checked={agreed}
                            onChange={setAgreed}
                            disabled={pending || !copy || restoreHeld}
                        />
                        {refusal && <p role="alert" className="ak-field-error">{refusal}</p>}
                        {notice && <p role="status" className="ak-field-help">{notice}</p>}
                        {restoreStatus && <p role="status" className="ak-field-help">{restoreStatus}</p>}
                        {checkFailed && <p role="alert" className="ak-field-error">{CHECK_FAILED_COPY}</p>}
                    </div>
                    <div className="ak-overlay__footer">
                        {restoreHeld && (
                            <button type="button" onClick={() => void checkRestore()} className="btn btn-blue-ghost">
                                Check
                            </button>
                        )}
                        {canResume && (
                            <button type="button" onClick={() => void resumeRestore()} disabled={pending} className="btn btn-blue-ghost">
                                Resume
                            </button>
                        )}
                        {canRestore && (
                            <button type="button" onClick={() => setConfirmingRestore(true)} disabled={pending} className="btn btn-blue-ghost">
                                Restore setup from live
                            </button>
                        )}
                        {answer !== 'loading' && answer.kind === 'unreadable' && (
                            <button type="button" onClick={() => read(owner)} disabled={pending} className="btn btn-blue-ghost">
                                Try again
                            </button>
                        )}
                        <button type="button" onClick={onClose} disabled={pending} className="btn btn-blue-ghost">
                            Cancel
                        </button>
                        <button type="button" onClick={() => void agree()} disabled={pending || !agreed || !copy || restoreHeld} className="btn btn-blue">
                            {pending ? PREPARING_LABEL : 'Enter Sandbox'}
                        </button>
                    </div>
                </SheetContent>
            </Sheet>
        </>
    );
};

export default SandboxEntryDialog;