"use client";

import { useState } from "react";
import Link from "next/link";
import { useRouter } from "next/navigation";
import {
  Archive, BarChart3, Copy, Eye, FlaskConical, MoreHorizontal, Pencil, Plus, RotateCcw, Send, Tag, Trash2, Undo2,
} from "lucide-react";
import { useRepositories } from "@/di/repository-provider";
import { env } from "@/infrastructure/config/env";
import { useT, useLocale } from "@/shared/i18n/client";
import { ROUTES } from "@/shared/constants";
import { ANNOUNCEMENT_FORMATS } from "@/shared/constants/announcements";
import { displayState, formatParis } from "@/shared/lib/announcements";
import { cn } from "@/shared/lib/utils";
import { usePageHeader } from "@/presentation/hooks/use-page-header";
import { useApiQuery } from "@/presentation/hooks/use-api-query";
import { useServerPagination } from "@/presentation/hooks/use-server-pagination";
import ServerDataTable, { type Column } from "@/presentation/components/shared/server-data-table";
import { Button } from "@/presentation/components/ui/button";
import { SearchableSelect } from "@/presentation/components/ui/searchable-select";
import {
  DropdownMenu,
  DropdownMenuContent,
  DropdownMenuItem,
  DropdownMenuSeparator,
  DropdownMenuTrigger,
} from "@/presentation/components/ui/dropdown-menu";
import {
  AnnouncementIcon,
  DisplayStateBadge,
  FormatBadge,
} from "@/presentation/components/announcements/announcement-badges";
import {
  useAnnouncementActions,
  useAvailableActions,
  type AnnouncementAction,
} from "@/presentation/components/announcements/announcement-actions";
import { useAnnouncementPermissions } from "@/presentation/components/announcements/use-announcement-permissions";
import type { Announcement, AnnouncementAudience, AnnouncementDisplayState } from "@/domain/entities/announcement";

const STATES: (AnnouncementDisplayState | "all")[] = ["all", "draft", "scheduled", "live", "ended", "archived"];

const ACTION_ICONS: Record<AnnouncementAction, React.ComponentType<{ className?: string }>> = {
  edit: Pencil,
  preview: Eye,
  publish: Send,
  duplicate: Copy,
  delete: Trash2,
  unpublish: Undo2,
  archive: Archive,
  reset: RotateCcw,
  stats: BarChart3,
};

function audienceCriteria(a: AnnouncementAudience): number {
  return [
    a.plans.length, a.capabilities_required.length, a.capabilities_missing.length, a.permissions.length,
    a.roles.length, a.companies_include.length, a.companies_exclude.length, a.languages.length, a.new_users_only ? 1 : 0,
  ].filter(Boolean).length;
}

export default function AnnouncementsPage() {
  const t = useT();
  const locale = useLocale();
  const router = useRouter();
  usePageHeader(t.pages.announcements.title, t.pages.announcements.subtitle);
  const { announcementRepository } = useRepositories();
  const { canManage } = useAnnouncementPermissions();
  const available = useAvailableActions();
  const [refreshKey, setRefreshKey] = useState(0);

  const pagination = useServerPagination({ orderBy: "updated_at", order: "DESC" });
  const { filters, setFilter } = pagination;

  const { data, loading, error } = useApiQuery(() => announcementRepository.list(pagination.params), {
    deps: [pagination.params, refreshKey],
  });

  const { run, dialogs } = useAnnouncementActions(() => setRefreshKey((k) => k + 1));
  const L = t.announcements.list;

  const columns: Column<Announcement>[] = [
    {
      key: "title",
      label: L.columns.title,
      sortable: true,
      render: (a) => (
        <div className="flex min-w-[220px] items-start gap-2.5">
          <span className="mt-0.5 flex h-8 w-8 shrink-0 items-center justify-center rounded-lg bg-blue-50 text-blue-600">
            <AnnouncementIcon name={a.icon} className="h-4 w-4" />
          </span>
          <div className="min-w-0">
            <div className="truncate text-sm font-semibold">{a.title.fr || "—"}</div>
            <div className="truncate font-mono text-[11px] text-muted-foreground">
              {a.key}
              {a.round > 1 && <span className="ml-1.5 font-sans">· {L.round(a.round)}</span>}
            </div>
          </div>
        </div>
      ),
    },
    { key: "format", label: L.columns.format, render: (a) => <FormatBadge format={a.format} stepCount={a.steps.length} /> },
    { key: "state", label: L.columns.state, render: (a) => <DisplayStateBadge state={displayState(a)} /> },
    {
      key: "starts_at",
      label: L.columns.dates,
      sortable: true,
      render: (a) => (
        <div className="whitespace-nowrap text-xs">
          <div>{a.starts_at ? L.from(formatParis(a.starts_at, locale, false)) : L.immediately}</div>
          <div className="text-muted-foreground">{a.ends_at ? L.until(formatParis(a.ends_at, locale, false)) : L.noEnd}</div>
        </div>
      ),
    },
    {
      key: "audience",
      label: L.columns.audience,
      render: (a) => {
        const n = audienceCriteria(a.audience);
        return (
          <div className="whitespace-nowrap text-xs">
            <div className="font-medium">{a.counts.eligible.toLocaleString(locale === "fr" ? "fr-FR" : "en-US")}</div>
            <div className="text-muted-foreground">{n ? L.audienceParts(n) : L.audienceEveryone}</div>
          </div>
        );
      },
    },
    {
      key: "seen",
      label: L.columns.results,
      sortable: true,
      render: (a) => (
        <div className="grid grid-cols-3 gap-3">
          <Num label={L.columns.seen} value={a.counts.seen} of={a.counts.eligible} />
          <Num label={L.columns.clicked} value={a.counts.clicked} of={a.counts.seen} />
          <Num label={L.columns.completed} value={a.counts.completed} of={a.counts.seen} />
        </div>
      ),
    },
    {
      key: "actions",
      label: "",
      className: "w-10",
      render: (a) => {
        const actions = available(a).filter((action) => canManage || action === "stats");
        return (
          <DropdownMenu>
            <DropdownMenuTrigger asChild>
              <Button variant="ghost" size="icon-sm" onClick={(e) => e.stopPropagation()} aria-label={a.title.fr}>
                <MoreHorizontal className="h-4 w-4" />
              </Button>
            </DropdownMenuTrigger>
            <DropdownMenuContent align="end" onClick={(e) => e.stopPropagation()}>
              {actions.map((action, i) => {
                const Icon = ACTION_ICONS[action];
                const destructive = action === "delete";
                return (
                  <div key={action}>
                    {destructive && i > 0 && <DropdownMenuSeparator />}
                    <DropdownMenuItem onClick={() => run(action, a)} className={destructive ? "text-destructive focus:text-destructive" : undefined}>
                      <Icon className="mr-2 h-4 w-4" />
                      {t.announcements.actions[action]}
                    </DropdownMenuItem>
                  </div>
                );
              })}
            </DropdownMenuContent>
          </DropdownMenu>
        );
      },
    },
  ];

  const activeState = (filters.state as string | undefined) ?? "all";

  return (
    <div className="space-y-4 p-6">
      <div className="flex flex-wrap items-center justify-between gap-3">
        <div className="flex flex-wrap items-center gap-1.5" role="tablist" aria-label={L.columns.state}>
          {STATES.map((state) => (
            <button
              key={state}
              type="button"
              role="tab"
              aria-selected={activeState === state}
              onClick={() => setFilter("state", state === "all" ? undefined : state)}
              className={cn(
                "rounded-full border px-3 py-1 text-xs font-medium transition-colors",
                activeState === state ? "border-blue-600 bg-blue-600 text-white" : "bg-background text-muted-foreground hover:bg-muted",
              )}
            >
              {state === "all" ? L.allStates : t.announcements.states[state]}
            </button>
          ))}
          {env.announcementsMock && (
            <span className="ml-2 inline-flex items-center gap-1 rounded-full border border-purple-200 bg-purple-50 px-2.5 py-0.5 text-xs font-medium text-purple-700">
              <FlaskConical className="h-3 w-3" />
              {t.announcements.mockBanner}
            </span>
          )}
        </div>
        {canManage && (
          <div className="flex items-center gap-2">
            {/* The BETA-like labels of Fleet's menu (SCRUM-443). */}
            <Button asChild size="sm" variant="outline">
              <Link href={ROUTES.announcementMenuLabels}>
                <Tag className="mr-1.5 h-4 w-4" />
                {t.announcements.menuLabels.button}
              </Link>
            </Button>
            <Button asChild size="sm">
              <Link href={ROUTES.announcementNew}>
                <Plus className="mr-1.5 h-4 w-4" />
                {t.announcements.newButton}
              </Link>
            </Button>
          </div>
        )}
      </div>

      {error ? (
        <div className="rounded-xl border border-red-200 bg-red-50 px-4 py-3 text-sm text-red-700">
          {t.announcements.errors.load} <span className="text-red-500">({error})</span>
        </div>
      ) : (
        <ServerDataTable
          columns={columns}
          data={data?.items ?? []}
          total={data?.total ?? 0}
          page={pagination.page}
          totalPages={data?.last_page ?? 1}
          loading={loading}
          search={pagination.search}
          onSearchChange={pagination.setSearch}
          searchPlaceholder={L.searchPlaceholder}
          onPageChange={pagination.setPage}
          onSortChange={pagination.setSort}
          sortBy={pagination.orderBy}
          sortOrder={pagination.order}
          onRowClick={(a) => router.push(`${ROUTES.announcements}/${a.id}`)}
          emptyMessage={L.empty}
          toolbar={
            <SearchableSelect
              triggerClassName="w-52"
              value={(filters.format as string | undefined) ?? "all"}
              onValueChange={(v) => setFilter("format", v === "all" ? undefined : v)}
              options={[
                { value: "all", label: L.allFormats },
                ...ANNOUNCEMENT_FORMATS.map((f) => ({ value: f, label: t.announcements.formats[f].name })),
              ]}
            />
          }
        />
      )}
      {dialogs}
    </div>
  );
}

function Num({ label, value, of }: { label: string; value: number; of: number }) {
  const pct = of > 0 ? Math.round((value / of) * 100) : null;
  return (
    <div className="whitespace-nowrap text-right text-xs" title={label}>
      <div className="font-semibold tabular-nums">{value.toLocaleString()}</div>
      <div className="tabular-nums text-muted-foreground">{pct !== null ? `${pct} %` : "—"}</div>
    </div>
  );
}
