import Form from '@admin/components/form/Form';
import FormField from '@admin/components/form/FormField';
import { Button } from '@admin/components/ui/button';
import { zodResolver } from '@hookform/resolvers/zod';
import { Plus } from 'lucide-react';
import { z } from 'zod';

export type ReminderFormValues = z.infer<typeof ReminderFormSchema>;

export type NormalizedReminderPayload = {
    title: string;
    description: string;
    tags: string[];
    priority: 'low' | 'medium' | 'high' | string;
    status?: string | number;
    due_date_time?: string;
    assigned_to?: number | null;
    date?: string;
    time?: string;
    people?: string[];
};

interface UserOption {
    label: string;
    value: string;
}

interface StatusOption {
    label: string;
    value: string;
}

interface TagOption {
    value: number;
    label: string;
    color: string;
}

interface ReminderFormProps {
    mode: 'add' | 'edit';
    initialReminder?: any;
    onSubmitReminder: (payload: NormalizedReminderPayload) => void;
    onCancel?: () => void;
    className?: string;
    users?: UserOption[];
    statuses?: StatusOption[];
    reminderTags?: TagOption[];
}

const ReminderFormSchema = z.object({
    title: z.string().min(3, 'Title must be at least 3 characters'),
    description: z.string().max(1000).optional().or(z.literal('')),
    priority: z.enum(['low', 'medium', 'high']),
    tags: z.preprocess((val) => (Array.isArray(val) ? val : val ? [val] : []), z.array(z.string()).optional()),
    status: z.union([z.string(), z.number()]).optional(),
    due_date_time: z.string().min(1, 'Due date and time is required'),
    date: z.string().optional(),
    time: z.string().optional(),
    people: z.array(z.string()).optional(),
});

export default function ReminderForm({
    mode,
    initialReminder,
    onSubmitReminder,
    onCancel,
    className,
    users = [],
    statuses = [],
    reminderTags = [],
}: ReminderFormProps) {
    // Extract tag labels for dropdown
    const tagLabels = reminderTags.map((tag) => tag.label);

    // Format datetime for datetime-local input (YYYY-MM-DDTHH:MM)
    const formatDatetimeLocal = (datetime: string) => {
        if (!datetime) return '';
        const date = new Date(datetime);
        const year = date.getFullYear();
        const month = String(date.getMonth() + 1).padStart(2, '0');
        const day = String(date.getDate()).padStart(2, '0');
        const hours = String(date.getHours()).padStart(2, '0');
        const minutes = String(date.getMinutes()).padStart(2, '0');
        return `${year}-${month}-${day}T${hours}:${minutes}`;
    };

    // Normalize initialReminder (reminder model) to form field names
    const mappedInitial = initialReminder
        ? {
              title: (initialReminder.title as string) || (initialReminder.name as string) || '',
              description: initialReminder.description || '',
              tags: (() => {
                  // Convert tag_names to tag labels for multiselect
                  if (initialReminder.tag_names && Array.isArray(initialReminder.tag_names)) {
                      return initialReminder.tag_names;
                  }
                  // Fallback to tag_ids if tag_names not available
                  if (initialReminder.tag_ids && Array.isArray(initialReminder.tag_ids)) {
                      return initialReminder.tag_ids
                          .map((tagId: number) => {
                              const tag = reminderTags.find((t) => t.value === tagId);
                              return tag ? tag.label : null;
                          })
                          .filter(Boolean);
                  }
                  return [];
              })(),
              status: (() => {
                  // Find the status value from the status enum value
                  const statusObj = statuses.find((s) => s.value === initialReminder.status);
                  return statusObj ? statusObj.value : 2; // Default to PENDING (value: 2)
              })(),
              priority: initialReminder.priority || 'medium',
              due_date_time: formatDatetimeLocal(initialReminder.due_date_time) || '',
              date: initialReminder.date || '',
              time: initialReminder.time || '',
              people: initialReminder.people_ids?.map((id: number) => String(id)) || [],
          }
        : {};

    const defaultValues = {
        title: '',
        description: '',
        tags: [],
        status: 2, // Default to PENDING enum value
        priority: 'medium',
        due_date_time: '',
        date: '',
        time: '',
        people: [],
        ...mappedInitial,
    };

    const resolver = zodResolver(ReminderFormSchema);

    const handleSubmit = async (values: ReminderFormValues) => {
        const title = values.title || '';
        const description = values.description || '';

        // Use due_date_time if provided, otherwise combine date and time
        let dueDatetime = values.due_date_time || '';
        if (!dueDatetime && values.date) {
            dueDatetime = values.time ? `${values.date} ${values.time}` : `${values.date} 00:00:00`;
        }

        const payload: NormalizedReminderPayload = {
            title,
            description,
            tags: Array.isArray(values.tags) ? values.tags : values.tags ? [values.tags] : [], // Tags array
            priority: values.priority || 'medium',
            status: values.status || 2, // Status enum value
            due_date_time: dueDatetime || undefined,
            assigned_to: values.people && values.people.length > 0 ? parseInt(values.people[0]) : null,
            date: values.date,
            time: values.time,
            people: values.people || [],
        };

        onSubmitReminder(payload);
    };

    return (
        <div className={['space-y-6 p-2', className].filter(Boolean).join(' ')}>
            <Form
                submitHandler={handleSubmit}
                defaultValues={defaultValues}
                formClassNames="space-y-6"
                resolver={resolver}
                key={initialReminder?.id || 'new'}
            >
                <FormField name="title" label="Title" type="text" placeholder="eg: Team Meeting Reminder" required />

                <FormField name="description" label="Description (optional)" type="textarea" />

                <FormField name="due_date_time" label="Due Date & Time" type="datetime-local" required />

                <div className="grid grid-cols-2 gap-4">
                    <FormField name="tags" label="Tags" type="multiselect" searchable options={tagLabels || []} allowCustomOptions={false} />
                    <FormField
                        name="status"
                        label="Status"
                        type="select"
                        options={
                            statuses || [
                                { label: 'Pending', value: 2 },
                                { label: 'Snoozed', value: 22 },
                                { label: 'Completed', value: 5 },
                                { label: 'Dismissed', value: 21 },
                                { label: 'Archived', value: 11 },
                            ]
                        }
                    />
                </div>

                {/* People selector (multiple) */}
                <FormField
                    name="people"
                    label="People"
                    type="multiselect"
                    searchable
                    options={users || []}
                    placeholder="Select people"
                    max={10}
                    allowCustomOptions={false}
                />

                <div className="flex justify-end gap-3">
                    {onCancel && (
                        <Button variant="outline" type="button" onClick={onCancel}>
                            Cancel
                        </Button>
                    )}
                    <Button className="hover:bg-success-800 bg-success text-white" type="submit">
                        <Plus className="h-4 w-4" />
                        {mode === 'add' ? 'Add Reminder' : 'Save Reminder'}
                    </Button>
                </div>
            </Form>
        </div>
    );
}