"use client";

import { useState, useEffect, useCallback } from 'react';
import { ModerationStats } from "./ModerationStats";
import { JobModerationQueueList } from "./JobModerationQueueList";
import { FilterPanel } from "./FilterPanel";
import { BulkFloatingBar } from './BulkFloatingBar';
import { BulkSelectionProvider, useBulkSelection } from './context/BulkSelectionContext';
import { BulkApproveModal } from './workspace/modals/BulkApproveModal';
import { BulkRejectModal } from './workspace/modals/BulkRejectModal';
import { BulkRequestChangesModal } from './workspace/modals/BulkRequestChangesModal';
import toast from 'react-hot-toast';

export type SortOption = 'urgent' | 'newest' | 'oldest' | 'companyAsc' | 'salaryHigh' | 'salaryLow';

export interface ModerationFilters {
    search: string;
    sort: SortOption;
    dateRange: string; // 'all' | 'today' | 'week' | 'month'
    workType: 'all' | 'remote' | 'on-site' | 'hybrid';
    employerStatus: 'all' | 'active' | 'inactive';
    urgentOnly: boolean;
    page: number;
    limit: number;
}

export function ModerationDashboard() {
    const [filters, setFilters] = useState<ModerationFilters>({
        search: '',
        sort: 'urgent',
        dateRange: 'all',
        workType: 'all',
        employerStatus: 'all',
        urgentOnly: false,
        page: 1,
        limit: 10
    });

    const [stats, setStats] = useState<any>(null);
    const [statsLoading, setStatsLoading] = useState(true);

    const [jobs, setJobs] = useState<any[]>([]);
    const [jobsLoading, setJobsLoading] = useState(true);
    const [pagination, setPagination] = useState({ total: 0, page: 1, totalPages: 1 });

    const fetchStats = async () => {
        try {
            const res = await fetch('/api/admin/jobs/moderation/stats');
            const data = await res.json();
            if (res.ok) setStats(data);
        } catch (error) {
            console.error(error);
        } finally {
            setStatsLoading(false);
        }
    };

    const fetchJobs = useCallback(async () => {
        setJobsLoading(true);
        try {
            const params = new URLSearchParams();
            if (filters.search) params.append('search', filters.search);
            if (filters.sort) params.append('sort', filters.sort);
            if (filters.dateRange && filters.dateRange !== 'all') params.append('dateRange', filters.dateRange);
            if (filters.workType && filters.workType !== 'all') params.append('workType', filters.workType);
            if (filters.employerStatus && filters.employerStatus !== 'all') params.append('employerStatus', filters.employerStatus);
            if (filters.urgentOnly) params.append('urgentOnly', 'true');
            params.append('page', filters.page.toString());
            params.append('limit', filters.limit.toString());

            const res = await fetch(`/api/admin/jobs/moderation?${params.toString()}`);
            const json = await res.json();
            if (res.ok) {
                setJobs(json.data || []);
                const meta = json.meta || { total: 0, page: 1, totalPages: 1 };
                setPagination(meta);
                // Synchronize total with bulk selection context if needed
                // But wait, we need to access the context here.
            }
        } catch (error) {
            console.error(error);
        } finally {
            setJobsLoading(false);
        }
    }, [filters]);

    useEffect(() => {
        fetchStats();
    }, []);

    useEffect(() => {
        fetchJobs();
    }, [fetchJobs]);

    const [isBulkProcessing, setIsBulkProcessing] = useState(false);
    const [activeBulkModal, setActiveBulkModal] = useState<'approve' | 'reject' | 'changes' | null>(null);

    const handleUndo = async (batchId: string) => {
        const loadingToast = toast.loading('Reverting batch operation...');
        try {
            const res = await fetch('/api/admin/jobs/moderation/bulk/undo', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ batchId })
            });

            if (res.ok) {
                toast.success('Batch operation reverted successfully', { id: loadingToast });
                handleRefresh();
            } else {
                throw new Error('Failed to revert operation');
            }
        } catch (error: any) {
            toast.error(error.message, { id: loadingToast });
        }
    };

    const handleBulkAction = async (action: 'approve' | 'reject' | 'changes', data?: any) => {
        if (!data) {
            setActiveBulkModal(action);
            return;
        }

        setIsBulkProcessing(true);
        const loadingToast = toast.loading(`Processing bulk ${action}...`);

        try {
            const res = await fetch('/api/admin/jobs/moderation/bulk', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    action,
                    ...data
                })
            });

            if (res.ok) {
                const result = await res.json();
                const batchId = result.batchId;

                toast.success((t) => (
                    <div className="flex items-center gap-3">
                        <span>Successfully processed bulk {action}</span>
                        {batchId && (
                            <button
                                onClick={async () => {
                                    toast.dismiss(t.id);
                                    await handleUndo(batchId);
                                }}
                                className="px-2 py-1 bg-slate-900 text-white text-[10px] font-bold rounded hover:bg-black transition-all"
                            >
                                UNDO
                            </button>
                        )}
                    </div>
                ), { id: loadingToast, duration: 6000 });

                handleRefresh();
                setActiveBulkModal(null);
            } else {
                const err = await res.json();
                throw new Error(err.error || 'Failed to process bulk action');
            }
        } catch (error: any) {
            toast.error(error.message, { id: loadingToast });
        } finally {
            setIsBulkProcessing(false);
        }
    };

    const handleRefresh = () => {
        fetchStats();
        fetchJobs();
    };

    return (
        <BulkSelectionProvider>
            <div className="space-y-6 relative pb-20">
                <ModerationStats stats={stats} loading={statsLoading} />

                <div className="bg-white rounded-xl shadow-sm border border-slate-200 overflow-hidden">
                    <FilterPanel filters={filters} setFilters={setFilters} stats={stats} />

                    <JobModerationQueueList
                        jobs={jobs}
                        loading={jobsLoading}
                        pagination={pagination}
                        filters={filters}
                        setFilters={setFilters}
                        onRefresh={handleRefresh}
                    />
                </div>

                <BulkFloatingBar
                    onAction={handleBulkAction}
                    isProcessing={isBulkProcessing}
                />

                <QueueTotalSync total={pagination.total} />

                <BulkModalsWrapper
                    activeModal={activeBulkModal}
                    onClose={() => setActiveBulkModal(null)}
                    onAction={handleBulkAction}
                    isProcessing={isBulkProcessing}
                    filters={filters}
                />
            </div>
        </BulkSelectionProvider>
    );
}

function QueueTotalSync({ total }: { total: number }) {
    const { setTotalInQueue } = useBulkSelection();
    useEffect(() => {
        setTotalInQueue(total);
    }, [total, setTotalInQueue]);
    return null;
}

// Wrapper to access context safely inside the provider
function BulkModalsWrapper({ activeModal, onClose, onAction, isProcessing, filters }: any) {
    const { selectedIds, isAllInQueueSelected, clearSelection } = useBulkSelection();

    const handleAction = async (data: any) => {
        await onAction(activeModal, {
            ...data,
            jobIds: isAllInQueueSelected ? [] : selectedIds,
            allInQueue: isAllInQueueSelected,
            filters: isAllInQueueSelected ? filters : undefined
        });
        clearSelection();
    };

    return (
        <>
            <BulkApproveModal
                isOpen={activeModal === 'approve'}
                onClose={onClose}
                onApprove={handleAction}
                isProcessing={isProcessing}
            />
            <BulkRejectModal
                isOpen={activeModal === 'reject'}
                onClose={onClose}
                onReject={handleAction}
                isProcessing={isProcessing}
            />
            <BulkRequestChangesModal
                isOpen={activeModal === 'changes'}
                onClose={onClose}
                onRequestChanges={handleAction}
                isProcessing={isProcessing}
            />
        </>
    );
}
