import type { Context } from "hono";
import { logError } from "@/lib/logger";
import { error } from "@/lib/response";
import {
  createAgentHandler,
  deleteAgentHandler,
  getAgentByIdHandler,
  listAgentsHandler,
  testAgentHandler,
  updateAgentHandler,
  getGlobalAgentHandler,
  updateGlobalAgentHandler,
  uploadFilesHandler,
  makeAgentGlobalHandler,
  toggleAgentHandler,
} from "@/controllers/admin/chatbot/agents.controller";
import {
  createPromptHandler,
  deletePromptHandler,
  getPromptByIdHandler,
  listPromptsHandler,
  updatePromptHandler,
} from "@/controllers/admin/chatbot/prompts.controller";
import { getChatbotAdminHistoryHandler } from "@/controllers/admin/chatbot/history.controller";

export const ChatbotController = (ctx: Context) => {
  // History
  const GetChatbotHistory = async () => {
    try {
      return await getChatbotAdminHistoryHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to fetch history", 500, err);
    }
  };

  // Agents
  const CreateAgent = async () => {
    try {
      return await createAgentHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to create agent", 500, err);
    }
  };

  const ListAgents = async () => {
    try {
      return await listAgentsHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to list agents", 500, err);
    }
  };

  const GetAgentById = async () => {
    try {
      return await getAgentByIdHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to fetch agent", 500, err);
    }
  };

  const UpdateAgent = async () => {
    try {
      return await updateAgentHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to update agent", 500, err);
    }
  };

  const DeleteAgent = async () => {
    try {
      return await deleteAgentHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to delete agent", 500, err);
    }
  };

  const TestAgent = async () => {
    try {
      return await testAgentHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to test agent", 500, err);
    }
  };

  const GetGlobalAgent = async () => {
    try {
      return await getGlobalAgentHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to fetch global agent", 500, err);
    }
  };

  const UpdateGlobalAgent = async () => {
    try {
      return await updateGlobalAgentHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to update global agent", 500, err);
    }
  };

  const UploadFiles = async () => {
    try {
      return await uploadFilesHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to upload files", 500, err);
    }
  };

  const MakeAgentGlobal = async () => {
    try {
      return await makeAgentGlobalHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to make agent global", 500, err);
    }
  };

  const ToggleAgent = async () => {
    try {
      return await toggleAgentHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to toggle agent", 500, err);
    }
  };

  // Prompts
  const CreatePrompt = async () => {
    try {
      return await createPromptHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to create prompt", 500, err);
    }
  };

  const ListPrompts = async () => {
    try {
      return await listPromptsHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to list prompts", 500, err);
    }
  };

  const GetPromptById = async () => {
    try {
      return await getPromptByIdHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to fetch prompt", 500, err);
    }
  };

  const UpdatePrompt = async () => {
    try {
      return await updatePromptHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to update prompt", 500, err);
    }
  };

  const DeletePrompt = async () => {
    try {
      return await deletePromptHandler(ctx);
    } catch (err) {
      logError(err);
      return error(ctx, "Failed to delete prompt", 500, err);
    }
  };

  return {
    GetChatbotHistory,
    CreateAgent,
    ListAgents,
    GetAgentById,
    UpdateAgent,
    DeleteAgent,
    TestAgent,
    GetGlobalAgent,
    UpdateGlobalAgent,
    UploadFiles,
    MakeAgentGlobal,
    ToggleAgent,
    CreatePrompt,
    ListPrompts,
    GetPromptById,
    UpdatePrompt,
    DeletePrompt,
  };
};

export type TChatbotController = ReturnType<typeof ChatbotController>;