"use client";

import { useState, useEffect } from "react";
import { useRouter, useSearchParams } from "next/navigation";
import { BookmarkCheck, Trash2, ChevronRight, Sparkles, X } from "lucide-react";
import { FilterPanel, MobileFilterButton } from "./FilterPanel";
import { SortBar } from "./SortBar";
import { ActiveFilters } from "./ActiveFilters";
import { JobCard } from "../JobCard";
import { Pagination } from "./Pagination";
import { EmptyState } from "./EmptyState";
import { getSavedSearches, deleteSavedSearch, saveSearch } from "@/app/actions/savedSearchActions";

interface Job {
    id: string;
    title: string;
    company: string;
    city?: string | null;
    state?: string | null;
    country?: string | null;
    type: string;
    work_location_type?: string | null;
    salary_min?: number | null;
    salary_max?: number | null;
    currency?: string | null;
    posted_at: string;
    deadline?: string | null;
    logo_url?: string | null;
    is_featured?: boolean;
    experience_level?: string | null;
    skills?: { skill: { name: string } }[];
    matchScore?: number;
    [key: string]: any;
}

interface SavedSearch {
    id: string;
    name: string;
    filters: Record<string, any>;
    alert_frequency: string;
    new_job_count: number;
    created_at: string;
}

interface JobListingClientProps {
    initialJobs: Job[];
    totalPages: number;
    currentPage: number;
    total: number;
    pageSize: number;
    isLoggedIn?: boolean;
}

export default function JobListingClient({
    initialJobs,
    totalPages,
    currentPage,
    total,
    pageSize,
    isLoggedIn = false,
}: JobListingClientProps) {
    const router = useRouter();
    const searchParams = useSearchParams();
    const [view, setView] = useState<"list" | "grid">(
        (searchParams.get("view") as "list" | "grid") || "list"
    );
    const [savedSearches, setSavedSearches] = useState<SavedSearch[]>([]);
    const [loadedSaved, setLoadedSaved] = useState(false);

    // Save Search Modal State
    const [isSaveModalOpen, setIsSaveModalOpen] = useState(false);
    const [searchName, setSearchName] = useState("");
    const [alertFrequency, setAlertFrequency] = useState<"none" | "daily" | "weekly">("daily");
    const [isSaving, setIsSaving] = useState(false);

    // Load saved searches for logged-in users
    useEffect(() => {
        if (isLoggedIn && !loadedSaved) {
            getSavedSearches().then((data) => {
                setSavedSearches(data as unknown as SavedSearch[]);
                setLoadedSaved(true);
            }).catch(() => setLoadedSaved(true));
        }
    }, [isLoggedIn, loadedSaved]);

    const handleViewChange = (newView: "list" | "grid") => {
        setView(newView);
        const params = new URLSearchParams(searchParams.toString());
        if (newView === "grid") params.set("view", "grid");
        else params.delete("view");
        router.push(`/jobs?${params.toString()}`, { scroll: false });
    };

    const handleApplySavedSearch = (filters: Record<string, any>) => {
        const params = new URLSearchParams();
        Object.entries(filters).forEach(([key, value]) => {
            if (value) params.set(key, String(value));
        });
        router.push(`/jobs?${params.toString()}`);
    };

    const handleDeleteSaved = async (id: string) => {
        try {
            await deleteSavedSearch(id);
            setSavedSearches((prev) => prev.filter((s) => s.id !== id));
        } catch (error) {
            console.error("Failed to delete saved search:", error);
        }
    };

    const handleSaveSearch = async () => {
        if (!searchName.trim()) return;
        setIsSaving(true);
        try {
            const filters: Record<string, string> = {};
            searchParams.forEach((value, key) => {
                if (key !== "page" && key !== "view") {
                    filters[key] = value;
                }
            });
            const newSearch = await saveSearch(searchName, filters, alertFrequency);
            if (newSearch) {
                setSavedSearches((prev) => [newSearch as unknown as SavedSearch, ...prev]);
                setIsSaveModalOpen(false);
                setSearchName("");
            }
        } catch (error) {
            console.error("Failed to save search:", error);
        } finally {
            setIsSaving(false);
        }
    };

    // Count active filters
    const activeFilterCount = [
        searchParams.get("type"),
        searchParams.get("workLocation"),
        searchParams.get("experience"),
        searchParams.get("datePosted") && searchParams.get("datePosted") !== "any" ? "yes" : null,
        searchParams.get("salaryMin"),
        searchParams.get("companySize"),
        searchParams.get("schedule"),
        searchParams.get("industry"),
    ].filter(Boolean).length;

    const hasFilters = activeFilterCount > 0 || searchParams.has("q") || searchParams.has("l");

    return (
        <div className="max-w-7xl mx-auto px-6 py-8 relative">
            {/* Save Search Modal */}
            {isSaveModalOpen && (
                <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/50 backdrop-blur-sm p-4">
                    <div className="bg-white rounded-2xl shadow-xl w-full max-w-md overflow-hidden" onClick={(e) => e.stopPropagation()}>
                        <div className="flex items-center justify-between px-6 py-4 border-b border-slate-100">
                            <h3 className="font-bold text-slate-800">Save Search Alert</h3>
                            <button onClick={() => setIsSaveModalOpen(false)} className="text-slate-400 hover:bg-slate-100 rounded-full p-1 transition-colors">
                                <X className="h-5 w-5" />
                            </button>
                        </div>
                        <div className="p-6 space-y-4">
                            <div>
                                <label className="block text-sm font-medium text-slate-700 mb-1">Alert Name</label>
                                <input
                                    type="text"
                                    placeholder="e.g. Remote Frontend Roles"
                                    className="w-full border border-slate-200 rounded-lg px-4 py-2.5 text-sm focus:outline-none focus:ring-2 focus:ring-primary/20 focus:border-primary transition-all"
                                    value={searchName}
                                    onChange={(e) => setSearchName(e.target.value)}
                                    autoFocus
                                />
                            </div>
                            <div>
                                <label className="block text-sm font-medium text-slate-700 mb-1">Email Alert Frequency</label>
                                <div className="grid grid-cols-3 gap-2">
                                    {['daily', 'weekly', 'none'].map((freq) => (
                                        <button
                                            key={freq}
                                            onClick={() => setAlertFrequency(freq as any)}
                                            className={`px-3 py-2 border rounded-lg text-sm font-medium capitalize tracking-wide transition-colors ${alertFrequency === freq
                                                    ? 'bg-primary/10 border-primary text-primary'
                                                    : 'bg-white border-slate-200 text-slate-600 hover:bg-slate-50'
                                                }`}
                                        >
                                            {freq}
                                        </button>
                                    ))}
                                </div>
                            </div>
                        </div>
                        <div className="flex items-center justify-end gap-3 px-6 py-4 bg-slate-50 border-t border-slate-100">
                            <button
                                onClick={() => setIsSaveModalOpen(false)}
                                className="px-4 py-2 text-sm font-medium text-slate-600 hover:bg-slate-200 rounded-lg transition-colors"
                            >
                                Cancel
                            </button>
                            <button
                                onClick={handleSaveSearch}
                                disabled={isSaving || !searchName.trim()}
                                className="px-5 py-2 text-sm font-medium text-white bg-primary hover:bg-primary/90 rounded-lg shadow-sm disabled:opacity-50 transition-colors flex items-center gap-2"
                            >
                                {isSaving ? "Saving..." : "Save Alert"}
                            </button>
                        </div>
                    </div>
                </div>
            )}

            <div className="flex flex-col lg:flex-row gap-8">
                {/* Left sidebar — Filters + Saved Searches */}
                <aside className="hidden lg:block w-72 shrink-0 space-y-6">
                    {/* Saved Searches */}
                    {isLoggedIn && savedSearches.length > 0 && (
                        <div className="bg-white rounded-2xl border border-slate-200 shadow-sm overflow-hidden">
                            <div className="flex items-center gap-2 px-5 py-4 border-b border-slate-100">
                                <BookmarkCheck className="h-4 w-4 text-blue-500" />
                                <span className="text-sm font-bold text-slate-800">Saved Searches</span>
                                <span className="ml-auto text-xs text-slate-400">{savedSearches.length}</span>
                            </div>
                            <div className="p-3 space-y-1 max-h-[280px] overflow-y-auto">
                                {savedSearches.map((search) => (
                                    <div
                                        key={search.id}
                                        className="group flex items-center gap-2 rounded-lg px-3 py-2 hover:bg-blue-50 transition-colors cursor-pointer"
                                        onClick={() => handleApplySavedSearch(search.filters)}
                                    >
                                        <div className="flex-1 min-w-0">
                                            <p className="text-sm font-medium text-slate-700 truncate group-hover:text-blue-700">
                                                {search.name}
                                            </p>
                                            <p className="text-[10px] text-slate-400">
                                                {search.alert_frequency !== "none" ? `📧 ${search.alert_frequency}` : "No alerts"}
                                            </p>
                                        </div>
                                        {search.new_job_count > 0 && (
                                            <span className="flex h-5 min-w-5 items-center justify-center rounded-full bg-blue-600 px-1.5 text-[10px] font-bold text-white">
                                                {search.new_job_count}
                                            </span>
                                        )}
                                        <button
                                            onClick={(e) => { e.stopPropagation(); handleDeleteSaved(search.id); }}
                                            className="opacity-0 group-hover:opacity-100 p-1 rounded hover:bg-red-50 transition-all"
                                            aria-label={`Delete ${search.name}`}
                                        >
                                            <Trash2 className="h-3 w-3 text-red-400" />
                                        </button>
                                    </div>
                                ))}
                            </div>
                        </div>
                    )}

                    <FilterPanel />
                </aside>

                {/* Main content */}
                <main className="flex-1 min-w-0">
                    {/* Mobile filter button */}
                    <div className="lg:hidden mb-4">
                        <MobileFilterButton activeCount={activeFilterCount} />
                    </div>

                    {/* Sort bar — Stitch "SHOWING X MATCHING JOBS" style */}
                    <SortBar
                        total={total}
                        view={view}
                        onViewChange={handleViewChange}
                        isLoggedIn={isLoggedIn}
                    />

                    {/* Active filters */}
                    <div className="mt-3 mb-6 flex flex-col sm:flex-row sm:items-center justify-between gap-4">
                        <ActiveFilters />

                        {isLoggedIn && hasFilters && (
                            <button
                                onClick={() => setIsSaveModalOpen(true)}
                                className="inline-flex items-center self-start sm:self-auto gap-2 text-sm font-medium text-blue-700 bg-blue-50 border border-blue-100 hover:bg-blue-100 px-3 py-1.5 rounded-lg transition-colors shrink-0"
                            >
                                <BookmarkCheck className="h-4 w-4" />
                                Save as Job Alert
                            </button>
                        )}
                    </div>

                    {/* Job listings */}
                    {initialJobs.length > 0 ? (
                        <>
                            <div
                                className={
                                    view === "grid"
                                        ? "grid grid-cols-1 sm:grid-cols-2 gap-4"
                                        : "space-y-4"
                                }
                            >
                                {initialJobs.map((job) => (
                                    <JobCard
                                        key={job.id}
                                        id={job.id}
                                        title={job.title}
                                        company={job.company}
                                        location={[job.city, job.state, job.country].filter(Boolean).join(", ") || "Not specified"}
                                        type={job.type}
                                        salaryMin={job.salary_min ?? undefined}
                                        salaryMax={job.salary_max ?? undefined}
                                        currency={job.currency ?? "NGN"}
                                        postedAt={(() => {
                                            try {
                                                const pa = job.posted_at as any;
                                                if (typeof pa === "string") return pa;
                                                if (pa instanceof Date) return (pa as Date).toISOString();
                                                return new Date(pa).toISOString();
                                            } catch { return new Date().toISOString(); }
                                        })()}
                                        skills={job.skills?.map((s: any) => typeof s === "string" ? s : s.skill?.name).filter(Boolean)}
                                        featured={job.is_featured}
                                        experienceLevel={job.experience_level ?? undefined}
                                        workLocationType={job.work_location_type ?? undefined}
                                        employerId={job.employer_id ?? undefined}
                                        matchScore={job.matchScore}
                                        variant={view}
                                    />
                                ))}
                            </div>

                            <Pagination
                                currentPage={currentPage}
                                totalPages={totalPages}
                                total={total}
                                pageSize={pageSize}
                            />
                        </>
                    ) : (
                        <EmptyState
                            query={searchParams.get("q") || undefined}
                            hasFilters={hasFilters}
                        />
                    )}
                </main>
            </div>
        </div>
    );
}
