import { FileText, PlusCircle, Search, Trash2, Undo2 } from 'lucide-react';
import { toast } from 'sonner';

import { useRef, useState } from 'react';

import { Head, Link, router } from '@inertiajs/react';

import { AdminDataTable } from '@/Components/admin/AdminDataTable';
import { PerPageSelector } from '@/Components/admin/PerPageSelector';
import { SortHeader } from '@/Components/admin/SortHeader';
import PageHeader from '@/Components/layout/PageHeader';
import { Badge } from '@/Components/ui/badge';
import {
  Breadcrumb,
  BreadcrumbItem,
  BreadcrumbLink,
  BreadcrumbList,
  BreadcrumbPage,
  BreadcrumbSeparator,
} from '@/Components/ui/breadcrumb';
import { Button } from '@/Components/ui/button';
import { Checkbox } from '@/Components/ui/checkbox';
import { ConfirmDialog } from '@/Components/ui/confirm-dialog';
import { ExportButton } from '@/Components/ui/export-button';
import { Input } from '@/Components/ui/input';
import {
  Select,
  SelectContent,
  SelectItem,
  SelectTrigger,
  SelectValue,
} from '@/Components/ui/select';
import {
  Table,
  TableBody,
  TableCell,
  TableHead,
  TableHeader,
  TableRow,
} from '@/Components/ui/table';
import { useAdminFilters } from '@/hooks/useAdminFilters';
import { useAdminKeyboardShortcuts } from '@/hooks/useAdminKeyboardShortcuts';
import { useNavigationState } from '@/hooks/useNavigationState';
import AdminLayout from '@/Layouts/AdminLayout';
import { formatRelativeTime } from '@/lib/format';

interface BlogPostRow {
  id: number;
  title: string;
  slug: string;
  author: string | null;
  published_at: string | null;
  deleted_at: string | null;
  created_at: string;
}

interface PaginatedPosts {
  data: BlogPostRow[];
  current_page: number;
  last_page: number;
  from: number | null;
  to: number | null;
  total: number;
}

interface Props {
  posts: PaginatedPosts;
  filters: { trashed: string; search: string; sort?: string; dir?: string; per_page?: number };
}

export default function BlogPostsIndex({ posts, filters }: Props) {
  const [selectedIds, setSelectedIds] = useState<Set<number>>(new Set());
  const [bulkConfirm, setBulkConfirm] = useState<'delete' | 'restore' | null>(null);
  const isNavigating = useNavigationState();
  const searchInputRef = useRef<HTMLInputElement>(null);

  const { search, setSearch, updateFilter, handleSort, handlePage } = useAdminFilters({
    route: route('admin.blog-posts.index'),
    filters,
  });

  function toggleSelect(id: number) {
    setSelectedIds((prev) => {
      const next = new Set(prev);
      if (next.has(id)) next.delete(id); else next.add(id);
      return next;
    });
  }

  function handleBulkDelete() {
    router.post(
      route('admin.blog-posts.bulk-destroy'),
      { ids: [...selectedIds] },
      {
        onSuccess: () => { setSelectedIds(new Set()); setBulkConfirm(null); },
        onError: () => { toast.error('Operation failed. Try again.'); },
      },
    );
  }

  function handleBulkRestore() {
    router.post(
      route('admin.blog-posts.bulk-restore'),
      { ids: [...selectedIds] },
      {
        onSuccess: () => { setSelectedIds(new Set()); setBulkConfirm(null); },
        onError: () => { toast.error('Operation failed. Try again.'); },
      },
    );
  }

  useAdminKeyboardShortcuts({
    onSearch: () => searchInputRef.current?.focus(),
    onNextPage: posts.current_page < posts.last_page ? () => handlePage(posts.current_page + 1) : undefined,
    onPrevPage: posts.current_page > 1 ? () => handlePage(posts.current_page - 1) : undefined,
  });

  const currentPage = posts.current_page;
  const lastPage = posts.last_page;
  useAdminKeyboardShortcuts({
    onNextPage: currentPage < lastPage ? () => handlePage(currentPage + 1) : undefined,
    onPrevPage: currentPage > 1 ? () => handlePage(currentPage - 1) : undefined,
  });

  return (
    <AdminLayout>
      <Head title="Blog Posts" />
      <div className="container py-6 space-y-6">
        <Breadcrumb>
          <BreadcrumbList>
            <BreadcrumbItem>
              <BreadcrumbLink asChild>
                <Link href="/admin">Admin</Link>
              </BreadcrumbLink>
            </BreadcrumbItem>
            <BreadcrumbSeparator />
            <BreadcrumbItem>
              <BreadcrumbPage>Blog Posts</BreadcrumbPage>
            </BreadcrumbItem>
          </BreadcrumbList>
        </Breadcrumb>
        <div className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
          <PageHeader title="Blog Posts" description="Manage marketing blog posts." />
          <div className="flex flex-wrap items-center gap-2">
            <ExportButton
              href={route('admin.blog-posts.export')}
              params={{
                ...(search ? { search } : {}),
                trashed: filters.trashed,
              }}
            />
            <Button asChild size="sm">
              <Link href={route('admin.blog-posts.create')}>
                <PlusCircle className="mr-2 h-4 w-4" />
                New Post
              </Link>
            </Button>
            <div className="relative">
              <Search className="absolute left-2.5 top-2.5 h-4 w-4 text-muted-foreground" aria-hidden="true" />
              <Input
                ref={searchInputRef}
                placeholder="Search title, slug, or author…"
                value={search}
                onChange={(e) => setSearch(e.target.value)}
                className="h-9 w-52 pl-8"
                aria-label="Search blog posts by title, slug, or author"
              />
            </div>
            <Select
              value={filters.trashed ?? 'without'}
              onValueChange={(value) => updateFilter({ trashed: value })}
            >
              <SelectTrigger className="w-36" aria-label="Filter by post status">
                <SelectValue />
              </SelectTrigger>
              <SelectContent>
                <SelectItem value="without">Active</SelectItem>
                <SelectItem value="only">Deleted</SelectItem>
                <SelectItem value="with">All</SelectItem>
              </SelectContent>
            </Select>
            <PerPageSelector
              value={filters.per_page ?? 25}
              onChange={(perPage) => updateFilter({ per_page: perPage })}
            />
          </div>
        </div>

        {selectedIds.size > 0 && (
          <div
            className="flex items-center gap-3 p-3 rounded-lg border bg-muted/40"
            role="status"
            aria-live="polite"
          >
            <span className="text-sm text-muted-foreground">{selectedIds.size} selected</span>
            {filters.trashed !== 'only' && (
              <Button size="sm" variant="destructive" onClick={() => setBulkConfirm('delete')}>
                <Trash2 className="h-3.5 w-3.5 mr-1" />
                Delete Selected
              </Button>
            )}
            {filters.trashed !== 'without' && (
              <Button size="sm" variant="outline" onClick={() => setBulkConfirm('restore')}>
                <Undo2 className="h-3.5 w-3.5 mr-1" />
                Restore Selected
              </Button>
            )}
            <Button size="sm" variant="ghost" onClick={() => setSelectedIds(new Set())}>
              Clear selection
            </Button>
          </div>
        )}

        <AdminDataTable
          isEmpty={posts.data.length === 0}
          isNavigating={isNavigating}
          pagination={posts}
          onPage={handlePage}
          paginationLabel="blog posts"
          emptyIcon={FileText}
          emptyTitle="No blog posts found"
          emptyDescription={
            filters.trashed === 'only'
              ? 'No deleted blog posts.'
              : 'No blog posts in the system yet.'
          }
        >
          <Table>
            <TableHeader>
              <TableRow>
                <TableHead className="w-8" />
                <TableHead>Title</TableHead>
                <TableHead>Slug</TableHead>
                <TableHead>Author</TableHead>
                <SortHeader
                  column="published_at"
                  label="Published"
                  currentSort={filters.sort}
                  currentDir={filters.dir}
                  onSort={handleSort}
                />
                <SortHeader
                  column="created_at"
                  label="Created"
                  currentSort={filters.sort}
                  currentDir={filters.dir}
                  onSort={handleSort}
                />
                {filters.trashed !== 'without' && <TableHead>Deleted</TableHead>}
                <TableHead className="w-[160px]">Actions</TableHead>
              </TableRow>
            </TableHeader>
            <TableBody>
              {posts.data.map((post) => (
                <TableRow key={post.id}>
                  <TableCell>
                    <Checkbox
                      checked={selectedIds.has(post.id)}
                      onCheckedChange={() => toggleSelect(post.id)}
                      aria-label={`Select "${post.title}"`}
                    />
                  </TableCell>
                  <TableCell className="font-medium">
                    {post.title}
                    {post.deleted_at && (
                      <Badge variant="destructive" className="ml-2">
                        Deleted
                      </Badge>
                    )}
                  </TableCell>
                  <TableCell className="text-sm text-muted-foreground">{post.slug}</TableCell>
                  <TableCell className="text-sm text-muted-foreground">{post.author ?? '—'}</TableCell>
                  <TableCell className="text-sm text-muted-foreground">
                    {formatRelativeTime(post.published_at)}
                  </TableCell>
                  <TableCell className="text-sm text-muted-foreground">
                    {formatRelativeTime(post.created_at)}
                  </TableCell>
                  {filters.trashed !== 'without' && (
                    <TableCell className="text-sm text-muted-foreground">
                      {post.deleted_at ? formatRelativeTime(post.deleted_at) : '—'}
                    </TableCell>
                  )}
                  <TableCell>
                    <div className="flex items-center gap-2">
                      {!post.deleted_at && (
                        <Button variant="ghost" size="sm" asChild>
                          <Link href={route('admin.blog-posts.edit', post.id)}>Edit</Link>
                        </Button>
                      )}
                      {!post.deleted_at && (
                        <ConfirmDialog
                          trigger={
                            <Button variant="ghost" size="sm" className="text-destructive hover:text-destructive">
                              Delete
                            </Button>
                          }
                          title="Delete blog post?"
                          description={`"${post.title}" will be soft-deleted and can be restored later.`}
                          confirmLabel="Delete"
                          variant="destructive"
                          onConfirm={() => router.delete(route('admin.blog-posts.destroy', post.id))}
                        />
                      )}
                      {post.deleted_at && (
                        <ConfirmDialog
                          trigger={
                            <Button variant="outline" size="sm">
                              Restore
                            </Button>
                          }
                          title="Restore blog post?"
                          description={`"${post.title}" will be restored and visible to users.`}
                          confirmLabel="Restore"
                          onConfirm={() => router.post(route('admin.blog-posts.restore', post.id))}
                        />
                      )}
                    </div>
                  </TableCell>
                </TableRow>
              ))}
            </TableBody>
          </Table>
        </AdminDataTable>
      </div>
      <ConfirmDialog
        open={bulkConfirm === 'delete'}
        onOpenChange={(open) => !open && setBulkConfirm(null)}
        title="Delete selected blog posts?"
        description={`${selectedIds.size} post(s) will be soft-deleted and can be restored later.`}
        confirmLabel="Delete"
        variant="destructive"
        onConfirm={handleBulkDelete}
      />
      <ConfirmDialog
        open={bulkConfirm === 'restore'}
        onOpenChange={(open) => !open && setBulkConfirm(null)}
        title="Restore selected blog posts?"
        description={`${selectedIds.size} post(s) will be restored and visible to users.`}
        confirmLabel="Restore"
        onConfirm={handleBulkRestore}
      />
    </AdminLayout>
  );
}
