import Hyperswarm from 'hyperswarm'
import goodbye from 'graceful-goodbye'
import crypto from 'hypercore-crypto'
import b4a from 'b4a'
import readline from 'readline'
import unirest from "unirest";
let rand = Math.floor(Math.random() * 99999).toString();

function sleep(ms) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
}
// Generate a random public key
const publicKey = crypto.randomBytes(32)

// Create the swarm and pass in the public key
const swarm = new Hyperswarm()
// goodbye(() => {
//   const message = `CLOSED: ${publicKey.toString('hex')}`;
//   for (let conn of conns) {
//       conn.write(message);
//   }
// });
// Keep track of all connections and USERNAMEs
let conns = []
let USERPWD = "/"
let DAPI_KEY = {}
let USERNAME = "anon" + rand
let LOGGEDIN = false

async function clearCursor() {
  readline.moveCursor(process.stdout, 0, -2) // up one line
  readline.clearLine(process.stdout, 0) // from cursor to end
  readline.moveCursor(process.stdout, 0, 2) // up one line
}

// API Functions
async function getUSERNAME(key) {
  let requestUSERNAME = await unirest
    .get('https://api.discord-linux.com/hello')
    .headers({ 'Accept': 'application/json', 'Content-Type': 'application/json', 'x-discord-linux-auth': key })
  return requestUSERNAME.body.message.replace("Hello, ", "").replace("!", "")
}

async function runCMD(key, cmd, pwd) {
  let requestData = await unirest
    .post('https://api.discord-linux.com/exec')
    .headers({
      'Accept': 'application/json', 'Content-Type': 'application/json',
      'x-discord-linux-auth': key
    })
    .send({ "cmd": cmd, "pwd": pwd })
  return requestData.body.stdout
}

async function startContainer(key) {
  let startContainer = await unirest
    .get('https://api.discord-linux.com/start')
    .headers({
      'Accept': 'application/json', 'Content-Type': 'application/json',
      'x-discord-linux-auth': key
    })
  return startContainer.body
}

async function stopContainer(key) {
  let stopContainer = await unirest
    .get('https://api.discord-linux.com/stop')
    .headers({
      'Accept': 'application/json', 'Content-Type': 'application/json',
      'x-discord-linux-auth': key
    })
  return stopContainer.body
}

async function restartContainer(key) {
  let restartContainer = await unirest
    .get('https://api.discord-linux.com/restart')
    .headers({
      'Accept': 'application/json', 'Content-Type': 'application/json',
      'x-discord-linux-auth': key
    })
  return restartContainer.body
}

async function getStats(key) {
  let getStats = await unirest
    .get('https://api.discord-linux.com/stats')
    .headers({
      'Accept': 'application/json', 'Content-Type': 'application/json',
      'x-discord-linux-auth': key
    })
  return getStats.body
}

async function AIRequest(prompt) {
  let AIRequest = await unirest
    .post('https://codex-ai-v9q6.onrender.com/')
    .headers({ 'Accept': 'application/json', 'Content-Type': 'application/json' })
    .send({ "prompt": prompt })
  return AIRequest.body.bot
}

swarm.on('connection', conn => {

  process.on('SIGINT', async () => {
    console.log("Sending close message...")
    for (let conn of conns) {
      conn.write(`CLOSED: ${publicKey.toString('hex')}`)
    }

    await sleep(2000)
    process.exit()

  })

  const name = b4a.toString(conn.remotePublicKey, 'hex')
  console.log(`* got a connection from ${name} (${USERNAME}) *`)
  conns.push(conn)
  conn.once('close', () => conns.splice(conns.indexOf(conn), 1))
  conn.on('data', data => {
    if (data.toString().startsWith('CLOSED:')) {
      // Extract the key from the message string
      const key = data.toString().split(':')[1].trim();
      console.log(`Removing peer ${key}`);
      (async () => {

          await sleep(5000)
          conns = conns.filter(c => c !== conn);
          conn.destroy();
      })();

    } else {
      console.log(`${data}`)
    }
    // Use the USERNAME if it has been set, otherwise use the public key
  })
})

swarm.on('error', (err) => {
  console.log('Error connecting to peer:', err);
});

// Use readline to accept input from the user
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
})

// When the user inputs a line of text, broadcast it to all connections
rl.on('line', input => {

  const signIn = input.match(/^\/login (\S+)$/)
  if (signIn) {
    const APIKEY = signIn[1]
    DAPI_KEY = { "key": APIKEY }
    getUSERNAME(APIKEY).then((data) => {
      USERNAME = data
      // const name = b4a.toString(publicKey, 'hex')
      // names[name] = USERNAME
      for (const conn of conns) {
        conn.write(`${USERNAME} has logged in!`)
      }
      clearCursor()
      console.log(`Welcome ${USERNAME} you are now logged in!`)
      return LOGGEDIN = true
    });
  }

  const changeDir = input.startsWith(">cd") || input.startsWith("> cd")
  if (changeDir) {
    const commandArgs = input.replace("> cd ", "").replace(">cd", "").replace(" ", "")
    if (commandArgs.startsWith("/")) {
      USERPWD = commandArgs;
      console.log("Directory Changed to: " + USERPWD)
    } else {
      USERPWD = USERPWD + "/" + commandArgs;
      console.log("Directory Changed to: " + USERPWD)
    }

  }

  const execute = input.startsWith(">")
  if (input.startsWith("/") || input.startsWith("!")) return

  if (execute) {
    let inputdata = input.split(2)
    const cmdToRun = inputdata.join(" ").replace("> ", "").replace(">", "")
    if (cmdToRun.includes("cd")) return
    runCMD(DAPI_KEY.key, cmdToRun, USERPWD).then((data) => {
      console.log(data)
      for (const conn of conns) {
        conn.write(`${USERNAME} ran ${cmdToRun}: \n` + data)
      }
    })
  }

  const AI = input.startsWith("!")
  if (AI) {
    let inputdata = input.split(2)
    const prompt = inputdata.join(" ").replace("! ", "").replace("!", "")
    AIRequest(prompt).then((data) => {
      console.log(data)
      for (const conn of conns) {
        conn.write(`${USERNAME} ran ${cmdToRun}: \n` + data)
      }
    })
  }

  const start = input.startsWith("/start")
  if (start) {
    startContainer(DAPI_KEY.key).then((data) => {
      console.log(data)
      for (const conn of conns) {
        conn.write(`${USERNAME} ran start.`)
      }
    })
  }

  const stop = input.startsWith("/stop")
  if (stop) {
    stopContainer(DAPI_KEY.key).then((data) => {
      console.log(data)
      for (const conn of conns) {
        conn.write(`${USERNAME} ran stop.`)
      }
    })
  }

  const restart = input.startsWith("/restart")
  if (restart) {
    restartContainer(DAPI_KEY.key).then((data) => {
      console.log(data)
      for (const conn of conns) {
        conn.write(`${USERNAME} ran restart.`)
      }
    })
  }

  const stats = input.startsWith("/stats")
  if (stats) {
    getStats(DAPI_KEY.key).then((data) => {
      console.log(data)
      for (const conn of conns) {
        conn.write(`${USERNAME} ran stats.`)
      }
    })
  }
  else {
    //  if (!LOGGEDIN) return console.log("Please login using /login [API KEY]")
    if (input.startsWith("/") || input.startsWith("!")) return

    for (const conn of conns) {
      conn.write(`${USERNAME}: ${input}`)
    }
    console.log(`${USERNAME}: ${input}`)
    // Clear the input line\
    clearCursor()
  }
})

// Join a common topic
const topic = process.argv[2] ? b4a.from(process.argv[2], 'hex') : crypto.randomBytes(32)

setTimeout(() => {
  const discovery = swarm.join(topic, {
    lookup: true,
    announce: true,
    timeout: 300000

  });

  // The flushed promise will resolve when the topic has been fully announced to the DHT
  discovery.flushed().then(() => {
    console.log(`joined topic: ${b4a.toString(topic, 'hex')}\n(Share this key to others so they may join.)`)
    console.log('You are now in a chatroom for your topic, feel free to chat.\n')
    console.log('Want to login to the SSH.SURF API? Type "/login [APIKEY]" to login.\n\n')
  })
}, 1000);