import { Head, router, setLayoutProps } from '@inertiajs/react';
import { useMemo, useState } from 'react';
import { toast } from 'sonner';

import { DivisionHeader } from '@/components/divisions/DivisionHeader';
import { CreateRecurringTaskSheet } from '@/components/recurring-tasks/CreateRecurringTaskSheet';
import { DeleteRecurringTaskDialog } from '@/components/recurring-tasks/DeleteRecurringTaskDialog';
import { EditRecurringTaskSheet } from '@/components/recurring-tasks/EditRecurringTaskSheet';
import { mapGeneratedTaskToTaskoTask } from '@/components/recurring-tasks/mapGeneratedTaskToTaskoTask';
import { RecurringTemplatesSection } from '@/components/recurring-tasks/RecurringTemplatesSection';
import { RoutineWorkSection } from '@/components/recurring-tasks/RoutineWorkSection';
import { useRecurringTasksFilters } from '@/components/recurring-tasks/useRecurringTasksFilters';
import { TaskDetailSheet } from '@/components/tasks/TaskDetailSheet';
import { index as divisionsIndex } from '@/routes/divisions';
import {
    run as runRecurringTask,
    runAll as runAllRecurringTasks,
    toggleStatus as toggleRecurringTaskStatus,
} from '@/routes/recurring-tasks';
import type {
    DivisionShowRecurringTasksProps,
    RecurringTask,
} from '@/types/recurring-task';
import type { Task } from '@/types/task';
import type { FlashMessages } from '@/types/ui';

export default function DivisionsShowRecurringTasks({
    data,
}: DivisionShowRecurringTasksProps) {
    const { base_info, filters, permissions } = data.secondary;
    const { active_schedule, tasks: generatedRecurringWork } = data.primary;

    // Penerima template tidak boleh berperan viewer — server menolaknya lewat
    // AssigneesBelongToDivision, jadi tidak ditawarkan sejak di daftar.
    const divisionMembers = useMemo(
        () =>
            data.secondary.members.members
                .filter((member) => member.role_type !== 'viewer')
                .map((member) => ({
                    id: String(member.user_id),
                    name: member.user_name,
                })),
        [data.secondary.members.members],
    );

    const divisionMembersForTaskSheet = useMemo(
        () =>
            data.secondary.members.members.map((member) => ({
                id: String(member.user_id),
                name: member.user_name,
                // Viewer dipetakan apa adanya, bukan dilebur ke 'member':
                // TaskDetailSheet memakai peran ini untuk menyaring kandidat
                // pelaksana subtask.
                role:
                    member.role_type === 'admin' ||
                    member.role_type === 'supervisor'
                        ? 'owner'
                        : member.role_type === 'viewer'
                          ? 'viewer'
                          : 'member',
            })),
        [data.secondary.members.members],
    );

    // Hak dibaca dari server, bukan disimpulkan dari daftar member: super admin
    // bukan anggota divisi mana pun, jadi penyimpulan itu menyembunyikan seluruh
    // seksi template darinya padahal server justru mengirim datanya. Keduanya
    // sengaja terpisah — super admin boleh melihat, tidak boleh mengelola.
    const {
        can_view_templates: canViewTemplates,
        can_manage_templates: canManageTemplates,
    } = permissions;

    const {
        recurringSearchQuery,
        recurringStatusFilter,
        setRecurringSearchQuery,
        setTemplateStatus,
        setWorkSearchQuery,
        setWorkStatus,
        setWorkPriority,
        workSearchQuery,
        workStatusFilter,
        workPriorityFilter,
    } = useRecurringTasksFilters({
        divisionSlug: base_info.slug,
        filters,
        canViewTemplates,
        workPage: generatedRecurringWork.pagination.current_page,
        templatePage: active_schedule.pagination.current_page,
    });

    const [isCreateOpen, setIsCreateOpen] = useState(false);
    const [editingTask, setEditingTask] = useState<RecurringTask | null>(null);
    const [deletingTask, setDeletingTask] = useState<RecurringTask | null>(
        null,
    );
    const [viewingWorkId, setViewingWorkId] = useState<string | null>(null);

    // Ownership filter for non-managers is applied server-side (before pagination),
    // so here we only map the already-scoped tasks to keep pagination counts accurate.
    const routineWork = useMemo(
        () =>
            (generatedRecurringWork.tasks || []).map((task) =>
                mapGeneratedTaskToTaskoTask(task),
            ),
        [generatedRecurringWork.tasks],
    );

    const viewingWork = useMemo(() => {
        if (!viewingWorkId) {
            return null;
        }

        const findTask = (tasks: Task[]): Task | null => {
            for (const t of tasks) {
                if (t.id === viewingWorkId) {
                    return t;
                }

                if (t.subtasks && t.subtasks.length > 0) {
                    const found = findTask(t.subtasks);

                    if (found) {
                        return found;
                    }
                }
            }

            return null;
        };

        return findTask(routineWork);
    }, [routineWork, viewingWorkId]);

    const handleToggleStatus = (task: RecurringTask) => {
        if (!canManageTemplates) {
            toast.error('You are not allowed to manage recurring tasks');

            return;
        }

        router.patch(
            toggleRecurringTaskStatus(task.id).url,
            {},
            {
                preserveScroll: true,
                onSuccess: () => {
                    toast.success('Status updated successfully');
                },
                onError: () => {
                    toast.error('Failed to update status');
                },
            },
        );
    };

    const handleRunNow = (task: RecurringTask) => {
        if (!canManageTemplates) {
            toast.error('You are not allowed to manage recurring tasks');

            return;
        }

        router.post(
            runRecurringTask(task.id).url,
            {},
            {
                preserveScroll: true,
                onSuccess: (page) => {
                    const flash = (page.props as { flash?: FlashMessages })
                        .flash;

                    if (flash?.info) {
                        toast.info(flash.info);
                    } else {
                        toast.success(
                            flash?.success ??
                                'Routine work generated successfully',
                        );
                    }
                },
                onError: () => {
                    toast.error('Failed to generate routine work');
                },
            },
        );
    };

    const handleRunAll = () => {
        if (!canManageTemplates) {
            toast.error('You are not allowed to manage recurring tasks');

            return;
        }

        router.post(
            runAllRecurringTasks(base_info.slug).url,
            {},
            {
                preserveScroll: true,
                onSuccess: (page) => {
                    const flash = (page.props as { flash?: FlashMessages })
                        .flash;

                    if (flash?.info) {
                        toast.info(flash.info);
                    } else {
                        toast.success(
                            flash?.success ??
                                'Active templates run successfully',
                        );
                    }
                },
                onError: () => {
                    toast.error('Failed to run active templates');
                },
            },
        );
    };

    setLayoutProps({
        breadcrumbs: [
            {
                title: 'Divisions',
                href: divisionsIndex().url,
            },
            {
                title: base_info.name,
            },
            {
                title: 'Recurring Tasks',
            },
        ],
    });

    return (
        <>
            <Head title={`${base_info.name} - Recurring Tasks`} />

            <div className="flex min-h-full flex-col bg-muted/50">
                <DivisionHeader baseInfo={base_info} />

                <div className="px-5">
                    <div className="mx-auto w-full pb-8">
                        <section className="space-y-4">
                            <RoutineWorkSection
                                tasks={routineWork}
                                pagination={generatedRecurringWork.pagination}
                                searchQuery={workSearchQuery}
                                statusFilter={workStatusFilter}
                                priorityFilter={workPriorityFilter}
                                onSearchChange={setWorkSearchQuery}
                                onStatusChange={setWorkStatus}
                                onPriorityChange={setWorkPriority}
                                onViewTask={setViewingWorkId}
                            />

                            {canViewTemplates && (
                                <RecurringTemplatesSection
                                    tasks={active_schedule.tasks}
                                    pagination={active_schedule.pagination}
                                    canManage={canManageTemplates}
                                    searchQuery={recurringSearchQuery}
                                    statusFilter={recurringStatusFilter}
                                    onCreate={() => setIsCreateOpen(true)}
                                    onDelete={setDeletingTask}
                                    onEdit={setEditingTask}
                                    onRunNow={handleRunNow}
                                    onRunAll={handleRunAll}
                                    onSearchChange={setRecurringSearchQuery}
                                    onStatusChange={setTemplateStatus}
                                    onToggleStatus={handleToggleStatus}
                                />
                            )}
                        </section>
                    </div>
                </div>
            </div>

            {canManageTemplates && (
                <>
                    <CreateRecurringTaskSheet
                        open={isCreateOpen}
                        onOpenChange={setIsCreateOpen}
                        divisions={[
                            { id: String(base_info.id), name: base_info.name },
                        ]}
                        members={divisionMembers}
                        defaultDivisionId={String(base_info.id)}
                    />

                    {editingTask && (
                        <EditRecurringTaskSheet
                            open={!!editingTask}
                            onOpenChange={(open) =>
                                !open && setEditingTask(null)
                            }
                            task={{
                                id: editingTask.id,
                                title: editingTask.name,
                                description: editingTask.description,
                                division: base_info.name,
                                divisionId: String(editingTask.division_id),
                                frequency: editingTask.frequency,
                                scheduleDay:
                                    editingTask.schedule_day ?? undefined,
                                scheduleDays: editingTask.schedule_days ?? [],
                                dueTime: editingTask.due_time ?? undefined,
                                priority: editingTask.priority,
                                requiredProofType:
                                    editingTask.required_proof_type || 'none',
                                status: editingTask.status,
                                assigneeIds:
                                    editingTask.assignees?.map((assignee) =>
                                        String(assignee.user_id),
                                    ) || [],
                            }}
                            divisions={[
                                {
                                    id: String(base_info.id),
                                    name: base_info.name,
                                },
                            ]}
                            members={divisionMembers}
                            disableDivisionSelect={true}
                        />
                    )}

                    <DeleteRecurringTaskDialog
                        open={!!deletingTask}
                        onOpenChange={(open) => !open && setDeletingTask(null)}
                        task={
                            deletingTask
                                ? {
                                      id: deletingTask.id,
                                      title: deletingTask.name,
                                  }
                                : null
                        }
                    />
                </>
            )}

            <TaskDetailSheet
                task={viewingWork}
                open={!!viewingWorkId}
                onOpenChange={(open) => !open && setViewingWorkId(null)}
                divisionId={String(base_info.id)}
                projectMembers={divisionMembersForTaskSheet}
                can={{ manageTasks: canManageTemplates }}
                // Routine work tidak bisa diedit/dihapus — tombolnya disembunyikan
                // TaskDetailSheet, jadi handler ini tidak pernah terpanggil.
                onEdit={() => {}}
                onDelete={() => {}}
                onNavigate={setViewingWorkId}
            />
        </>
    );
}