import { keepPreviousData, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import {
  AcquisitionSlot,
  cursorPage,
  PreferenceSuppression,
  RuleAtom,
  type RuleAtomCreate,
  type RuleAtomUpdate,
  RuleDefaults,
  RuleGroup,
  type RuleGroupCreate,
  type RuleGroupKind,
  RuleGroupRevisionList,
  type RuleGroupSource,
  type RuleGroupUpdate,
  RuleKeywordList,
  type RuleLayer,
  RuleParseResult,
  type RulePreviewRequest,
  RulePreviewResult,
  Subscription,
} from "@umt/contracts";
import { api } from "~/lib/api.ts";
import { getParsed, parseOrThrow } from "./library.ts";
import { fetchAllCursorPages } from "./parse.ts";

// 规则(W9-D,docs/runbook/rules.md):规则组 = 收录过滤条件 + 偏好标签合一;自定义条件;三套默认链;抑制记录。
// 写入给 ruleString(优先)或 layers;PATCH 带 expectedRevision,不匹配 409。

export const ruleKeys = {
  all: ["rules"] as const,
  groups: (f: RuleGroupFilters) => ["rules", "groups", f] as const,
  group: (id: string) => ["rules", "group", id] as const,
  revisions: (id: string) => ["rules", "revisions", id] as const,
  keywords: ["rules", "keywords"] as const,
  atoms: ["rules", "atoms"] as const,
  defaults: ["rules", "defaults"] as const,
  suppressions: ["rules", "suppressions"] as const,
  refs: ["rules", "refs"] as const,
};

export type RuleGroupFilters = {
  kind?: RuleGroupKind;
  source?: RuleGroupSource;
  enabled?: "true" | "false";
  includeDeleted?: "true";
  q?: string;
};

const GroupPage = cursorPage(RuleGroup);
const AtomPage = cursorPage(RuleAtom);
const SupPage = cursorPage(PreferenceSuppression);

export function useRuleGroups(filters: RuleGroupFilters = {}) {
  return useQuery({
    queryKey: ruleKeys.groups(filters),
    queryFn: ({ signal }) =>
      fetchAllCursorPages((cursor) => getParsed(GroupPage, "/rules", { ...filters, limit: 200, cursor }, signal)),
    placeholderData: keepPreviousData,
  });
}

export function useRuleGroupRevisions(id: string | null | undefined) {
  return useQuery({
    queryKey: ruleKeys.revisions(id ?? ""),
    enabled: !!id,
    queryFn: async ({ signal }) =>
      (await getParsed(RuleGroupRevisionList, `/rules/${id}/revisions`, undefined, signal)).items,
  });
}

export function useRuleKeywords() {
  return useQuery({
    queryKey: ruleKeys.keywords,
    queryFn: async ({ signal }) => (await getParsed(RuleKeywordList, "/rules/keywords", undefined, signal)).items,
    staleTime: 60_000,
  });
}

export function useRuleAtoms() {
  return useQuery({
    queryKey: ruleKeys.atoms,
    queryFn: ({ signal }) =>
      fetchAllCursorPages((cursor) => getParsed(AtomPage, "/rules/atoms", { limit: 200, cursor }, signal)),
  });
}

export function useRuleDefaults() {
  return useQuery({
    queryKey: ruleKeys.defaults,
    queryFn: ({ signal }) => getParsed(RuleDefaults, "/rules/defaults", undefined, signal),
  });
}

export function useRuleSuppressions() {
  return useQuery({
    queryKey: ruleKeys.suppressions,
    queryFn: ({ signal }) =>
      fetchAllCursorPages((cursor) => getParsed(SupPage, "/rules/suppressions", { limit: 200, cursor }, signal)),
  });
}

export type RuleRefs = {
  /** 规则组 id → 引用它的订阅(params.ruleGroupIds 或私有组) */
  subscriptions: Map<string, { id: string; title: string }[]>;
  /** 规则组 id → 引用它的收录版本 */
  slots: Map<string, { id: string; name: string }[]>;
};

const SubPage = cursorPage(Subscription);
const SlotPage = cursorPage(AcquisitionSlot);

/** 引用关系:列表接口不带引用计数,前端从订阅与收录版本反查(各取前 200 条) */
export function useRuleRefs() {
  return useQuery({
    queryKey: ruleKeys.refs,
    queryFn: async ({ signal }): Promise<RuleRefs> => {
      const [subs, slots] = await Promise.all([
        getParsed(SubPage, "/subscriptions", { limit: 200 }, signal),
        getParsed(SlotPage, "/acquisition-slots", { limit: 200 }, signal),
      ]);
      const subscriptions = new Map<string, { id: string; title: string }[]>();
      for (const s of subs.items) {
        const ids = Array.isArray(s.params?.ruleGroupIds) ? (s.params.ruleGroupIds as string[]) : [];
        const title =
          (s as { mediaEntityTitle?: string | null }).mediaEntityTitle ?? s.titleQuery ?? `订阅 ${s.id.slice(0, 8)}`;
        for (const id of ids) subscriptions.set(id, [...(subscriptions.get(id) ?? []), { id: s.id, title }]);
      }
      const slotRefs = new Map<string, { id: string; name: string }[]>();
      for (const sl of slots.items)
        for (const id of sl.ruleGroupIds ?? [])
          slotRefs.set(id, [...(slotRefs.get(id) ?? []), { id: sl.id, name: sl.name }]);
      return { subscriptions, slots: slotRefs };
    },
    staleTime: 30_000,
  });
}

/** 规则串 → 层(实时解析;错误带位置与相近名) */
export function parseRuleString(ruleString: string) {
  return api
    .post<unknown>("/rules/parse", { ruleString })
    .then((d) => parseOrThrow(RuleParseResult, d, "/rules/parse"));
}

export function usePreviewRuleGroup() {
  return useMutation({
    mutationFn: ({ id, ...body }: RulePreviewRequest & { id: string }) =>
      api.post<unknown>(`/rules/${id}/preview`, body).then((d) => parseOrThrow(RulePreviewResult, d, "/rules/preview")),
  });
}

function useInvalidate() {
  const qc = useQueryClient();
  return () => {
    void qc.invalidateQueries({ queryKey: ruleKeys.all });
    // 旧偏好标签页与订阅/收录版本的规则组显示同源
    void qc.invalidateQueries({ queryKey: ["preferences"] });
  };
}

const parseGroup = (d: unknown) => parseOrThrow(RuleGroup, d, "/rules");

export function useCreateRuleGroup() {
  const done = useInvalidate();
  return useMutation({
    mutationFn: (body: RuleGroupCreate) => api.post<unknown>("/rules", body).then(parseGroup),
    onSuccess: done,
  });
}

/** 编辑 / 停用(enabled=false 写抑制记录)/ 重新启用;带 expectedRevision 防覆盖 */
export function useUpdateRuleGroup() {
  const done = useInvalidate();
  return useMutation({
    mutationFn: ({ id, ...body }: RuleGroupUpdate & { id: string }) =>
      api.patch<unknown>(`/rules/${id}`, body).then(parseGroup),
    onSettled: done,
  });
}

/** 删除:标记删除并写抑制记录;被收录版本/订阅引用时 409 */
export function useDeleteRuleGroup() {
  const done = useInvalidate();
  return useMutation({
    mutationFn: (id: string) => api.del<unknown>(`/rules/${id}`),
    onSuccess: done,
  });
}

export function useSaveRuleDefaults() {
  const done = useInvalidate();
  return useMutation({
    mutationFn: (body: RuleDefaults) =>
      api.put<unknown>("/rules/defaults", body).then((d) => parseOrThrow(RuleDefaults, d, "/rules/defaults")),
    onSuccess: done,
  });
}

const parseAtom = (d: unknown) => parseOrThrow(RuleAtom, d, "/rules/atoms");

export function useCreateRuleAtom() {
  const done = useInvalidate();
  return useMutation({
    mutationFn: (body: RuleAtomCreate) => api.post<unknown>("/rules/atoms", body).then(parseAtom),
    onSuccess: done,
  });
}

export function useUpdateRuleAtom() {
  const done = useInvalidate();
  return useMutation({
    mutationFn: ({ id, ...body }: RuleAtomUpdate & { id: string }) =>
      api.patch<unknown>(`/rules/atoms/${id}`, body).then(parseAtom),
    onSuccess: done,
  });
}

export function useDeleteRuleAtom() {
  const done = useInvalidate();
  return useMutation({
    mutationFn: (id: string) => api.del<unknown>(`/rules/atoms/${id}`),
    onSuccess: done,
  });
}

/** 解除抑制:之后 Agent 可以再次提出同一规则(仍需审批) */
export function useLiftRuleSuppression() {
  const done = useInvalidate();
  return useMutation({
    mutationFn: (v: { id: string; reason?: string }) =>
      api
        .patch<unknown>(`/rules/suppressions/${v.id}`, { active: false, reason: v.reason })
        .then((d) => parseOrThrow(PreferenceSuppression, d, "/rules/suppressions")),
    onSuccess: done,
  });
}

export type { RuleLayer };