import { Head, Link, router, useForm, usePage } from '@inertiajs/react';
import type { FormEvent } from 'react';
import { useEffect, useMemo, useRef, useState } from 'react';
import '../../../css/rsvp-settings.css';

type QuestionType = 'text' | 'single_choice' | 'multiple_choice' | 'boolean';

type RsvpQuestion = {
    id: string;
    label: string;
    helpText: string | null;
    type: QuestionType;
    required: boolean;
    options: string[];
    sortOrder: number;
    responseCount: number;
};

type PageProps = {
    wedding: {
        name: string;
        timezone: string;
    };
    event: {
        id: string;
        title: string;
        startsAt: string;
        rsvpDeadline: string | null;
    };
    questions: RsvpQuestion[];
    flash: {
        success: string | null;
    };
    errors: Record<string, string>;
};

type QuestionForm = {
    label: string;
    help_text: string;
    type: QuestionType;
    is_required: boolean;
    options: string[];
    sort_order: number;
};

const questionTypeLabels: Record<QuestionType, string> = {
    text: 'Freitext',
    single_choice: 'Einfachauswahl',
    multiple_choice: 'Mehrfachauswahl',
    boolean: 'Ja oder Nein',
};

const isChoiceQuestion = (type: QuestionType) => type === 'single_choice' || type === 'multiple_choice';

const emptyQuestion = (sortOrder: number): QuestionForm => ({
    label: '',
    help_text: '',
    type: 'text',
    is_required: false,
    options: ['', ''],
    sort_order: sortOrder,
});

const toDateTimeInput = (value: string | null, timeZone: string): string => {
    if (!value) return '';
    const date = new Date(value);
    if (Number.isNaN(date.getTime())) return '';

    try {
        const parts = new Intl.DateTimeFormat('de-DE', {
            timeZone,
            year: 'numeric',
            month: '2-digit',
            day: '2-digit',
            hour: '2-digit',
            minute: '2-digit',
            hourCycle: 'h23',
        }).formatToParts(date);
        const getPart = (type: Intl.DateTimeFormatPartTypes) => parts.find((part) => part.type === type)?.value ?? '';
        return `${getPart('year')}-${getPart('month')}-${getPart('day')}T${getPart('hour')}:${getPart('minute')}`;
    } catch {
        return value.slice(0, 16);
    }
};

const formatEventDate = (value: string, timeZone: string): string => {
    const date = new Date(value);
    if (Number.isNaN(date.getTime())) return 'Termin noch nicht verfügbar';

    try {
        return new Intl.DateTimeFormat('de-DE', {
            timeZone,
            weekday: 'long',
            day: '2-digit',
            month: 'long',
            year: 'numeric',
            hour: '2-digit',
            minute: '2-digit',
        }).format(date);
    } catch {
        return new Intl.DateTimeFormat('de-DE', {
            day: '2-digit',
            month: 'long',
            year: 'numeric',
            hour: '2-digit',
            minute: '2-digit',
        }).format(date);
    }
};

export default function RsvpSettings() {
    const { wedding, event, questions, flash, errors } = usePage<PageProps>().props;
    const sortedQuestions = useMemo(() => [...questions].sort((a, b) => a.sortOrder - b.sortOrder), [questions]);
    const nextSortOrder = sortedQuestions.length > 0
        ? Math.max(...sortedQuestions.map((question) => question.sortOrder)) + 10
        : 10;
    const [orderedQuestions, setOrderedQuestions] = useState(sortedQuestions);
    const [editingId, setEditingId] = useState<string | null>(null);
    const [pendingAction, setPendingAction] = useState<string | null>(null);
    const [optionError, setOptionError] = useState<string | null>(null);
    const editorHeading = useRef<HTMLHeadingElement>(null);

    const deadlineForm = useForm<{ rsvp_deadline: string }>({
        rsvp_deadline: toDateTimeInput(event.rsvpDeadline, wedding.timezone),
    });
    const questionForm = useForm<QuestionForm>(emptyQuestion(nextSortOrder));

    useEffect(() => {
        setOrderedQuestions(sortedQuestions);
    }, [sortedQuestions]);

    const focusEditor = () => {
        window.setTimeout(() => editorHeading.current?.focus(), 150);
    };

    const submitDeadline = (submitEvent: FormEvent<HTMLFormElement>) => {
        submitEvent.preventDefault();
        if (deadlineForm.processing) return;

        deadlineForm.transform((data) => data);
        deadlineForm.put(`/veranstaltungen/${event.id}/rueckmeldung`, {
            preserveScroll: true,
        });
    };

    const removeDeadline = () => {
        if (deadlineForm.processing || !deadlineForm.data.rsvp_deadline) return;

        deadlineForm.transform(() => ({ rsvp_deadline: '' }));
        deadlineForm.put(`/veranstaltungen/${event.id}/rueckmeldung`, {
            preserveScroll: true,
            onSuccess: () => deadlineForm.setData('rsvp_deadline', ''),
        });
    };

    const startCreating = () => {
        setEditingId(null);
        setOptionError(null);
        questionForm.clearErrors();
        questionForm.setData(emptyQuestion(nextSortOrder));
        focusEditor();
    };

    const startEditing = (question: RsvpQuestion) => {
        setEditingId(question.id);
        setOptionError(null);
        questionForm.clearErrors();
        questionForm.setData({
            label: question.label,
            help_text: question.helpText ?? '',
            type: question.type,
            is_required: question.required,
            options: question.options.length > 0 ? [...question.options] : ['', ''],
            sort_order: question.sortOrder,
        });
        focusEditor();
    };

    const cancelEditing = () => {
        setEditingId(null);
        setOptionError(null);
        questionForm.clearErrors();
        questionForm.setData(emptyQuestion(nextSortOrder));
    };

    const updateOption = (index: number, value: string) => {
        setOptionError(null);
        questionForm.setData('options', questionForm.data.options.map((option, optionIndex) =>
            optionIndex === index ? value : option,
        ));
    };

    const removeOption = (index: number) => {
        setOptionError(null);
        questionForm.setData('options', questionForm.data.options.filter((_, optionIndex) => optionIndex !== index));
    };

    const submitQuestion = (submitEvent: FormEvent<HTMLFormElement>) => {
        submitEvent.preventDefault();
        if (questionForm.processing) return;

        const options = questionForm.data.options.map((option) => option.trim()).filter(Boolean);
        const normalizedOptions = options.map((option) => option.toLocaleLowerCase('de-DE'));

        if (isChoiceQuestion(questionForm.data.type) && options.length === 0) {
            setOptionError('Füge mindestens eine Antwortoption hinzu.');
            return;
        }
        if (new Set(normalizedOptions).size !== normalizedOptions.length) {
            setOptionError('Jede Antwortoption darf nur einmal vorkommen.');
            return;
        }

        setOptionError(null);
        questionForm.transform((data) => ({
            ...data,
            options: isChoiceQuestion(data.type) ? options : [],
        }));

        const requestOptions = {
            preserveScroll: true,
            onSuccess: () => {
                setEditingId(null);
                questionForm.setData(emptyQuestion(nextSortOrder));
            },
        };

        if (editingId === null) {
            questionForm.post(`/veranstaltungen/${event.id}/rueckmeldung/fragen`, requestOptions);
        } else {
            questionForm.put(`/veranstaltungen/${event.id}/rueckmeldung/fragen/${editingId}`, requestOptions);
        }
    };

    const moveQuestion = (index: number, direction: -1 | 1) => {
        const targetIndex = index + direction;
        if (targetIndex < 0 || targetIndex >= orderedQuestions.length || pendingAction !== null) return;

        const previousOrder = [...orderedQuestions];
        const nextOrder = [...orderedQuestions];
        [nextOrder[index], nextOrder[targetIndex]] = [nextOrder[targetIndex], nextOrder[index]];
        setOrderedQuestions(nextOrder);
        setPendingAction('sorting');

        router.put(`/veranstaltungen/${event.id}/rueckmeldung/fragen-sortierung`, {
            question_ids: nextOrder.map((question) => question.id),
        }, {
            preserveScroll: true,
            onError: () => setOrderedQuestions(previousOrder),
            onFinish: () => setPendingAction(null),
        });
    };

    const deleteQuestion = (question: RsvpQuestion) => {
        if (pendingAction !== null || questionForm.processing || deadlineForm.processing) return;

        const warning = question.responseCount > 0
            ? `Für „${question.label}“ liegen bereits ${question.responseCount} Antworten vor. Möchtest du die Löschung trotzdem anfragen? Der Server kann sie ablehnen.`
            : `Möchtest du die Frage „${question.label}“ wirklich löschen?`;
        if (!window.confirm(warning)) return;

        const actionKey = `delete-${question.id}`;
        setPendingAction(actionKey);
        router.delete(`/veranstaltungen/${event.id}/rueckmeldung/fragen/${question.id}`, {
            preserveScroll: true,
            onSuccess: () => {
                if (editingId === question.id) cancelEditing();
            },
            onFinish: () => setPendingAction(null),
        });
    };

    const questionErrors = { ...errors, ...(questionForm.errors as Record<string, string>) };
    const optionErrors = [...new Set(Object.entries(questionErrors)
        .filter(([key]) => key === 'options' || key.startsWith('options.'))
        .map(([, message]) => message)
        .filter(Boolean))];
    const generalError = errors.rsvp ?? errors.questions ?? errors.general;
    const requestsPending = deadlineForm.processing || questionForm.processing || pendingAction !== null;

    return (
        <>
            <Head title={`RSVP-Einstellungen · ${event.title}`} />
            <main className="rsvp-settings-shell">
                <nav className="rsvp-settings-nav" aria-label="Bereichsnavigation">
                    <div>
                        <span className="rsvp-settings-eyebrow">{wedding.name}</span>
                        <strong>RSVP-Einstellungen</strong>
                    </div>
                    <Link className="rsvp-settings-secondary" href="/veranstaltungen">Zurück zu Veranstaltungen</Link>
                </nav>

                <header className="rsvp-settings-header">
                    <div>
                        <span className="rsvp-settings-eyebrow">Rückmeldung konfigurieren</span>
                        <h1>{event.title}</h1>
                        <p className="rsvp-settings-event-date">{formatEventDate(event.startsAt, wedding.timezone)}</p>
                    </div>
                    <p className="rsvp-settings-header-note">Die Fragen werden von jeder eingeladenen Person einzeln beantwortet. So können Familienmitglieder unterschiedliche Angaben machen.</p>
                </header>

                {flash.success && <div className="alert rsvp-settings-success" role="status">{flash.success}</div>}
                {generalError && <div className="alert alert-danger rsvp-settings-page-alert" role="alert">{generalError}</div>}

                <div className="rsvp-settings-grid">
                    <div className="rsvp-settings-main">
                        <section className="rsvp-settings-panel" aria-labelledby="deadline-title">
                            <div className="rsvp-settings-section-heading">
                                <div><span className="rsvp-settings-eyebrow">Zeitraum</span><h2 id="deadline-title">Rückmeldefrist</h2></div>
                                {event.rsvpDeadline && <span className="rsvp-settings-set-badge">Frist gesetzt</span>}
                            </div>
                            <p className="rsvp-settings-copy">Bis zu diesem Zeitpunkt können eingeladene Gäste ihre Antworten bearbeiten.</p>
                            <form aria-busy={deadlineForm.processing} className="rsvp-settings-deadline-form" noValidate onSubmit={submitDeadline}>
                                <div>
                                    <label className="form-label" htmlFor="rsvp-deadline">Datum und Uhrzeit</label>
                                    <input
                                        className={`form-control${deadlineForm.errors.rsvp_deadline ? ' is-invalid' : ''}`}
                                        disabled={requestsPending && !deadlineForm.processing}
                                        id="rsvp-deadline"
                                        onChange={(changeEvent) => deadlineForm.setData('rsvp_deadline', changeEvent.target.value)}
                                        type="datetime-local"
                                        value={deadlineForm.data.rsvp_deadline}
                                    />
                                    {deadlineForm.errors.rsvp_deadline && <div className="invalid-feedback">{deadlineForm.errors.rsvp_deadline}</div>}
                                    <small>Zeitzone: {wedding.timezone}</small>
                                </div>
                                <div className="rsvp-settings-deadline-actions">
                                    <button className="rsvp-settings-primary" disabled={requestsPending} type="submit">{deadlineForm.processing ? 'Wird gespeichert …' : 'Frist speichern'}</button>
                                    <button className="rsvp-settings-text-action is-danger" disabled={requestsPending || !deadlineForm.data.rsvp_deadline} onClick={removeDeadline} type="button">Frist entfernen</button>
                                </div>
                            </form>
                        </section>

                        <section className="rsvp-settings-panel" aria-labelledby="questions-title">
                            <div className="rsvp-settings-section-heading">
                                <div><span className="rsvp-settings-eyebrow">Fragebogen</span><h2 id="questions-title">Vorhandene Fragen</h2></div>
                                <span className="rsvp-settings-count" aria-label={`${orderedQuestions.length} Fragen`}>{orderedQuestions.length}</span>
                            </div>

                            {orderedQuestions.length === 0 ? (
                                <div className="rsvp-settings-empty">
                                    <span aria-hidden="true">◇</span>
                                    <h3>Noch keine Zusatzfragen</h3>
                                    <p>Erstelle die erste Frage, wenn ihr neben der Zu- oder Absage weitere Angaben benötigt.</p>
                                    <button className="rsvp-settings-secondary" onClick={startCreating} type="button">Erste Frage erstellen</button>
                                </div>
                            ) : (
                                <ol className="rsvp-settings-question-list">
                                    {orderedQuestions.map((question, index) => (
                                        <li className={`rsvp-settings-question-card${editingId === question.id ? ' is-editing' : ''}`} key={question.id}>
                                            <div className="rsvp-settings-question-position" aria-hidden="true">{index + 1}</div>
                                            <div className="rsvp-settings-question-content">
                                                <div className="rsvp-settings-question-topline">
                                                    <div className="rsvp-settings-badges">
                                                        <span>{questionTypeLabels[question.type]}</span>
                                                        {question.required && <span className="is-required">Pflichtfrage</span>}
                                                    </div>
                                                    <span className={`rsvp-settings-response-count${question.responseCount > 0 ? ' has-responses' : ''}`}>
                                                        {question.responseCount} {question.responseCount === 1 ? 'Antwort' : 'Antworten'}
                                                    </span>
                                                </div>
                                                <h3>{question.label}</h3>
                                                {question.helpText && <p>{question.helpText}</p>}
                                                {isChoiceQuestion(question.type) && question.options.length > 0 && (
                                                    <div className="rsvp-settings-option-preview">
                                                        {question.options.map((option, optionIndex) => <span key={`${question.id}-${optionIndex}`}>{option}</span>)}
                                                    </div>
                                                )}
                                                {question.responseCount > 0 && <p className="rsvp-settings-protection-note">Für diese Frage liegen Antworten vor. Änderungen oder Löschen können serverseitig eingeschränkt sein.</p>}
                                                <div className="rsvp-settings-question-actions">
                                                    <button className="rsvp-settings-text-action" disabled={requestsPending} onClick={() => startEditing(question)} type="button">Bearbeiten</button>
                                                    <button aria-label={`${question.label} nach oben verschieben`} className="rsvp-settings-icon-action" disabled={requestsPending || index === 0} onClick={() => moveQuestion(index, -1)} type="button">↑</button>
                                                    <button aria-label={`${question.label} nach unten verschieben`} className="rsvp-settings-icon-action" disabled={requestsPending || index === orderedQuestions.length - 1} onClick={() => moveQuestion(index, 1)} type="button">↓</button>
                                                    <button className="rsvp-settings-text-action is-danger" disabled={requestsPending} onClick={() => deleteQuestion(question)} type="button">{pendingAction === `delete-${question.id}` ? 'Wird gelöscht …' : 'Löschen'}</button>
                                                </div>
                                            </div>
                                        </li>
                                    ))}
                                </ol>
                            )}
                            {pendingAction === 'sorting' && <p className="rsvp-settings-saving" role="status">Neue Reihenfolge wird gespeichert …</p>}
                        </section>
                    </div>

                    <aside className="rsvp-settings-editor" aria-labelledby="question-editor-title">
                        <div className="rsvp-settings-section-heading">
                            <div>
                                <span className="rsvp-settings-eyebrow">{editingId === null ? 'Neue Frage' : 'Frage bearbeiten'}</span>
                                <h2 id="question-editor-title" ref={editorHeading} tabIndex={-1}>{editingId === null ? 'Frage erstellen' : 'Inhalt aktualisieren'}</h2>
                            </div>
                            {editingId !== null && <button className="rsvp-settings-text-action" disabled={questionForm.processing} onClick={cancelEditing} type="button">Abbrechen</button>}
                        </div>

                        <form aria-busy={questionForm.processing} noValidate onSubmit={submitQuestion}>
                            <div className="mb-3">
                                <label className="form-label" htmlFor="question-label">Frage</label>
                                <input
                                    className={`form-control${questionForm.errors.label ? ' is-invalid' : ''}`}
                                    disabled={requestsPending && !questionForm.processing}
                                    id="question-label"
                                    onChange={(changeEvent) => questionForm.setData('label', changeEvent.target.value)}
                                    placeholder="z. B. Welches Menü möchtet ihr?"
                                    value={questionForm.data.label}
                                />
                                {questionForm.errors.label && <div className="invalid-feedback">{questionForm.errors.label}</div>}
                            </div>

                            <div className="mb-3">
                                <label className="form-label" htmlFor="question-help">Hilfetext <span>optional</span></label>
                                <textarea
                                    className={`form-control${questionForm.errors.help_text ? ' is-invalid' : ''}`}
                                    disabled={requestsPending && !questionForm.processing}
                                    id="question-help"
                                    onChange={(changeEvent) => questionForm.setData('help_text', changeEvent.target.value)}
                                    placeholder="Eine kurze Erklärung für eure Gäste"
                                    rows={3}
                                    value={questionForm.data.help_text}
                                />
                                {questionForm.errors.help_text && <div className="invalid-feedback">{questionForm.errors.help_text}</div>}
                            </div>

                            <div className="mb-3">
                                <label className="form-label" htmlFor="question-type">Fragetyp</label>
                                <select
                                    className={`form-select${questionForm.errors.type ? ' is-invalid' : ''}`}
                                    disabled={requestsPending && !questionForm.processing}
                                    id="question-type"
                                    onChange={(changeEvent) => questionForm.setData('type', changeEvent.target.value as QuestionType)}
                                    value={questionForm.data.type}
                                >
                                    {Object.entries(questionTypeLabels).map(([value, label]) => <option key={value} value={value}>{label}</option>)}
                                </select>
                                {questionForm.errors.type && <div className="invalid-feedback">{questionForm.errors.type}</div>}
                            </div>

                            {isChoiceQuestion(questionForm.data.type) && (
                                <fieldset className="rsvp-settings-options">
                                    <legend>Antwortoptionen</legend>
                                    <p>Leere Zeilen werden nicht gespeichert. Doppelte Optionen sind nicht zulässig.</p>
                                    <div className="rsvp-settings-option-list">
                                        {questionForm.data.options.map((option, index) => (
                                            <div key={index}>
                                                <label className="visually-hidden" htmlFor={`question-option-${index}`}>Antwortoption {index + 1}</label>
                                                <input
                                                    className="form-control"
                                                    disabled={requestsPending && !questionForm.processing}
                                                    id={`question-option-${index}`}
                                                    onChange={(changeEvent) => updateOption(index, changeEvent.target.value)}
                                                    placeholder={`Option ${index + 1}`}
                                                    value={option}
                                                />
                                                <button aria-label={`Antwortoption ${index + 1} entfernen`} disabled={requestsPending} onClick={() => removeOption(index)} type="button">×</button>
                                            </div>
                                        ))}
                                    </div>
                                    <button className="rsvp-settings-add-option" disabled={requestsPending} onClick={() => questionForm.setData('options', [...questionForm.data.options, ''])} type="button">+ Option hinzufügen</button>
                                    {(optionError || optionErrors.length > 0) && (
                                        <div className="rsvp-settings-field-errors" role="alert">
                                            {optionError && <p>{optionError}</p>}
                                            {optionErrors.map((message) => <p key={message}>{message}</p>)}
                                        </div>
                                    )}
                                </fieldset>
                            )}

                            <label className="rsvp-settings-required-toggle">
                                <input
                                    checked={questionForm.data.is_required}
                                    className="form-check-input"
                                    disabled={requestsPending && !questionForm.processing}
                                    onChange={(changeEvent) => questionForm.setData('is_required', changeEvent.target.checked)}
                                    type="checkbox"
                                />
                                <span><strong>Pflichtfrage</strong><small>Muss bei einer Zusage beantwortet werden</small></span>
                            </label>
                            {questionForm.errors.is_required && <div className="rsvp-settings-field-errors" role="alert"><p>{questionForm.errors.is_required}</p></div>}

                            <button className="rsvp-settings-primary rsvp-settings-submit-question" disabled={requestsPending} type="submit">
                                {questionForm.processing ? 'Wird gespeichert …' : editingId === null ? 'Frage erstellen' : 'Änderungen speichern'}
                            </button>
                        </form>
                    </aside>
                </div>
            </main>
        </>
    );
}
