import path from 'path';
import Hyperswarm from 'hyperswarm';
import EventEmitter from 'node:events';
import b4a from "b4a";
import TextMessage from "./message/TextMessage.js";
import FileMessage from "./message/FileMessage.js";
import AudioMessage from "./message/AudioMessage.js";
import Message from "./message/Message.js";
import IconMessage from "./message/IconMessage.js";
import Corestore from 'corestore';
import Hyperdrive from 'hyperdrive';
import fs from 'fs';
import ServeDrive from 'serve-drive';

/**
 * This class is the core component of the bot system. It handles connections to the Hyperswarm network, manages message sending and receiving, and emits events for various actions.
 * @emits Client#onMessage
 * @emits Client#onFile
 * @emits Client#onAudio
 * @emits Client#onIcon
 */
class Client extends EventEmitter {
  /**
   * @param {String} botName The name of the bot.
   * @since 1.0
   * @constructor
   * @author snxraven
   */
  constructor(botName) {
    super();
    if (!botName) return console.error("Bot Name is not defined!");
    this.botName = botName;
    this.swarm = new Hyperswarm();
    this.joinedRooms = new Set(); // Track the rooms the bot has joined
    this.currentTopic = null; // Track the current topic

    // Initialize Corestore and Hyperdrive
    this.storagePath = './storage/';
    this.store = new Corestore(this.storagePath);
    this.drive = new Hyperdrive(this.store);

    // Initialize ServeDrive
    this.servePort = null;
    this.initializeServeDrive();

    this.setupSwarm();

    process.on('exit', () => {
      console.log('EXIT signal received. Shutting down HyperSwarm...');
      this.destroy();
    });

    process.on('SIGTERM', async () => {
      console.log('SIGTERM signal received. Shutting down HyperSwarm...');
      await this.destroy();
      console.log('HyperSwarm was shut down. Exiting the process with exit code 0.');
      process.exit(0);
    });

    process.on('SIGINT', async () => {
      console.log('SIGINT signal received. Shutting down HyperSwarm...');
      await this.destroy();
      console.log('HyperSwarm was shut down. Exiting the process with exit code 0.');
      process.exit(0);
    });
  }

  /**
   * @description Initializes the ServeDrive for serving files and audio.
   * @since 1.0
   * @author snxraven
   */
  async initializeServeDrive() {
    try {
      this.servePort = this.getRandomPort();
      const serve = new ServeDrive({
        port: this.servePort,
        get: ({ key, filename, version }) => this.drive
      });
      await serve.ready();
      console.log('ServeDrive listening on port:', this.servePort);
    } catch (error) {
      console.error('Error initializing ServeDrive:', error);
    }
  }
  /**
   * @description Returns a random port number.
   * @since 1.0
   * @author snxraven
   * @return {Number} Random port number.
   */
  getRandomPort() {
    return Math.floor(Math.random() * (65535 - 49152 + 1)) + 49152;
  }

  /**
   * @description Fetches and sets the bot's avatar from a local file.
   * @param {String} filePath path to the local avatar file.
   * @since 1.0
   * @author snxraven
   */
  async fetchAvatar(filePath) {
    try {
      await this.drive.ready();
      const iconBuffer = fs.readFileSync(filePath);
      await this.drive.put(`/icons/${this.botName}.png`, iconBuffer);
      this.botAvatar = `http://localhost:${this.servePort}/icons/${this.botName}.png`;

      // Cache the icon message
      this.iconMessage = IconMessage.new(this, iconBuffer);
    } catch (error) {
      console.error('Error fetching avatar:', error);
    }
  }

  /**
   * @description Sets up the Hyperswarm network and connection handlers.
   * @since 1.0
   * @author snxraven
   */
  setupSwarm() {
    this.swarm.on('connection', (peer) => {
      // Send the cached icon message to the new peer
      if (this.iconMessage) {
        peer.write(this.iconMessage.toJsonString());
      }

      peer.on('data', async message => {
        const messageObj = JSON.parse(message.toString());
        if (this.joinedRooms.has(messageObj.topic)) { // Process message only if it is from a joined room
          this.currentTopic = messageObj.topic; // Set the current topic from the incoming message

          const msgType = messageObj.type;
          const peerName = messageObj.name; // Changed from name to userName
          const peerAvatar = messageObj.avatar;
          const timestamp = messageObj.timestamp;


          if (msgType === "message")
            /**
             * Triggered when a new message is received.
             *
             * @event Client#onMessage
             * @property peer - HyperSwarm peer object
             * @property {TextMessage} textMessage -Class with all of the information about received text message
             * @example
             * const bot = new Client("MyBot");
             * bot.on('onMessage', (peer, message) => {
             *   console.log(`Message from ${message.peerName}: ${message.message}`);
             * });
            */
            this.emit('onMessage', peer, new TextMessage(peerName, peerAvatar, this.currentTopic, timestamp, messageObj.message));

          if (msgType === "file") {
            const fileBuffer = await this.drive.get(`/files/${messageObj.fileName}`);
            /**
             * Triggered when a file message is received.
             *
             * @event Client#onFile
             * @property peer - HyperSwarm peer object
             * @property {FileMessage} fileMessage - Class with all of the information about received file
             * @example
             * const bot = new Client("MyBot");
             * bot.on('onFile', (peer, message) => {
             *   console.log(`Received file from ${message.peerName}`);
             * });
             */
            this.emit('onFile', peer, new FileMessage(peerName, peerAvatar, this.currentTopic, timestamp, messageObj.fileName, `http://localhost:${this.servePort}/files/${messageObj.fileName}`, messageObj.fileType, messageObj.fileData));
          }

          if (msgType === "icon")
            /**
             * Triggered when an icon message is received.
             *
             * @event Client#onIcon
             * @property peer - HyperSwarm peer object
             * @property {IconMessage} iconMessage - Class with all of the information about received peer icon
             * @example
             * const bot = new Client("MyBot");
             * bot.on('onIcon', (peer, message) => {
             *   console.log(`Received new Icon from ${message.peerName}`);
             * });
             */
            this.emit('onIcon', peer, new IconMessage(peerName, peerAvatar, timestamp));

          if (msgType === "audio") {
            const audioBuffer = await this.drive.get(`/audio/${messageObj.audioName}`);
            /**
             * Triggered when an audio message is received.
             *
             * @event Client#onAudio
             * @property peer - HyperSwarm peer object
             * @property {AudioMessage} audioMessage - Class with all of the information about received audio file
             * @example
             * const bot = new Client("MyBot");
             * bot.on('onAudio', (peer, message) => {
             *   console.log(`Received audio file from ${message.peerName}`);
             * });
             */
            this.emit('onAudio', peer, new AudioMessage(peerName, peerAvatar, this.currentTopic, timestamp, `http://localhost:${this.servePort}/audio/${messageObj.audioName}`, messageObj.audioType, messageObj.audioData));
          }
        }
      });

      peer.on('error', e => {
        this.emit('onError', e);
        console.error(`Connection error: ${e}`);
      });
    });

    this.swarm.on('update', () => {
      console.log(`Connections count: ${this.swarm.connections.size} / Peers count: ${this.swarm.peers.size}`);
    });
  }
  /**
   * @description Joins a specified chat room.
   * @since 1.0
   * @author snxraven
   * @param {String} chatRoomID Chat room topic string
   */
  joinChatRoom(chatRoomID) {
    if (!chatRoomID || typeof chatRoomID !== 'string') {
      console.error("Invalid chat room ID!");
      return;
    }

    this.joinedRooms.add(chatRoomID); // Add the room to the list of joined rooms
    this.currentTopic = chatRoomID; // Store the current topic
    this.discovery = this.swarm.join(Buffer.from(chatRoomID, 'hex'), { client: true, server: true });
    this.discovery.flushed().then(() => {
      console.log(`Bot ${this.botName} joined the chat room.`);
      this.emit('onBotJoinRoom');
    });
  }

  /**
   * @description Sends a text message.
   * @since 1.0
   * @author MiTask
   * @param {String} message Text message to send to the bot's current chat room.
   */
  sendTextMessage(message) {
    console.log(`Preparing to send text message: ${message}`);
    this.sendMessage(TextMessage.new(this, message));
  }

  /**
   * @description Sends a file message.
   * @since 1.0
   * @author snxraven
   * @param {String} filePath Path to the file to send.
   * @param {String} fileType Type of the file to send.
   */
  async sendFileMessage(filePath, fileType) {
    try {
      await this.drive.ready();
      const fileBuffer = fs.readFileSync(filePath);
      const fileName = path.basename(filePath);
      await this.drive.put(`/files/${fileName}`, fileBuffer);
      const fileUrl = `http://localhost:${this.servePort}/files/${fileName}`;
      const fileMessage = FileMessage.new(this, fileName, fileUrl, fileType, fileBuffer); // Pass fileBuffer to the new method
      this.sendMessage(fileMessage);
    } catch (error) {
      console.error('Error sending file message:', error);
    }
  }

  /**
   * @description Sends an audio message.
   * @since 1.0
   * @author snxraven
   * @param {String} filePath Path to the audio file to send.
   * @param {String} audioType Type of the audio file to send.
   */
  async sendAudioMessage(filePath, audioType) {
    try {
      await this.drive.ready();
      const audioBuffer = fs.readFileSync(filePath);
      const audioName = path.basename(filePath);
      await this.drive.put(`/audio/${audioName}`, audioBuffer);
      const audioUrl = `http://localhost:${this.servePort}/audio/${audioName}`;
      const audioMessage = AudioMessage.new(this, audioUrl, audioType, audioBuffer); // Pass audioBuffer to the new method
      this.sendMessage(audioMessage);
    } catch (error) {
      console.error('Error sending audio message:', error);
    }
  }


  /**
   * @description Sends a generic message.
   * @since 1.0
   * @author MiTask
   * @param {Message} message Message class (TextMessage, FileMessage or AudioMessage)
   */
  sendMessage(message) {
    if (!(message instanceof Message)) {
      console.error(`message does not extend Message class (TextMessage, FileMessage, AudioMessage).`, message);
      return;
    }

    console.log("Sending message:", message);
    const data = message.toJsonString();
    const peers = [...this.swarm.connections];
    if (peers.length === 0) {
      console.warn("No active peer connections found.");
      return;
    }

    console.log(`Sending message to ${peers.length} peers.`);
    for (const peer of peers) {
      try {
        peer.write(data);
        console.log(`Message sent to peer: ${peer.remoteAddress}`);
      } catch (error) {
        console.error(`Failed to send message to peer: ${peer.remoteAddress}`, error);
      }
    }
  }

  /**
   * @description Disconnects the bot and shuts down the Hyperswarm network.
   * @since 1.0
   * @author snxraven
   */
  async destroy() {
    await this.swarm.destroy();
    console.log(`Bot ${this.botName} disconnected.`);
  }
}

export default Client;