import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import { message } from 'antd';
import { silverUsersClient } from '@/client/api';
import type { InferResponseType, InferRequestType } from 'hono/client';

// 定义类型
type KnowledgeCategory = InferResponseType<typeof silverUsersClient['knowledge-categories']['$get'], 200>['data'][0];
type CreateCategoryRequest = InferRequestType<typeof silverUsersClient['knowledge-categories']['$post']>['json'];
type UpdateCategoryRequest = InferRequestType<typeof silverUsersClient['knowledge-categories'][':id']['$put']>['json'];

// 错误响应类型
interface ErrorResponse {
  code: number;
  message: string;
  errors?: Record<string, string[]>;
}

// Query keys
export const KNOWLEDGE_CATEGORIES_KEYS = {
  all: ['knowledge-categories'] as const,
  lists: () => [...KNOWLEDGE_CATEGORIES_KEYS.all, 'list'] as const,
  list: (params: Record<string, any>) => [...KNOWLEDGE_CATEGORIES_KEYS.lists(), params] as const,
  details: () => [...KNOWLEDGE_CATEGORIES_KEYS.all, 'detail'] as const,
  detail: (id: number) => [...KNOWLEDGE_CATEGORIES_KEYS.details(), id] as const,
  tree: () => [...KNOWLEDGE_CATEGORIES_KEYS.all, 'tree'] as const,
};

// 获取知识分类列表
export const useKnowledgeCategories = (params?: {
  page?: number;
  pageSize?: number;
  keyword?: string;
  isActive?: number;
}) => {
  return useQuery({
    queryKey: KNOWLEDGE_CATEGORIES_KEYS.list(params || {}),
    queryFn: async () => {
      const response = await silverUsersClient['knowledge-categories'].$get({
        query: {
          page: params?.page || 1,
          pageSize: params?.pageSize || 10,
          ...(params?.keyword && { keyword: params.keyword }),
          ...(params?.isActive !== undefined && { isActive: params.isActive }),
        },
      });
      
      if (!response.ok) {
        throw new Error('获取知识分类失败');
      }
      
      return response.json();
    },
    staleTime: 5 * 60 * 1000, // 5分钟
    gcTime: 10 * 60 * 1000, // 10分钟
  });
};

// 获取所有知识分类（用于树形选择）
export const useAllKnowledgeCategories = (showAll: boolean = false) => {
  return useQuery({
    queryKey: KNOWLEDGE_CATEGORIES_KEYS.list({ showAll }),
    queryFn: async () => {
      const response = await silverUsersClient['knowledge-categories'].$get({
        query: { 
          page: 1, 
          pageSize: 1000,
          ...(showAll ? {} : { isActive: 1 })
        }
      });
      
      if (!response.ok) {
        throw new Error('获取知识分类失败');
      }
      
      const result = await response.json();
      return result.data;
    },
    staleTime: 5 * 60 * 1000,
    gcTime: 10 * 60 * 1000,
  });
};

// 创建知识分类
export const useCreateKnowledgeCategory = () => {
  const queryClient = useQueryClient();
  
  return useMutation({
    mutationFn: async (data: CreateCategoryRequest) => {
      const response = await silverUsersClient['knowledge-categories'].$post({
        json: data,
      });
      
      if (!response.ok) {
        const error = await response.json();
        throw new Error(error.message || '创建知识分类失败');
      }
      
      return response.json();
    },
    onSuccess: () => {
      message.success('创建成功');
      // 刷新相关缓存
      queryClient.invalidateQueries({ queryKey: KNOWLEDGE_CATEGORIES_KEYS.lists() });
      queryClient.invalidateQueries({ queryKey: KNOWLEDGE_CATEGORIES_KEYS.tree() });
    },
    onError: (error) => {
      const errorMessage = error instanceof Error ? error.message : '创建失败';
      message.error(errorMessage);
    },
  });
};

// 更新知识分类
export const useUpdateKnowledgeCategory = () => {
  const queryClient = useQueryClient();
  
  return useMutation({
    mutationFn: async ({ id, data }: { id: number; data: UpdateCategoryRequest }) => {
      const response = await silverUsersClient['knowledge-categories'][':id']['$put']({
        param: { id: id.toString() },
        json: data,
      });
      
      if (!response.ok) {
        const error = await response.json();
        throw new Error(error.message || '更新知识分类失败');
      }
      
      return response.json();
    },
    onSuccess: () => {
      message.success('更新成功');
      // 刷新相关缓存
      queryClient.invalidateQueries({ queryKey: KNOWLEDGE_CATEGORIES_KEYS.lists() });
      queryClient.invalidateQueries({ queryKey: KNOWLEDGE_CATEGORIES_KEYS.tree() });
    },
    onError: (error) => {
      const errorMessage = error instanceof Error ? error.message : '更新失败';
      message.error(errorMessage);
    },
  });
};

// 删除知识分类
export const useDeleteKnowledgeCategory = () => {
  const queryClient = useQueryClient();
  
  return useMutation({
    mutationFn: async (id: number) => {
      const response = await silverUsersClient['knowledge-categories'][':id']['$delete']({
        param: { id: id.toString() },
      });
      
      if (!response.ok) {
        const error = await response.json();
        throw new Error(error.message || '删除知识分类失败');
      }
      
      return response.json();
    },
    onSuccess: () => {
      message.success('删除成功');
      // 刷新相关缓存
      queryClient.invalidateQueries({ queryKey: KNOWLEDGE_CATEGORIES_KEYS.lists() });
      queryClient.invalidateQueries({ queryKey: KNOWLEDGE_CATEGORIES_KEYS.tree() });
    },
    onError: (error) => {
      const errorMessage = error instanceof Error ? error.message : '删除失败';
      message.error(errorMessage);
    },
  });
};

// 切换知识分类状态
export const useToggleKnowledgeCategoryStatus = () => {
  const queryClient = useQueryClient();
  
  return useMutation({
    mutationFn: async ({ id, isActive }: { id: number; isActive: boolean }) => {
      const response = await silverUsersClient['knowledge-categories'][':id']['$put']({
        param: { id: id.toString() },
        json: { isActive: isActive ? 1 : 0 } as UpdateCategoryRequest,
      });
      
      if (!response.ok) {
        const error = await response.json();
        throw new Error(error.message || '更新状态失败');
      }
      
      return response.json();
    },
    onSuccess: () => {
      // 刷新相关缓存
      queryClient.invalidateQueries({ queryKey: KNOWLEDGE_CATEGORIES_KEYS.lists() });
      queryClient.invalidateQueries({ queryKey: KNOWLEDGE_CATEGORIES_KEYS.tree() });
    },
    onError: (error) => {
      const errorMessage = error instanceof Error ? error.message : '更新状态失败';
      message.error(errorMessage);
    },
  });
};

// 工具函数：构建分类树
export const buildCategoryTree = (items: KnowledgeCategory[], parentId: number | null = null): KnowledgeCategory[] => {
  return items
    .filter(item => item.parentId === parentId)
    .map(item => ({
      ...item,
      children: buildCategoryTree(items, item.id)
    }));
};

// 工具函数：获取分类路径
export const getCategoryPath = (categoryId: number, allCategories: KnowledgeCategory[]): string[] => {
  const path: string[] = [];
  const findPath = (id: number) => {
    const category = allCategories.find(cat => cat.id === id);
    if (category) {
      if (category.parentId) {
        findPath(category.parentId);
      }
      path.push(category.name);
    }
  };
  
  findPath(categoryId);
  return path;
};

// 工具函数：获取所有子分类ID
export const getAllChildrenIds = (categoryId: number, categories: KnowledgeCategory[]): number[] => {
  const ids: number[] = [categoryId];
  const findChildren = (parentId: number) => {
    categories.forEach(cat => {
      if (cat.parentId === parentId) {
        ids.push(cat.id);
        findChildren(cat.id);
      }
    });
  };
  
  findChildren(categoryId);
  return ids;
};