import { Request, Response } from "express";
import {
  
  handleSubmitCode,
  handleLoginWithSession,
  handleRequestCode,
  
  handleCreateTask,
  handleCancelTask,
  handleSendMessage,

  startBots,
  stopBots,
  restartBots,
  getBotsState,
} from "./services";
import { handleAddTelegrafBot } from "./bots";
import { getActiveClients as getClients, getActiveTasks as getTasks, sendResponse } from "./utils";
import { supabase } from './db/supabase';
import { loadCommandsAndMessages } from './config';
import { stopBot } from './bots/botManager';

import {  telegrafBots } from "./models";
export const submitCode = async (req: Request, res: Response) => {
  const { phoneNumber, code } = req.body;
  const result = await handleSubmitCode(phoneNumber, code);
  sendResponse(res, result.status, result.data);
};

export const loginWithSession = async (req: Request, res: Response) => {
  const { apiKey, hash, session, phoneNumber } = req.body;
  const result = await handleLoginWithSession(apiKey, hash, session, phoneNumber);
  sendResponse(res, result.status, result.data);
};

export const getActiveClients = (req: Request, res: Response) => {
  const result = getClients();
  sendResponse(res, 200, result);
};

export const requestCode = async (req: Request, res: Response) => {
  const { apiKey, hash, phoneNumber } = req.body;
  const result = await handleRequestCode(apiKey, hash, phoneNumber);
  sendResponse(res, result.status, result.data);
};

export const addTelegrafBot = async (req: Request, res: Response) => {
  const { botToken } = req.body;
  const result = await handleAddTelegrafBot(botToken);
  sendResponse(res, result.status, result.data);
};

export const createTask = async (req: Request, res: Response) => {
  const { phoneNumber, taskType, taskData } = req.body;
  const result = await handleCreateTask(phoneNumber,taskType, taskData);
  sendResponse(res, result.status, result.data);
};

export const cancelTask = async (req: Request, res: Response) => {
  const { taskId } = req.params;
  const result = await handleCancelTask(taskId);
  sendResponse(res, result.status, result.data);
};

export const getActiveTasks = (req: Request, res: Response) => {
  const result = getTasks();
  sendResponse(res, 200, result);
};

export const sendMessage = async (req: Request, res: Response) => {
  const { botToken, chatId, text } = req.body;
  const result = await handleSendMessage(botToken, chatId, text);
  sendResponse(res, result.status, result.data);
};

export const startBotsEndpoint = async (req: Request, res: Response) => {
  try {
    await startBots();
    sendResponse(res, 200, { message: "Bots started successfully" });
  } catch (error: any) {
    sendResponse(res, 500, { error: error.message });
  }
};

export const stopBotsEndpoint = async (req: Request, res: Response) => {
  try {
    await stopBots();
    sendResponse(res, 200, { message: "Bots stopped successfully" });
  } catch (error: any) {
    sendResponse(res, 500, { error: error.message });
  }
};

export const restartBotsEndpoint = async (req: Request, res: Response) => {
  try {
    await restartBots();
    sendResponse(res, 200, { message: "Bots restarted successfully" });
  } catch (error: any) {
    sendResponse(res, 500, { error: error.message });
  }
};

export const getBotsStateEndpoint = async (req: Request, res: Response) => {
  try {
    const state = await getBotsState();
    sendResponse(res, 200, state);
  } catch (error: any) {
    sendResponse(res, 500, { error: error.message });
  }
};

// Command Controllers
export const getCommands = async (req: Request, res: Response) => {
  try {
    const { data: commands, error } = await supabase
      .from('commands')
      .select('*')
      .order('created_at');
      
    if (error) throw error;
    
    res.status(200).json(commands);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

export const getCommand = async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { data: command, error } = await supabase
      .from('commands')
      .select('*')
      .eq('id', id)
      .single();
      
    if (error) throw error;
    
    res.status(200).json(command);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

export const createCommand = async (req: Request, res: Response) => {
  try {
    const { key, description } = req.body;
    
    if (!key) {
      return res.status(400).json({ error: 'Command key is required' });
    }
    
    const { data: command, error } = await supabase
      .from('commands')
      .insert([{ key, description }])
      .select()
      .single();
      
    if (error) throw error;
    
    // Reload commands and messages
    await loadCommandsAndMessages();
    
    res.status(201).json(command);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

export const updateCommand = async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { key, description } = req.body;
    
    if (!key) {
      return res.status(400).json({ error: 'Command key is required' });
    }
    
    const { data: command, error } = await supabase
      .from('commands')
      .update({ key, description, updated_at: new Date() })
      .eq('id', id)
      .select()
      .single();
      
    if (error) throw error;
    
    // Reload commands and messages
    await loadCommandsAndMessages();
    
    res.status(200).json(command);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

export const deleteCommand = async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    
    const { error } = await supabase
      .from('commands')
      .delete()
      .eq('id', id);
      
    if (error) throw error;
    
    // Reload commands and messages
    await loadCommandsAndMessages();
    
    res.status(204).send();
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

// Message Controllers
export const getMessages = async (req: Request, res: Response) => {
  try {
    const { command_id } = req.query;
    
    let query = supabase
      .from('messages')
      .select('*, commands(*)');
      
    if (command_id) {
      query = query.eq('command_id', command_id);
    }
    
    const { data: messages, error } = await query.order('created_at');
      
    if (error) throw error;
    
    res.status(200).json(messages);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

export const getMessage = async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { data: message, error } = await supabase
      .from('messages')
      .select('*, commands(*)')
      .eq('id', id)
      .single();
      
    if (error) throw error;
    
    res.status(200).json(message);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

export const createMessage = async (req: Request, res: Response): Promise<void> => {
  try {
    const { command_id, key, value, description } = req.body;
    
    if (!command_id || !key || !value) {
      res.status(400).json({ error: 'Command ID, key, and value are required' });
      return;
    }
    
    const { data: message, error } = await supabase
      .from('messages')
      .insert([{ command_id, key, value, description }])
      .select()
      .single();
      
    if (error) throw error;
    
    // Reload commands and messages
    await loadCommandsAndMessages();
    
    res.status(201).json(message);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

export const updateMessage = async (req: Request, res: Response): Promise<void> => {
  try {
    const { id } = req.params;
    const { command_id, key, value, description } = req.body;
    
    if (!command_id || !key || !value) {
      res.status(400).json({ error: 'Command ID, key, and value are required' });
      return;
    }
    
    const { data: message, error } = await supabase
      .from('messages')
      .update({ command_id, key, value, description, updated_at: new Date() })
      .eq('id', id)
      .select()
      .single();
      
    if (error) throw error;
    
    // Reload commands and messages
    await loadCommandsAndMessages();
    
    res.status(200).json(message);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

export const deleteMessage = async (req: Request, res: Response): Promise<void> => {
  try {
    const { id } = req.params;
    
    const { error } = await supabase
      .from('messages')
      .delete()
      .eq('id', id);
      
    if (error) throw error;
    
    // Reload commands and messages
    await loadCommandsAndMessages();
    
    res.status(204).send();
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

export const startTelegrafBotsEndpoint = async (req: Request, res: Response) => {
  try {
    // Fetch bot tokens from database
    const { data: bots, error } = await supabase
      .from('telegraf_bots')
      .select('*')
      .eq('is_active', true);

    if (error) {
      throw error;
    }

    const results = [];
    for (const bot of bots) {
      try {
        const result = await handleAddTelegrafBot(bot.token);
        results.push({
          botId: bot.id,
          status: result.status,
          message: result.data.message || result.data.error
        });
      } catch (error) {
        results.push({
          botId: bot.id,
          status: 500,
          message: error.message
        });
      }
    }

    sendResponse(res, 200, {
      message: "Telegraf bots startup completed",
      results
    });
  } catch (error: any) {
    sendResponse(res, 500, { error: error.message });
  }
};

export const startSpecificBotEndpoint = async (req: Request, res: Response) => {
  try {
    const { botId } = req.body;

    if (!botId) {
      
      return sendResponse(res, 400, { error: "Bot ID is required" });
    }

    // Start the bot using ID
    const result = await handleAddTelegrafBot(botId);
    sendResponse(res, result.status, result.data);
  } catch (error: any) {
    console.error('Error starting specific bot:', error);
    sendResponse(res, 500, { error: error.message });
  }
};

export const stopSpecificBotEndpoint = async (req: Request, res: Response) => {
  try {
    const { botId } = req.body;

    if (!botId) {
      return sendResponse(res, 400, { error: "Bot ID is required" });
    }

    const result = await stopBot(botId);
    
    if (result.success) {
      sendResponse(res, 200, { message: result.message });
    } else {
      sendResponse(res, 404, { error: result.message });
    }
  } catch (error: any) {
    console.error('Error stopping specific bot:', error);
    sendResponse(res, 500, { error: error.message });
  }
};