#include "GCrypt/Util.h"
#include "GCrypt/GHash.h"
#include <vector>

namespace Leonetienne::GCrypt {

  std::string PadStringToLength(const std::string& str, const std::size_t len, const char pad, const bool padLeft) {
    // Fast-reject: Already above padded length
    if (str.length() >= len) {
      return str;
    }

    std::stringstream ss;

    // Pad left:
    if (padLeft) {
      for (std::size_t i = 0; i < len - str.size(); i++) {
        ss << pad;
      }
      ss << str;
    }
    // Pad right:
    else {
      ss << str;
      for (std::size_t i = 0; i < len - str.size(); i++) {
        ss << pad;
      }
    }

    return ss.str();
  }

  Block StringToBitblock(const std::string& s, bool padLeft) {
    std::stringstream ss;

    for (std::size_t i = 0; i < s.size(); i++) {
      ss << std::bitset<8>(s[i]);
    }

    // Pad rest with zeores
    return Block(PadStringToLength(ss.str(), Block::BLOCK_SIZE_BITS, '0', padLeft));
  }

  Flexblock StringToBits(const std::string& s) {
    std::stringstream ss;

    for (std::size_t i = 0; i < s.size(); i++) {
      ss << std::bitset<8>(s[i]);
    }

    return Flexblock(ss.str());
  }

  std::string BitblockToBytes(const Block& block) {
    std::stringstream ss;

    std::uint8_t* curByte = (std::uint8_t*)(void*)block.Data();
    for (std::size_t j = 0; j < Block::BLOCK_SIZE; j++) {
      ss << *curByte++;
    }

    return ss.str();
  }

  std::string BitblocksToBytes(const std::vector<Block>& blocks) {
    std::stringstream ss;

    for (const Block& block : blocks) {
      ss << BitblockToBytes(block);
    }

    return ss.str();
  }

  std::string BitblockToString(const Block& bits) {
    // Decode to bytes
    std::string text = BitblockToBytes(bits);

    // Dümp excess nullbytes
    text.resize(strlen(text.data()));

    return text;
  }

  std::string BitblocksToString(const std::vector<Block>& blocks) {
    // Decode to bytes
    std::string text = BitblocksToBytes(blocks);

    // Dümp excess nullbytes
    text.resize(strlen(text.data()));

    return text;
  }

  std::string BitsToBytes(const Flexblock& bits) {
    std::stringstream ss;

    const std::string bitstring = bits;

    for (std::size_t i = 0; i < bits.size(); i += 8) {
      ss << (char)std::bitset<8>(bitstring.substr(i, 8)).to_ulong();
    }

    return ss.str();
  }

  std::string BitsToString(const Flexblock& bits) {
    // Decode to bytes
    std::string text = BitsToBytes(bits);

    // Dümp excess nullbytes
    text.resize(strlen(text.data()));

    return text;
  }

  std::string BitblockToHexstring(const Block& b) {
    std::stringstream ss;
    const std::string charset = "0123456789abcdef";
    const std::string bstr = b.ToString();

    for (std::size_t i = 0; i < bstr.size(); i += 4) {
      ss << charset[std::bitset<4>(bstr.substr(i, 4)).to_ulong()];
    }

    return ss.str();
  }

  std::string BitsToHexstring(const Flexblock& b) {
    std::stringstream ss;
    const std::string charset = "0123456789abcdef";
    const std::string bstr = b;

    for (std::size_t i = 0; i < bstr.size(); i += 4) {
      ss << charset[std::bitset<4>(bstr.substr(i, 4)).to_ulong()];
    }

    return ss.str();
  }

  Block HexstringToBitblock(const std::string& hexstring) {
    std::stringstream ss;

    for (std::size_t i = 0; i < hexstring.size(); i++) {
      const char c = hexstring[i];

      // Get value
      std::size_t value;
      if ((c >= '0') && (c <= '9')) {
        // Is it a number?
        value = ((std::size_t)c - '0') + 0;
      }
      else if ((c >= 'a') && (c <= 'f')) {
        // Else, it is a lowercase letter
        value = ((std::size_t)c - 'a') + 10;
      }
      else {
        throw std::logic_error("non-hex string detected in HexstringToBits()");
      }

      // Append to our bits
      ss << std::bitset<4>(value).to_string();
    }

    return Block(ss.str());
  }

  Flexblock HexstringToBits(const std::string& hexstring) {
    std::stringstream ss;

    for (std::size_t i = 0; i < hexstring.size(); i++) {
      const char c = hexstring[i];

      // Get value
      std::size_t value;
      if ((c >= '0') && (c <= '9')) {
        // Is it a number?
        value = ((std::size_t)c - '0') + 0;
      }
      else if ((c >= 'a') && (c <= 'f')) {
        // Else, it is a lowercase letter
        value = ((std::size_t)c - 'a') + 10;
      }
      else {
        throw std::logic_error("non-hex string detected in HexstringToBits()");
      }

      // Append to our bits
      ss << std::bitset<4>(value).to_string();
    }

    return ss.str();
  }

  Flexblock ReadFileToBits(const std::string& filepath) {
    // Read file
    std::ifstream ifs(filepath, std::ios::binary);

    if (!ifs.good()) {
      throw std::runtime_error("Unable to open ifilestream!");
    }

    std::stringstream ss;
    std::copy(
        std::istreambuf_iterator<char>(ifs),
        std::istreambuf_iterator<char>(),
        std::ostreambuf_iterator<char>(ss)
        );

    ifs.close();

    const std::string bytes = ss.str();

    // Convert bytes to bits
    return StringToBits(bytes);
  }

  void WriteBitsToFile(const std::string& filepath, const Flexblock& bits) {
    // Convert bits to bytes
    const std::string bytes = BitsToBytes(bits);

    // Write bits to file
    std::ofstream ofs(filepath, std::ios::binary);

    if (!ofs.good()) {
      throw std::runtime_error("Unable to open ofilestream!");
    }

    ofs.write(bytes.data(), bytes.length());
    ofs.close();

    return;
  }

  std::vector<Block> ReadFileToBlocks(const std::string& filepath) {
    // Read file

    // "ate" specifies that the read-pointer is already at the end of the file
    // this allows to estimate the file size
    std::ifstream ifs(filepath, std::ios::binary | std::ios::ate);

    if (!ifs.good()) {
      throw std::runtime_error("Unable to open ifilestream!");
    }

    // Create our vector of blocks, and resorve a good guess
    // of memory
    std::vector<Block> blocks;
    blocks.reserve((ifs.tellg() / Block::BLOCK_SIZE) + 1);

    // Move read head to the file beginning
    ifs.seekg(std::ios_base::beg);

    // Whilst not reached eof, read into blocks
    while (!ifs.eof()) {
      // Create a new block, and zero it
      Block block;
      block.Reset();

      // Read data into the block
      ifs.read((char*)(void*)block.Data(), Block::BLOCK_SIZE);
      const std::size_t n_bytes_read = ifs.gcount();

      if (n_bytes_read > 0) {
        // Append the block to our vector
        blocks.emplace_back(block);
      }
    }

    // Close the filehandle
    ifs.close();

    return blocks;
  }

  void WriteBlocksToFile(
      const std::string& filepath,
      const std::vector<Block>& blocks
  ){

    // Create outfile file handle
    std::ofstream ofs(filepath, std::ios::binary);

    if (!ofs.good()) {
      throw std::runtime_error("Unable to open ofilestream!");
    }

    // Write all the blocks
    for (const Block& block : blocks) {
      ofs.write((char*)(void*)block.Data(), Block::BLOCK_SIZE);
    }

    // Close the filehandle
    ofs.close();

    return;
  }

  std::vector<Block> StringToBitblocks(const std::string& s) {

    // Create our block vector, and reserve exactly
    // how many blocks are required to store this string
    const std::size_t num_blocks = (s.length() / Block::BLOCK_SIZE) + 1;
    std::vector<Block> blocks;
    blocks.reserve(num_blocks);

    for (std::size_t i = 0; i < num_blocks; i++) {
      // Create new block, and zero it
      Block block;
      block.Reset();

      std::size_t bytes_copied = 0;

      // Iterate over all bytes in the block
      std::uint8_t* curByte = (std::uint8_t*)(void*)block.Data();
      for (std::size_t j = 0; j < Block::BLOCK_SIZE; j++) {
        curByte++;

        // Carry our character over

        const std::size_t strIdx = i*Block::BLOCK_SIZE + j;
        // The string still has chars to give
        if (strIdx < s.length()) {
          *curByte = s[j];
          bytes_copied++;
        }
        // We've reached the end of the string
        else {
          // Save our block, if it contains any bytes
          if (bytes_copied) {
            blocks.emplace_back(block);
          }

          // Return our blocks
          return blocks;
        }
      }
    }

    return blocks;
  }
}