import { useEffect, useRef, useState } from 'react';
import { AlertCircle, CheckCircle2, Loader2 } from 'lucide-react';
import type { Address, Organization } from 'fhir/r4';
import { useAuthServiceContext } from '../../../services/AuthService.tsx';
import { useOrganizationServiceContext } from '../../../services/OrganizationService.tsx';
import { useStaffPermissionServiceContext } from '../../../services/StaffPermissionService';
import { formatCampaignPostalAddress, resolveCampaignMailingAddress } from '../../../config/campaignMailingAddress.ts';
import { Button } from '../../../components/ui/button.tsx';
import { Checkbox } from '../../../components/ui/checkbox.tsx';
import { Input } from '../../../components/ui/input.tsx';
import { Label } from '../../../components/ui/label.tsx';
import { Alert, AlertDescription } from '../../../components/ui/alert.tsx';
import { relayServerFailure } from '../../../utils/fetchFailureMessage';
import SandboxDisabled from '../../../components/SandboxMode/SandboxDisabled';
import { environment } from '../../../environments/environment';
import { isSaveRetired, isSaveTimedOut, useSaveScope } from '../../../utils/saveOperation';
import { holdSettingsWrite, settingsWriteHolder, unresolvedSettingsWrite, useUnresolvedSettingsWrite, type UnresolvedSettingsWrite } from '../../../utils/unresolvedSettingsWrite';

const EMPTY: Address = { line: [''], city: '', state: '', postalCode: '', country: 'US' };
const UNKNOWN = 'The mailing-address save could not be confirmed. Check the saved mailing address before saving again.';
const normalized = (address: Address): Address => ({
    line: (address.line ?? []).map(line => line.trim()).filter(Boolean),
    city: address.city?.trim(), state: address.state?.trim(), postalCode: address.postalCode?.trim(),
    ...(address.country?.trim() ? { country: address.country.trim() } : {}),
});
const readableOrganization = (value: Organization | undefined, id: string): value is Organization =>
    value?.resourceType === 'Organization' && value.id === id && typeof value.meta?.versionId === 'string' && Boolean(value.meta.versionId);
const readableSetting = (value: { source?: unknown; effectiveAddress?: Address | null } | undefined): boolean => {
    if (value?.source === 'none') return value.effectiveAddress === null;
    if (value?.source !== 'primary' && value?.source !== 'override') return false;
    const address = value.effectiveAddress;
    return Boolean(address && Array.isArray(address.line) && address.line.every(line => typeof line === 'string') && address.line.some(line => typeof line === 'string' && line.trim())
        && [address.city, address.state, address.postalCode].every(part => typeof part === 'string' && part.trim()));
};


const CampaignMailingAddressSection = () => {
    const auth = useAuthServiceContext();
    const { setWpOrganization } = auth;
    const currentOrganization = auth.currentOrganization ?? undefined;
    const { updateCampaignMailingAddress, fetchOrganizationAsCaller } = useOrganizationServiceContext();
    const { permissionsSettled, canManage } = useStaffPermissionServiceContext();
    const mayManage = permissionsSettled && canManage('organization');
    const current = useRef({ organization: currentOrganization, mayManage });
    current.current = { organization: currentOrganization, mayManage };
    const [baseline, setBaseline] = useState<Organization | undefined>(currentOrganization);
    const [resolved, setResolved] = useState(() => resolveCampaignMailingAddress(currentOrganization));
    const [useOverride, setUseOverride] = useState(false);
    const [draft, setDraft] = useState<Address>(EMPTY);
    const [saving, setSaving] = useState(false);
    const [checking, setChecking] = useState(false);
    const [needsRead, setNeedsRead] = useState(false);
    const [checked, setChecked] = useState(false);
    const [error, setError] = useState<string>();
    const [saved, setSaved] = useState(false);
    const generation = useRef(0);
    const working = useRef(false);
    const holder = settingsWriteHolder(`campaign-mailing-address:${currentOrganization?.id ?? ''}`);
    const held = useUnresolvedSettingsWrite(holder);
    const seed = (organization: Organization | undefined) => {
        const setting = resolveCampaignMailingAddress(organization);
        setUseOverride(setting.source === 'override');
        setDraft(setting.source === 'override' && setting.address ? setting.address : EMPTY);
    };
    const scope = useSaveScope(mayManage ? currentOrganization?.id : undefined, () => {
        working.current = false;
        setSaving(false); setChecking(false); setError(undefined); setSaved(false); setChecked(false);
        setNeedsRead(false); setBaseline(current.current.organization); setResolved(resolveCampaignMailingAddress(current.current.organization)); seed(current.current.organization);
        generation.current += 1;
    });
    useEffect(() => {
        setBaseline(currentOrganization); setResolved(resolveCampaignMailingAddress(currentOrganization)); seed(currentOrganization);
        setError(undefined); setSaved(false); setChecked(false); setNeedsRead(false);
        generation.current += 1;
    }, [currentOrganization?.id]);

    const patch = (field: keyof Address, value: string) => {
        generation.current += 1;
        setDraft(prev => field === 'line' ? { ...prev, line: [value] } : { ...prev, [field]: value });
        setSaved(false);
    };
    const handleSave = async () => {
        const organizationId = currentOrganization?.id;
        const versionId = baseline?.meta?.versionId;
        if (environment.inSandboxMode || !current.current.mayManage || !organizationId || baseline?.id !== organizationId || !versionId || needsRead || working.current || unresolvedSettingsWrite(holder)) return;
        const operation = scope.start();
        const admittedOrganization = current.current.organization;
        const draftGeneration = generation.current;
        const address = useOverride ? normalized(draft) : null;
        let sent = false;
        let ownHold: UnresolvedSettingsWrite | undefined;
        const settle = () => { if (ownHold && unresolvedSettingsWrite(holder) === ownHold) holdSettingsWrite(holder, undefined); };
        const transport = {
            ...operation.transport, organizationId, versionId,
            admit: () => { operation.admit(); if (!current.current.mayManage || current.current.organization?.id !== organizationId) throw new Error('Your current practice cannot save this setting.');
                if (unresolvedSettingsWrite(holder) && unresolvedSettingsWrite(holder) !== ownHold) throw new Error(UNKNOWN); },
            onSend: () => {
                operation.admit(); sent = true;
                ownHold = { kind: 'campaign-mailing-address', state: 'unconfirmed', detail: versionId };
                holdSettingsWrite(holder, ownHold);
            },
        };
        working.current = true; setSaving(true); setError(undefined); setSaved(false); setChecked(false);
        try {
            const answer = await operation.step(() => updateCampaignMailingAddress({ address }, transport).catch(error => {
                const status = (error as { status?: unknown } | null)?.status;
                if (typeof status === 'number' && status >= 400 && status < 500) settle();
                throw error;
            }), true);
            operation.admit();
            if (!readableOrganization(answer?.organization, organizationId)
                || !readableSetting(answer?.settings)) throw new Error(UNKNOWN);
            let confirmed = answer.organization;
            let effective = { address: answer.settings.effectiveAddress, source: answer.settings.source };
            if (current.current.organization !== admittedOrganization) {
                const beforeRead = current.current.organization;
                confirmed = await operation.step(() => fetchOrganizationAsCaller(organizationId, undefined, organizationId, operation.transport));
                if (!readableOrganization(confirmed, organizationId)) throw new Error(UNKNOWN);
                effective = resolveCampaignMailingAddress(confirmed);
                operation.admit();
                if (current.current.organization !== beforeRead) throw new Error(UNKNOWN);
                setWpOrganization(confirmed);
            } else setWpOrganization(confirmed);
            operation.admit();
            setBaseline(confirmed); setResolved(effective); settle();
            if (generation.current === draftGeneration) { seed(confirmed); setSaved(true); }
            else setError('The earlier mailing address was saved. Your newer changes have not been saved.');
        } catch (failure) {
            if (isSaveRetired(failure) || !operation.belongs()) return;
            const status = (failure as { status?: unknown } | null)?.status;
            if (sent && unresolvedSettingsWrite(holder) === ownHold) setError(UNKNOWN);
            else {
                setError(isSaveTimedOut(failure) ? 'The save timed out before it was sent. Try again.' : relayServerFailure(failure, 'Failed to save this setting. Please try again.'));
                if (status === 412 || status === 428) setNeedsRead(true);
            }
        } finally {
            if (operation.belongs()) { working.current = false; setSaving(false); }
            operation.retire();
        }
    };
    const checkCurrent = async () => {
        const organizationId = currentOrganization?.id;
        if (working.current || !organizationId || !current.current.mayManage || environment.inSandboxMode) return;
        const operation = scope.start();
        const draftGeneration = generation.current;
        const beforeRead = current.current.organization;
        const heldAtStart = unresolvedSettingsWrite(holder);
        working.current = true; setChecking(true); setError(undefined);
        try {
            const read = await operation.step(() => fetchOrganizationAsCaller(organizationId, undefined, organizationId, operation.transport));
            if (!readableOrganization(read, organizationId)) throw new Error('The current saved mailing address could not be read. Try the check again.');
            operation.admit();
            if (current.current.organization !== beforeRead) throw new Error('The practice changed during the check. Check again.');
            setWpOrganization(read);
            setBaseline(read); setResolved(resolveCampaignMailingAddress(read)); if (generation.current === draftGeneration) seed(read);
            if (unresolvedSettingsWrite(holder) === heldAtStart) holdSettingsWrite(holder, undefined);
            setNeedsRead(false); setChecked(true); setSaved(false);
        } catch (failure) {
            if (isSaveRetired(failure) || !operation.belongs()) return;
            setError('The current saved mailing address could not be read. Save remains unavailable until it is checked.');
        } finally {
            if (operation.belongs()) { working.current = false; setChecking(false); }
            operation.retire();
        }
    };

    return (
        <SandboxDisabled>
        <div className="ahr-campaign-mailing-address space-y-4">
            <div>
                <h2 className="ak-section-title">Marketing Email Mailing Address</h2>
                <p className="ak-card__description">
                    The law requires a physical mailing address in every marketing email. By default
                    we use your practice&apos;s primary address.
                </p>
            </div>

            {(error || held) && (
                <Alert variant="destructive">
                    <AlertCircle />
                    <AlertDescription>{error ?? UNKNOWN}</AlertDescription>
                </Alert>
            )}

            {saved && (
                <Alert>
                    <CheckCircle2 />
                    <AlertDescription>Mailing address saved.</AlertDescription>
                </Alert>
            )}

            {resolved.source === 'none' && !useOverride && (
                <Alert variant="destructive">
                    <AlertCircle />
                    <AlertDescription>
                        Your practice has no primary address on file, so marketing emails cannot be
                        sent yet. Add one under Locations, or set a mailing address below.
                    </AlertDescription>
                </Alert>
            )}

            {resolved.source !== 'none' && (
                <p className="text-sm">
                    <span className="text-muted-foreground">
                        {resolved.source === 'override'
                            ? 'Marketing emails currently show: '
                            : 'Marketing emails currently show your primary address: '}
                    </span>
                    <span className="font-medium">
                        {formatCampaignPostalAddress(resolved.address as Address)}
                    </span>
                </p>
            )}

            <div className="flex items-start gap-2">
                <Checkbox
                    id="campaign-mailing-override"
                    checked={useOverride}
                    disabled={!mayManage || checking || environment.inSandboxMode}
                    onCheckedChange={(checked) => {
                        generation.current += 1;
                        setUseOverride(checked === true);
                        setSaved(false);
                    }}
                />
                <div>
                    <Label htmlFor="campaign-mailing-override">
                        Use a different mailing address for marketing emails
                    </Label>
                    <p className="ak-field-help">
                        Only if your mail goes somewhere other than your practice address — a PO box,
                        a billing office, or a management company.
                    </p>
                </div>
            </div>

            {useOverride && (
                <div className="grid gap-3 sm:grid-cols-2">
                    <div className="sm:col-span-2">
                        <Label htmlFor="campaign-mailing-line">Street address</Label>
                        <Input
                            id="campaign-mailing-line"
                            value={draft.line?.[0] ?? ''}
                            disabled={!mayManage || checking || environment.inSandboxMode}
                            onChange={(event) => patch('line', event.target.value)}
                        />
                    </div>
                    <div>
                        <Label htmlFor="campaign-mailing-city">City</Label>
                        <Input
                            id="campaign-mailing-city"
                            value={draft.city ?? ''}
                            disabled={!mayManage || checking || environment.inSandboxMode}
                            onChange={(event) => patch('city', event.target.value)}
                        />
                    </div>
                    <div>
                        <Label htmlFor="campaign-mailing-state">State</Label>
                        <Input
                            id="campaign-mailing-state"
                            value={draft.state ?? ''}
                            disabled={!mayManage || checking || environment.inSandboxMode}
                            onChange={(event) => patch('state', event.target.value)}
                        />
                    </div>
                    <div>
                        <Label htmlFor="campaign-mailing-postal">ZIP code</Label>
                        <Input
                            id="campaign-mailing-postal"
                            value={draft.postalCode ?? ''}
                            disabled={!mayManage || checking || environment.inSandboxMode}
                            onChange={(event) => patch('postalCode', event.target.value)}
                        />
                    </div>
                </div>
            )}

            {(held || needsRead || !baseline?.meta?.versionId) && <Button className="btn btn-blue" disabled={saving || checking || !mayManage || environment.inSandboxMode} onClick={() => void checkCurrent()}>
                {checking ? 'Checking…' : 'Check saved mailing address'}
            </Button>}
            {checked && <p role="status">Current saved mailing address checked. This does not confirm the earlier request.</p>}
            {!mayManage && <p>{permissionsSettled ? 'Ask a practice administrator to change the marketing mailing address.' : 'Checking your permissions.'}</p>}
            <Button className="btn btn-green" onClick={() => void handleSave()} disabled={saving || checking || needsRead || Boolean(held) || !mayManage || (!baseline?.meta?.versionId || baseline.id !== currentOrganization?.id) || environment.inSandboxMode}>
                {saving && <Loader2 className="animate-spin" />}
                Save
            </Button>
        </div>
        </SandboxDisabled>
    );
};

export default CampaignMailingAddressSection;