#include "../include/fileman.h"
#include "../include/base64.h"

FileMan::FileMan() { islisting = false; }

FileMan::~FileMan() {
  cancelGet();
  cancelPut();
  cancelList();
}

bool FileMan::isGetting() { return getfile.is_open(); }

bool FileMan::isPutting() { return putfile.is_open(); }

bool FileMan::isListing() { return islisting; }

bool FileMan::openPut(const std::string &path) {
  putpath = path;
  putname = pathToFilename(path);
  putfile.open(path, std::ios::ate | std::ios::binary);
  if (putfile.is_open()) {
    size_t size = putfile.tellg();
    putsize = size;
    putchunks = size / max_read_len + ((size % max_read_len) ? 1 : 0);
    putchunksRemaining = putchunks;
    putfile.seekg(std::ios::beg);
    return true;
  }
  return false;
}

bool FileMan::openGet(const std::string &path) {
  getpath = path;
  getname = pathToFilename(path);
  getchunks = 0;
  getchunksRemaining = 0;
  getfile.open(path, std::ios::app | std::ios::binary);
  if (getfile.tellp() != std::ios::beg) {
    closeGet();
    return false;
  }
  return true;
}

bool FileMan::openList() {
  if (isListing()) {
    return false;
  }
  listdata = std::vector<std::string>();
  islisting = true;
  return true;
}

void FileMan::closePut() { putfile.close(); }

void FileMan::closeGet() { getfile.close(); }

void FileMan::closeList() { islisting = false; }

void FileMan::cancelPut() {
  if (isPutting()) {
    closePut();
  }
}

void FileMan::cancelGet() {
  if (isGetting()) {
    closeGet();
    std::remove(getname.c_str());
  }
}

void FileMan::cancelList() {
  if (isListing()) {
    closeList();
  }
}

void FileMan::writeGet(const std::vector<char> data) {
  getfile.write(data.data(), data.size());
  getchunksRemaining--;
}

void FileMan::writeBase64(std::string data) {
  writeGet(base64::decodeVector(data));
}

void FileMan::putListData(std::vector<std::string> names) {
  listdata.insert(listdata.end(), names.begin(), names.end());
  listchunksRemaining--;
}

std::vector<std::string> FileMan::getListData() { return listdata; }

int FileMan::getGetChunks() { return getchunks; }

int FileMan::getGetRemainingChunks() { return getchunksRemaining; }

void FileMan::setGetChunks(int chunks) {
  getchunks = chunks;
  getchunksRemaining = chunks - 1;
}

void FileMan::setListChunks(int chunks) {
  listchunks = chunks;
  getchunksRemaining = chunks - 1;
}

std::vector<char> FileMan::readPut() {
  char buf[max_read_len];
  std::vector<char> data;

  std::streamoff read = this->putfile.tellg();
  if (read + max_read_len > this->putsize) {
    read = this->putsize % max_read_len;
  } else {
    read = max_read_len;
  }

  putfile.read(buf, read);
  data.assign(buf, buf + read);
  putchunksRemaining--;
  return data;
}

std::string FileMan::readBase64() { return base64::encodeVector(readPut()); }

std::string FileMan::getPutName() { return putname; }

std::string FileMan::getGetName() { return getname; }

int FileMan::getPutChunks() { return putchunks; }

int FileMan::getPutRemainingChunks() { return putchunksRemaining; }

int FileMan::getPutSize() { return putsize; }

int FileMan::getListRemainingChunks() { return listchunksRemaining; }

int FileMan::getListChunks() { return listchunks; }

std::string FileMan::pathToFilename(std::string path) {

  int lastFoundIndex = -1;

  for (int currentIndex = path.find("/"); currentIndex != std::string::npos;
       currentIndex = path.find("/", currentIndex + 1)) {

    // check if the "/" was escaped
    if (currentIndex > 0 && path[currentIndex - 1] == '\\')
      continue;

    /*  // check unnecessary, because error occurs when trying to open file
       anyways

        // check if the "/" is at the end of path name
        if (currentIndex + 1 == path.length()) {
          // ERROR: INVALID FILENAME, BECAUSE ENDS WITH "/"
        }
    */
    // otherwise we found a valid "/"
    lastFoundIndex = currentIndex;
  }

  return path.substr(lastFoundIndex + 1);
}