#include "Helpers.hpp"
#include "Main.hpp"

void HTTPrequest::processHTTPHeader() {
  //
  // Reading happens here
  //
  std::shared_ptr<HTTPrequest> self(shared_from_this());

  // Sadly due to the nature of how asio works this entire logic needs to be
  // mostly in 1 method I do wager that I could break off the whole body
  // processing into its own thing as well as a lot of inline methods
  // specifically for argument and header processing

  // TODO: Remove boundary from the body. Do keep other stuff like
  // file type and name

  // HEADER read
  asio::async_read_until(
      sock, buffer, "\r\n\r\n", // its not the other way bud
      [this, self](std::error_code error, std::size_t packageSize) {
        if (!error) {
          buffer.commit(packageSize);
          std::unordered_map<std::string, std::string> request;
          std::unordered_map<std::string, std::string> args;
          std::istream stream(&buffer);
          uint64_t octetCount = 0;

          // This is HTTP main request
          std::string rq, key, value, type, path;

          Helpers::getlineAndCount(stream, octetCount, type,
                                   ' '); // HTTP request type
          Helpers::getlineAndCount(stream, octetCount, path, ' '); // HTTP path
          Helpers::getlineAndCount(stream, octetCount,
                                   rq); // Version, omitting for now

          // Quick stop to process arguments
          if (path.find('?') != std::string::npos) {
            std::stringstream pathStream(path);
            std::getline(pathStream, path, '?'); // Keeping the path pure

            while (!pathStream.eof()) {
              std::getline(pathStream, key, '=');
              std::getline(pathStream, value, '&');
              args.insert({key, value});
            }
          }

          // Rest of the request vals
          while (octetCount <
                 packageSize - 2) { // -2 is due to last two \r\n\r\n combo
            Helpers::getlineAndCount(stream, octetCount, key, ':');
            Helpers::getlineAndCount(
                stream, octetCount, rq,
                ' '); // trim start some gangster shit right here
            Helpers::getlineAndCount(stream, octetCount, value);
            request.insert({key, value});
          }

          // ===================
          // BODY OF THE REQUEST
          // ===================
          if (request.find("Content-Length") != request.end()) {
            std::size_t uploadSize = std::stoull(request.at("Content-Length")) -
                                     buffer.size(),
                        octetCount = 0;

            // This part needs to be sync since we want this specific instance
            // execution to pause
            while (octetCount < uploadSize) {
              octetCount += asio::read(sock, buffer.prepare(uploadSize));
            }

            buffer.commit(octetCount);
            std::istream bodyStream(&buffer);
            std::string body;
            body.resize(buffer.size());
            bodyStream.read(body.data(), buffer.size());

            buffer.consume(
                buffer.size()); // Just so the buffer is nice and clean
          }

          processRequest(type, path, request, args); // This writes data too
          sock.close();
        }
      });
}