import { useState } from 'react';
import { useTranslation } from 'react-i18next';
import { Button, Badge, Checkbox } from '@/Components/ui';
import { Loader2, CheckCircle2, XCircle, Circle, Download, RotateCcw, AlertTriangle, ShieldCheck, ShieldAlert } from 'lucide-react';

const STEPS = ['check', 'download', 'verify', 'extract', 'preflight', 'backup', 'apply', 'migrate', 'finalize'];

const box = {
    error: 'border-red-200 bg-red-50 text-red-800 dark:border-red-800 dark:bg-red-900/20 dark:text-red-300',
    success: 'border-green-200 bg-green-50 text-green-800 dark:border-green-800 dark:bg-green-900/20 dark:text-green-300',
    warning: 'border-amber-200 bg-amber-50 text-amber-800 dark:border-amber-800 dark:bg-amber-900/20 dark:text-amber-300',
};

function Notice({ tone, icon: Icon, children }) {
    return (
        <div className={`flex items-start gap-2 rounded-lg border px-4 py-3 text-sm ${box[tone]}`}>
            <Icon className="mt-0.5 h-4 w-4 shrink-0" />
            <div className="min-w-0 break-words">{children}</div>
        </div>
    );
}

function StepIcon({ status, active }) {
    if (active || status === 'running') return <Loader2 className="h-4 w-4 animate-spin text-brand-600" />;
    if (status === 'done') return <CheckCircle2 className="h-4 w-4 text-green-600" />;
    if (status === 'failed') return <XCircle className="h-4 w-4 text-red-600" />;
    return <Circle className="h-4 w-4 text-neutral-300 dark:text-neutral-600" />;
}

/**
 * Drives the staged in-app updater: each step (download → … → finalize) is its
 * own request to the token-authenticated runner, so no single request has to
 * survive the whole update and every step runs with freshly loaded code.
 * `initialRun` is the persisted run state, so a reload resumes where it stopped.
 */
export default function UpdateRunner({ update, initialRun = null }) {
    const { t } = useTranslation();
    const [run, setRun] = useState(initialRun);
    const [session, setSession] = useState(null); // { token, runner }
    const [busy, setBusy] = useState(null); // 'install' | 'rollback' | 'status' | 'discard'
    const [activeStep, setActiveStep] = useState(null);
    const [error, setError] = useState(null); // { message, reason?, network? }
    const [notice, setNotice] = useState(null);
    const [skipDb, setSkipDb] = useState(false);

    const finished = run && ['completed', 'rolled_back'].includes(run.status);
    const inProgress = run && !finished;
    const canInstall = update?.ok && update.update_available && !inProgress
        && !(run?.status === 'completed' && run.version === update.version);

    const failure = (err) => {
        const payload = err?.response?.data;
        if (payload?.state !== undefined) setRun(payload.state);
        setError(payload?.message
            ? { message: payload.message, reason: payload.reason }
            : { message: t('updater.network_error'), network: true });
    };

    const runnerPost = async (sess, url, data = {}) => {
        const res = await window.axios.post(url, data, { headers: { 'X-Update-Token': sess.token }, timeout: 0 });
        return res.data;
    };

    const openSession = async () => {
        const res = await window.axios.post(route('admin.license.update.resume'));
        const sess = { token: res.data.token, runner: res.data.runner };
        setSession(sess);
        setRun(res.data.state);
        return { sess, state: res.data.state };
    };

    // Run the remaining steps one request at a time until done or a failure.
    const drive = async (sess, state, options = {}) => {
        let current = state;
        let opts = options;
        while (current?.next_step) {
            const step = current.next_step;
            setActiveStep(step);
            let data;
            try {
                data = await runnerPost(sess, sess.runner.steps[step], opts);
            } catch (err) {
                failure(err);
                return;
            }
            opts = {};
            current = data.state;
            setRun(current);
        }
        if (current?.status === 'completed') {
            setNotice(t('updater.completed', { version: current.version }));
        }
    };

    const withBusy = (kind, fn) => async (...args) => {
        setBusy(kind);
        setError(null);
        setNotice(null);
        try {
            await fn(...args);
        } catch (err) {
            failure(err);
        } finally {
            setBusy(null);
            setActiveStep(null);
        }
    };

    const install = withBusy('install', async () => {
        if (!window.confirm(t('updater.install_confirm', { version: update.version }))) return;
        setSkipDb(false);
        const res = await window.axios.post(route('admin.license.update.start'));
        const sess = { token: res.data.token, runner: res.data.runner };
        setSession(sess);
        setRun(res.data.state);
        await drive(sess, res.data.state);
    });

    const proceed = withBusy('install', async (options = {}) => {
        let sess = session;
        let state = run;
        if (!sess) {
            ({ sess, state } = await openSession());
        }
        await drive(sess, state, options);
    });

    const refresh = withBusy('status', async () => {
        if (session) {
            const res = await window.axios.get(session.runner.status, { headers: { 'X-Update-Token': session.token } });
            setRun(res.data.state);
        } else {
            await openSession();
        }
    });

    const rollback = withBusy('rollback', async () => {
        if (!window.confirm(t('updater.rollback_confirm'))) return;
        const data = session
            ? await runnerPost(session, session.runner.rollback)
            : (await window.axios.post(route('admin.license.update.rollback'), {}, { timeout: 0 })).data;
        setRun(data.state);
        setNotice(data.message);
    });

    const discard = withBusy('discard', async () => {
        await window.axios.post(route('admin.license.update.discard'));
        setRun(null);
        setSession(null);
    });

    const reason = error?.reason ?? run?.reason;
    const errorMessage = error?.message ?? (run?.status === 'failed' || run?.status === 'rolled_back' ? run?.error : null);

    return (
        <div className="space-y-4">
            {!run && canInstall && (
                <p className="text-xs text-neutral-500 dark:text-neutral-400">{t('updater.intro')}</p>
            )}

            {run && (
                <div className="rounded-lg border border-neutral-200 p-4 dark:border-neutral-800">
                    <div className="mb-3 flex flex-wrap items-center justify-between gap-2">
                        <span className="text-sm font-semibold text-neutral-900 dark:text-neutral-100">
                            {t('updater.progress_title')}
                            {run.version ? ` · v${run.from_version || '?'} → v${run.version}` : ''}
                        </span>
                        {run.checksum === 'verified' && (
                            <Badge className="bg-green-100 text-green-800 dark:bg-green-900/30 dark:text-green-300">
                                <ShieldCheck className="mr-1 inline h-3.5 w-3.5" /> {t('updater.verified')}
                            </Badge>
                        )}
                        {run.checksum === 'unverified' && (
                            <Badge className="bg-amber-100 text-amber-800 dark:bg-amber-900/30 dark:text-amber-300" title={t('updater.unverified')}>
                                <ShieldAlert className="mr-1 inline h-3.5 w-3.5" /> {t('updater.unverified')}
                            </Badge>
                        )}
                    </div>

                    <ol className="space-y-2">
                        {STEPS.map((step) => {
                            const record = run.steps?.[step] ?? { status: 'pending', message: '' };
                            return (
                                <li key={step} className="flex items-start gap-2 text-sm">
                                    <span className="mt-0.5"><StepIcon status={record.status} active={activeStep === step} /></span>
                                    <div className="min-w-0">
                                        <p className={record.status === 'pending' ? 'text-neutral-400 dark:text-neutral-500' : 'text-neutral-800 dark:text-neutral-200'}>
                                            {t(`updater.steps.${step}`)}
                                        </p>
                                        {record.message && record.status !== 'failed' && (
                                            <p className="text-xs text-neutral-500 dark:text-neutral-400 break-words">{record.message}</p>
                                        )}
                                    </div>
                                </li>
                            );
                        })}
                    </ol>

                    {(run.preflight?.warnings?.length > 0) && (
                        <div className="mt-3 text-xs text-amber-700 dark:text-amber-300">
                            <p className="font-medium">{t('updater.warnings')}</p>
                            <ul className="list-disc pl-5">
                                {run.preflight.warnings.map((w, i) => <li key={i}>{w}</li>)}
                            </ul>
                        </div>
                    )}

                    <div className="mt-3 space-y-1 text-xs text-neutral-500 dark:text-neutral-400">
                        {run.backup && <p>{t('updater.backup_location', { path: run.backup })}</p>}
                        {run.db_backup?.file && <p>{t('updater.db_backup_file', { file: run.db_backup.file })}</p>}
                    </div>
                </div>
            )}

            {run?.maintenance && inProgress && (
                <Notice tone="warning" icon={AlertTriangle}>{t('updater.maintenance_on')}</Notice>
            )}

            {inProgress && run.stale && !busy && (
                <Notice tone="warning" icon={AlertTriangle}>{t('updater.stale')}</Notice>
            )}

            {errorMessage && !busy && (
                <Notice tone="error" icon={XCircle}>
                    {run?.status !== 'rolled_back' && <p className="font-medium">{t('updater.failed')}</p>}
                    <p>{errorMessage}</p>
                </Notice>
            )}

            {run?.status === 'rolled_back' && !errorMessage && !busy && (
                <Notice tone="success" icon={CheckCircle2}>{notice || t('updater.rolled_back')}</Notice>
            )}

            {run?.status === 'completed' && notice && !busy && (
                <Notice tone="success" icon={CheckCircle2}>
                    <p>{notice}</p>
                    <button type="button" onClick={() => window.location.reload()} className="mt-1 font-medium underline">
                        {t('updater.reload')}
                    </button>
                </Notice>
            )}

            {inProgress && reason === 'db_backup_failed' && !busy && (
                <div className="space-y-3 rounded-lg border border-neutral-200 p-4 dark:border-neutral-800">
                    <Checkbox
                        id="update-skip-db-backup"
                        label={t('updater.db_backup_confirm')}
                        checked={skipDb}
                        onChange={(e) => setSkipDb(e.target.checked)}
                    />
                    <Button size="sm" variant="primary" disabled={!skipDb} onClick={() => proceed({ skip_db_backup: true })}>
                        {t('updater.continue')}
                    </Button>
                </div>
            )}

            <div className="flex flex-wrap items-center gap-3">
                {canInstall && (
                    <Button variant="primary" onClick={install} disabled={!!busy}>
                        {busy === 'install' ? <Loader2 className="mr-2 h-4 w-4 animate-spin" /> : <Download className="mr-2 h-4 w-4" />}
                        {busy === 'install' ? t('updater.installing') : t('updater.install', { version: update.version })}
                    </Button>
                )}

                {inProgress && !busy && run.next_step && !run.stale && reason !== 'interrupted' && reason !== 'db_backup_failed' && !error?.network && (
                    <Button variant="primary" onClick={() => proceed()}>
                        {run.status === 'failed' ? t('updater.retry') : t('updater.resume')}
                    </Button>
                )}

                {inProgress && busy === 'install' && !canInstall && (
                    <Button variant="primary" disabled>
                        <Loader2 className="mr-2 h-4 w-4 animate-spin" /> {t('updater.installing')}
                    </Button>
                )}

                {error?.network && !busy && (
                    <Button variant="outline" onClick={refresh}>{t('updater.check_status')}</Button>
                )}

                {run?.can_rollback && !busy && (
                    <Button variant={inProgress ? 'danger' : 'outline'} onClick={rollback}>
                        <RotateCcw className="mr-2 h-4 w-4" /> {t('updater.rollback')}
                    </Button>
                )}
                {busy === 'rollback' && (
                    <Button variant="outline" disabled>
                        <Loader2 className="mr-2 h-4 w-4 animate-spin" /> {t('updater.rolling_back')}
                    </Button>
                )}

                {inProgress && run.can_discard && !busy && (
                    <Button variant="ghost" onClick={discard}>
                        {run.status === 'failed' ? t('updater.start_over') : t('updater.discard')}
                    </Button>
                )}

                {busy === 'install' && (
                    <span className="text-xs text-neutral-500 dark:text-neutral-400">{t('updater.keep_open')}</span>
                )}
            </div>
        </div>
    );
}
