import { useState, useCallback, useEffect } from 'react';
import agentService from '@/services/agent_service';
import type { IFlow } from '@/interfaces/database/agent';
import type { IAgentPaginationParams, IAgentCreateRequestBody, IAgentSettingRequestBody } from '@/interfaces/request/agent';
import logger from '@/utils/logger';
import { useTranslation } from 'react-i18next';
import { useSnackbar } from '@/hooks/useSnackbar';

export interface UseAgentListState {
  agents: IFlow[];
  total: number;
  loading: boolean;
  error: string | null;
  currentPage: number;
  pageSize: number;
  keywords: string;
  orderby?: string;
  desc?: boolean;
}

export interface UseAgentListReturn extends UseAgentListState {
  fetchAgents: (params?: IAgentPaginationParams) => Promise<void>;
  setKeywords: (keywords: string) => void;
  setCurrentPage: (page: number) => void;
  setPageSize: (size: number) => void;
  setOrder: (orderby?: string, desc?: boolean) => void;
  refresh: () => Promise<void>;
}

/**
 * 智能体列表钩子
 * @param initialParams 初始参数
 */
export const useAgentList = (initialParams?: IAgentPaginationParams) => {
  const [agents, setAgents] = useState<IFlow[]>([]);
  const [total, setTotal] = useState(0);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [currentPage, setCurrentPage] = useState(initialParams?.page || 1);
  const [pageSize, setPageSize] = useState(initialParams?.page_size || 10);
  const [keywords, setKeywords] = useState(initialParams?.keywords || '');

  const fetchAgentList = useCallback(async (params?: IAgentPaginationParams) => {
    setLoading(true);
    setError(null);
    try {
      const response = await agentService.listCanvas(params);
      const res = response.data || {};
      logger.info('useAgentList fetchAgentList', res);
      const data = res.data
      setAgents(data.canvas || []);
      setTotal(data.total || 0);
    } catch (err: any) {
      setError(err.message || 'Failed to fetch agent list');
    } finally {
      setLoading(false);
    }
  }, []);

  const refresh = useCallback(() => fetchAgentList({
    keywords,
    page: currentPage,
    page_size: pageSize,
  }), [keywords, currentPage, pageSize]);

  useEffect(() => {
    refresh();
  }, [refresh]);

  return {
    agents,
    total,
    loading,
    error,
    currentPage,
    pageSize,
    keywords,
    fetchAgents: fetchAgentList,
    setKeywords,
    setCurrentPage,
    setPageSize,
    refresh,
  };
};


export function useAgentOperations() {
  const { t } = useTranslation();
  const { showMessage } = useSnackbar();
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);

  const createAgent = useCallback(async (body: IAgentCreateRequestBody) => {
    try {
      setLoading(true);
      setError(null);
      const res = await agentService.setCanvas(body);
      const newId = res?.data?.data?.id || res?.data?.id;
      showMessage.success(t('agent.createAgentSuccess'));
      return { success: true, id: newId } as const;
    } catch (err: any) {
      const errorMessage = err?.response?.data?.message || err?.message || t('agent.createAgentFailed');
      setError(errorMessage);
      showMessage.error(errorMessage);
      return { success: false, error: errorMessage } as const;
    } finally {
      setLoading(false);
    }
  }, [t, showMessage]);

  const editAgent = useCallback(async (data: Partial<IAgentSettingRequestBody>) => {
    try {
      setLoading(true);
      setError(null);
      const res = await agentService.settingAgent(data);
      const code = res?.data?.code;
      if (code === 0) {
        showMessage.success(t('message.updated'));
        return { success: true } as const;
      }
      const msg = res?.data?.message || t('common.operationFailed');
      showMessage.error(msg);
      return { success: false, error: msg } as const;
    } catch (err: any) {
      const errorMessage = err?.response?.data?.message || err?.message || t('common.operationFailed');
      setError(errorMessage);
      showMessage.error(errorMessage);
      return { success: false, error: errorMessage } as const;
    } finally {
      setLoading(false);
    }
  }, [t, showMessage]);

  const deleteAgents = useCallback(async (ids: string[]) => {
    try {
      setLoading(true);
      setError(null);
      const res = await agentService.removeCanvas(ids);
      const code = res?.data?.code;
      if (code === 0) {
        showMessage.success(t('message.deleted'));
        return { success: true } as const;
      }
      const msg = res?.data?.message || t('common.operationFailed');
      showMessage.error(msg);
      return { success: false, error: msg } as const;
    } catch (err: any) {
      const errorMessage = err?.response?.data?.message || err?.message || t('common.operationFailed');
      setError(errorMessage);
      showMessage.error(errorMessage);
      return { success: false, error: errorMessage } as const;
    } finally {
      setLoading(false);
    }
  }, [t, showMessage]);

  const clearError = useCallback(() => setError(null), []);

  return { loading, error, createAgent, editAgent, deleteAgents, clearError };
}