"use client";

import { useState, useCallback } from "react";
import { LayoutList, LayoutGrid, Columns3, Plus, Download, CalendarDays } from "lucide-react";
import Link from "next/link";
import { AdvancedFilters } from "./AdvancedFilters";
import { ApplicationCardDetailed } from "./ApplicationCardDetailed";
import { BulkActionsToolbar } from "./BulkActionsToolbar";
import { KanbanBoard } from "../KanbanBoard";
import { InterviewCalendar } from "./InterviewCalendar";
import { updateApplicationStatus } from "@/app/actions/applicationActions";
import { useRouter } from "next/navigation";
import { PipelineAnalyticsDashboard } from "../../ats/PipelineAnalyticsDashboard";
import { ChevronDown, ChevronUp, BarChart } from "lucide-react";

interface EmployerApplicationsDashboardProps {
    applications: any[];
    jobs: any[];
    statusCounts: Record<string, number>;
    interviews: any[];
}

type ViewMode = "list" | "card" | "kanban" | "calendar";

export function EmployerApplicationsDashboard({
    applications: initialApplications,
    jobs,
    statusCounts,
    interviews,
}: EmployerApplicationsDashboardProps) {
    const router = useRouter();
    const [viewMode, setViewMode] = useState<ViewMode>("list");
    const [selectedIds, setSelectedIds] = useState<Set<string>>(new Set());
    const [filteredApplications, setFilteredApplications] = useState(initialApplications);
    const [selectedJobId, setSelectedJobId] = useState<string | null>(null);
    const [showAnalytics, setShowAnalytics] = useState(false);

    const handleFiltersChange = useCallback(
        (filters: any) => {
            let result = [...initialApplications];

            // Client-side filtering for all non-search filters
            if (filters.status && filters.status !== "all") {
                result = result.filter((app) => app.status === filters.status);
            }

            if (filters.jobId) {
                result = result.filter((app) => app.job_id === filters.jobId || app.job?.id === filters.jobId);
                setSelectedJobId(filters.jobId);
            } else {
                setSelectedJobId(null);
            }

            if (filters.dateRange) {
                const now = new Date();
                const dateMap: Record<string, Date> = {
                    today: new Date(now.getFullYear(), now.getMonth(), now.getDate()),
                    week: new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000),
                    month: new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000),
                    quarter: new Date(now.getTime() - 90 * 24 * 60 * 60 * 1000),
                };
                if (dateMap[filters.dateRange]) {
                    result = result.filter(
                        (app) => new Date(app.applied_at) >= dateMap[filters.dateRange]
                    );
                }
            }

            if (filters.minMatchScore) {
                const min = parseInt(filters.minMatchScore);
                result = result.filter(
                    (app) => app.match_score && app.match_score >= min
                );
            }

            if (filters.search) {
                const q = filters.search.toLowerCase();
                result = result.filter(
                    (app) =>
                        app.candidate?.name?.toLowerCase().includes(q) ||
                        app.candidate?.email?.toLowerCase().includes(q)
                );
            }

            // Sort
            if (filters.sortBy === "oldest") {
                result.sort(
                    (a, b) =>
                        new Date(a.applied_at).getTime() - new Date(b.applied_at).getTime()
                );
            } else if (filters.sortBy === "match_score") {
                result.sort((a, b) => (b.match_score || 0) - (a.match_score || 0));
            } else if (filters.sortBy === "rating") {
                result.sort((a, b) => (b.rating || 0) - (a.rating || 0));
            } else if (filters.sortBy === "name") {
                result.sort((a, b) =>
                    (a.candidate?.name || "").localeCompare(b.candidate?.name || "")
                );
            } else {
                result.sort(
                    (a, b) =>
                        new Date(b.applied_at).getTime() - new Date(a.applied_at).getTime()
                );
            }

            setFilteredApplications(result);
        },
        [initialApplications]
    );

    const toggleSelect = (id: string, selected: boolean) => {
        setSelectedIds((prev) => {
            const next = new Set(prev);
            if (selected) next.add(id);
            else next.delete(id);
            return next;
        });
    };

    const handleBulkStatusChange = async (status: string) => {
        try {
            await Promise.all(
                Array.from(selectedIds).map((id) =>
                    updateApplicationStatus(id, status as any)
                )
            );
            setSelectedIds(new Set());
            router.refresh();
        } catch (error) {
            console.error("Bulk status change failed:", error);
        }
    };

    const handleBulkExport = () => {
        // Client-side CSV export
        const selected = filteredApplications.filter((a) =>
            selectedIds.has(a.id)
        );
        const headers = ["Name", "Email", "Job", "Status", "Match Score", "Applied Date", "Rating"];
        const rows = selected.map((a) => [
            a.candidate?.name || "",
            a.candidate?.email || "",
            a.job?.title || "",
            a.status,
            a.match_score || "",
            new Date(a.applied_at).toLocaleDateString(),
            a.rating || "",
        ]);
        const csv =
            [headers.join(","), ...rows.map((r) => r.join(","))].join("\n");

        const blob = new Blob([csv], { type: "text/csv" });
        const url = URL.createObjectURL(blob);
        const a = document.createElement("a");
        a.href = url;
        a.download = "applications_export.csv";
        a.click();
        URL.revokeObjectURL(url);
    };

    const viewModes = [
        { id: "list" as ViewMode, label: "List", icon: LayoutList },
        { id: "card" as ViewMode, label: "Cards", icon: LayoutGrid },
        { id: "kanban" as ViewMode, label: "Kanban", icon: Columns3 },
        { id: "calendar" as ViewMode, label: "Calendar", icon: CalendarDays },
    ];

    return (
        <div className="space-y-5">
            {/* Quick Actions Bar */}
            <div className="flex flex-wrap items-center gap-3">
                <Link
                    href="/dashboard/employer/post-job"
                    className="inline-flex items-center gap-2 px-4 py-2.5 bg-primary text-white text-sm font-semibold rounded-xl hover:bg-primary/90 transition-colors shadow-sm shadow-primary/20"
                >
                    <Plus className="w-4 h-4" />
                    Post New Job
                </Link>

                {/* View Mode Switcher */}
                <div className="flex items-center gap-1 bg-slate-100 p-1 rounded-xl ml-auto">
                    {viewModes.map((mode) => {
                        const Icon = mode.icon;
                        return (
                            <button
                                key={mode.id}
                                onClick={() => setViewMode(mode.id)}
                                className={`flex items-center gap-1.5 px-3 py-1.5 text-xs font-semibold rounded-lg transition-all ${viewMode === mode.id
                                    ? "bg-white text-primary shadow-sm"
                                    : "text-slate-600 hover:text-slate-900"
                                    }`}
                            >
                                <Icon className="w-3.5 h-3.5" />
                                {mode.label}
                            </button>
                        );
                    })}
                </div>
            </div>

            {/* Advanced Filters */}
            <AdvancedFilters
                jobs={jobs}
                initialFilters={{
                    jobId: "",
                    status: "all",
                    dateRange: "",
                    minMatchScore: "",
                    search: "",
                    sortBy: "recent",
                }}
                statusCounts={statusCounts}
                onFiltersChange={handleFiltersChange}
            />

            {/* Pipeline Analytics (Expandable when a Job is Selected) */}
            {selectedJobId && (
                <div className="bg-slate-50 border border-slate-200 rounded-2xl overflow-hidden transition-all duration-300">
                    <button
                        onClick={() => setShowAnalytics(!showAnalytics)}
                        className="w-full flex items-center justify-between p-4 hover:bg-slate-100 transition-colors"
                    >
                        <div className="flex items-center gap-2">
                            <div className="p-1.5 bg-blue-100 text-blue-600 rounded-lg">
                                <BarChart className="w-5 h-5" />
                            </div>
                            <span className="font-semibold text-slate-800">Job Pipeline Analytics</span>
                        </div>
                        {showAnalytics ? <ChevronUp className="w-5 h-5 text-slate-500" /> : <ChevronDown className="w-5 h-5 text-slate-500" />}
                    </button>
                    {showAnalytics && (
                        <div className="p-6 border-t border-slate-200 bg-white">
                            <PipelineAnalyticsDashboard jobId={selectedJobId} />
                        </div>
                    )}
                </div>
            )}

            {/* Results Info */}
            <div className="flex items-center justify-between">
                <p className="text-sm text-slate-500">
                    Showing <strong className="text-slate-700">{filteredApplications.length}</strong> application{filteredApplications.length !== 1 ? "s" : ""}
                </p>
                {viewMode === "list" && filteredApplications.length > 0 && (
                    <button
                        onClick={() => {
                            if (selectedIds.size === filteredApplications.length) {
                                setSelectedIds(new Set());
                            } else {
                                setSelectedIds(
                                    new Set(filteredApplications.map((a) => a.id))
                                );
                            }
                        }}
                        className="text-xs font-semibold text-primary hover:text-primary/80"
                    >
                        {selectedIds.size === filteredApplications.length
                            ? "Deselect All"
                            : "Select All"}
                    </button>
                )}
            </div>

            {/* Applications Display */}
            {filteredApplications.length === 0 ? (
                <div className="flex flex-col items-center justify-center py-16 rounded-2xl border-2 border-dashed border-slate-200 bg-slate-50/50">
                    <LayoutList className="w-12 h-12 text-slate-300 mb-4" />
                    <h3 className="text-lg font-bold text-slate-700">No applications found</h3>
                    <p className="text-sm text-slate-500 mt-2">
                        Try adjusting your filters or post a new job to attract candidates.
                    </p>
                </div>
            ) : viewMode === "calendar" ? (
                <InterviewCalendar interviews={interviews} />
            ) : viewMode === "kanban" ? (
                <KanbanBoard
                    applications={filteredApplications}
                    selectedJobId={selectedJobId}
                />
            ) : viewMode === "card" ? (
                <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
                    {filteredApplications.map((app) => (
                        <ApplicationCardDetailed
                            key={app.id}
                            application={app}
                            onSelect={toggleSelect}
                            isSelected={selectedIds.has(app.id)}
                        />
                    ))}
                </div>
            ) : (
                <div className="space-y-3">
                    {filteredApplications.map((app) => (
                        <ApplicationCardDetailed
                            key={app.id}
                            application={app}
                            onSelect={toggleSelect}
                            isSelected={selectedIds.has(app.id)}
                        />
                    ))}
                </div>
            )}

            {/* Bulk Actions Toolbar */}
            <BulkActionsToolbar
                selectedCount={selectedIds.size}
                onClearSelection={() => setSelectedIds(new Set())}
                onBulkStatusChange={handleBulkStatusChange}
                onBulkExport={handleBulkExport}
            />
        </div>
    );
}
