#include <cstdint>
#include <cstring>
#include <iostream>

#include <utility>
#include <vector>

#include <spdlog/spdlog.h>

#include "audio.hxx"
#include "opus.h"

#include "opus_defines.h"
#include "rtp.hxx"
#include "server.hxx"

#define OPUS_FRAME_SIZE 3840

std::string getline();

Server::Server(std::pair<std::string, uint16_t> local_socket,
               std::pair<std::string, uint16_t> remote_socket, AudioDevice dev,
               asio::io_context &io)
    : local_address(local_socket.first), device(std::move(dev)),
      rtp(local_socket, remote_socket, io) {
  this->logger = spdlog::get("audpipe");

  int error = OPUS_OK;
  this->opusenc = opus_encoder_create(48000, 2, OPUS_APPLICATION_VOIP, &error);
  if (error != OPUS_OK) {
    auto error_msg = std::format("Failed to create opus encoder. Reason: {}",
                                 opus_strerror(error));
    this->logger->critical(error_msg);
    throw std::runtime_error(error_msg);
  }

  opus_encoder_ctl(this->opusenc, OPUS_SET_BITRATE(192000));
  opus_encoder_ctl(this->opusenc, OPUS_SET_COMPLEXITY(10));
  opus_encoder_ctl(this->opusenc, OPUS_SET_DTX(1));
  opus_encoder_ctl(
      this->opusenc,
      OPUS_SET_VBR(
          1)); // TODO: Encryption needs to be handled specially with VBR on.
  opus_encoder_ctl(this->opusenc, OPUS_SET_VBR_CONSTRAINT(0));
  opus_encoder_ctl(this->opusenc, OPUS_SET_INBAND_FEC(0));
  opus_encoder_ctl(this->opusenc, OPUS_SET_PACKET_LOSS_PERC(0));
  opus_encoder_ctl(this->opusenc,
                   OPUS_SET_MAX_BANDWIDTH(OPUS_BANDWIDTH_FULLBAND));
  opus_encoder_ctl(this->opusenc, OPUS_SET_SIGNAL(OPUS_SIGNAL_VOICE));

  this->opus_enc_outbuf = std::vector<uint8_t>();
  this->opus_enc_outbuf.resize(OPUS_FRAME_SIZE);
  this->opus_enc_outbuf_size = 0;
  this->pcm_stereo_buf.resize(960 * 2);

  auto &audio = AudioBackend::instance();

  audio.set_data_callback([&](const uint8_t *data, size_t len) {
    this->bytes_to_opus(data, len);

    uint8_t *opus_data = static_cast<uint8_t *>(this->opus_enc_outbuf.data());
    size_t opus_data_len = this->opus_enc_outbuf_size;

    if (opus_data_len == 0) {
      return;
    }

    // TODO: Make this check for errors/fail etc. For now just hand it off.
    this->rtp.write_frames(opus_data, opus_data_len);
  });
}

Server::~Server() {
  stop();

  if (this->opusenc != nullptr) {
    opus_encoder_destroy(this->opusenc);
    this->opusenc = nullptr;
  }
}

void Server::run() {
  this->running = true;

  try {
    AudioBackend::instance().record(this->device);
  } catch (...) {
    // We trust upstream code to log before throwing so just ignore the
    // exception.
    this->running = false;
    throw;
  }

  this->running = false;
}

void Server::stop() {
  this->running = false;
  this->rtp.stop();
  AudioBackend::instance().stop_recording();
}

AudioDevice Server::choose_device_interactive(std::vector<AudioDevice> inputs) {
  for (int i = 0; i < inputs.size(); i++) {
    std::cout << std::format("{})\t{}", i + 1, inputs.at(i).description)
              << std::endl;
  }

  std::cout << "Choose a device to record from (1): " << std::flush;
  int idx = 1;

  std::istringstream iss(getline());
  if (!(iss >> idx) || (iss >> std::ws, !iss.eof()) || idx <= 0 ||
      idx > inputs.size()) {
    auto logger = spdlog::get("audpipe");
    logger->debug("Invalid input, defaulting to 1.");

    idx = 1;
  }

  AudioDevice dev = inputs.at(idx - 1);

  return dev;
}

// Source - https://stackoverflow.com/a/546470
// Posted by Johannes Schaub - litb, modified by community. See post 'Timeline'
// for change history Retrieved 2026-03-13, License - CC BY-SA 3.0
std::string getline() {
  std::string str;
  std::getline(std::cin, str);
  return str;
}

// Populates opus_enc_outbuf.
void Server::bytes_to_opus(const uint8_t *data, size_t len) {
  // 960 samples/channel is 20 ms at 48 kHz.
  const size_t max_bytes = OPUS_FRAME_SIZE;
  this->opus_enc_outbuf_size = 0;

  if (data == nullptr || len < sizeof(opus_int16)) {
    return;
  }

  // Clear the outbuf.
  memset(this->opus_enc_outbuf.data(), 0, this->opus_enc_outbuf.size());

  const auto *in = reinterpret_cast<const opus_int16 *>(data);
  const size_t samples_total = len / sizeof(opus_int16);
  const opus_int16 *encode_in = nullptr;

  if (this->device.channels == 1) {
    if (samples_total < 960) {
      return;
    }

    // Upmix mono capture to stereo expected by encoder.
    for (size_t i = 0; i < 960; i++) {
      auto sample = in[i];
      this->pcm_stereo_buf[2 * i] = sample;
      this->pcm_stereo_buf[2 * i + 1] = sample;
    }
    encode_in = this->pcm_stereo_buf.data();
  } else {
    if (samples_total < 1920) {
      return;
    }
    encode_in = in;
  }

  auto res = opus_encode(this->opusenc, encode_in, 960,
                         this->opus_enc_outbuf.data(), max_bytes);

  // TODO: Recover from this.
  if (res < 0) {
    auto error_msg = std::format("Failed to encode opus frame. Reason: {}",
                                 opus_strerror(res));
    this->logger->critical(error_msg);
    throw std::runtime_error(error_msg);
  }

  // Else we have the size of the output frame. I would rather not reallocate
  // the block of memory, seems easier to just store pointer and length.
  this->opus_enc_outbuf_size = res;
  this->logger->debug("Got opus frame with size {}", res);
}