#ifndef TRANSPORT_HH
#define TRANSPORT_HH

#include "unique_fd.hh"

#include <filesystem>
#include <functional>
#include <memory>
#include <optional>
#include <string_view>
#include <utility>
#include <vector>

class Buffer;
class Config;
class Logger;
class Looper;
class TaskRunner;

class Transport {
public:
  class Request {
  public:
    virtual ~Request() = default;

    virtual std::string_view method() const = 0;
    virtual std::string_view path() const = 0;
    virtual std::string_view query(std::string_view name) const = 0;
    virtual std::optional<std::string> header_one(
        std::string_view name) const = 0;
    virtual std::vector<std::string> header_all(
        std::string_view name) const = 0;
  };

  class Input {
  public:
    virtual ~Input() = default;

    enum class Return {
      OK,  // At least one byte was added to buffer.
      FULL,  // Zero bytes added to buffer as it is full.
      END, // Zero or more bytes added to buffer but there are no more bytes
           // available because input has ended.
      ERR, // No bytes added to buffer and there was an fatal error reading
           // any more bytes.
      WAIT,  // Zero or more bytes added to buffer but wait before calling
             // fill again (see wait_once).
    };

    virtual Return fill(Buffer* buffer, size_t buf_request_size = 1) = 0;

    // Setup callback to be called when Input is ready to be read again using
    // looper. Callback will only be called once. Callback might be called
    // before wait returns if Input is already ready. If Input is destroyed
    // before getting ready the callback will never be called.
    virtual void wait_once(std::shared_ptr<Looper> looper,
                           std::function<void()> callback) = 0;

  protected:
    Input() = default;
  };

  class Response {
  public:
    virtual ~Response() = default;

    virtual uint16_t code() const = 0;
    virtual std::vector<std::pair<std::string, std::string>> const&
        headers() const = 0;
    // Only call this once. If it returns null, call open_content_async instead.
    virtual std::unique_ptr<Input> open_content() = 0;
    // Only call this once and only if open_content() first returned nullptr.
    // If response is destroyed before callback is posted the callback will
    // never be posted. But if callback is already posted then it will run,
    // and the input will still be valid.
    virtual void open_content_async(
        std::shared_ptr<TaskRunner> runner,
        std::function<void(std::unique_ptr<Input>)> callback);

    virtual void add_header(std::string name, std::string value) = 0;

  protected:
    Response() = default;
  };

  std::unique_ptr<Response> create_ok_data(std::string data);
  std::unique_ptr<Response> create_ok_file(std::filesystem::path path);
  std::unique_ptr<Response> create_ok_exif_thumbnail(
      std::filesystem::path path);
  std::unique_ptr<Response> create_not_found();
  std::unique_ptr<Response> create_redirect(std::string target,
                                            bool temporary = true);
  virtual std::unique_ptr<Response> create_data(
      uint16_t code, std::string data) = 0;
  virtual std::unique_ptr<Response> create_file(
      uint16_t code, std::filesystem::path data) = 0;
  virtual std::unique_ptr<Response> create_exif_thumbnail(
      uint16_t code, std::filesystem::path data) = 0;

  class Handler {
  public:
    virtual ~Handler() = default;

    virtual std::unique_ptr<Response> request(Transport* transport,
                                              Request const* request) = 0;

  protected:
    Handler() = default;
  };

  // Takes care of GET/HEAD, optional cache headers and general housekeeping.
  // Also removes // and similar from paths.
  static std::unique_ptr<Handler> create_default_handler(
      std::shared_ptr<Logger> logger,
      Handler* handler);

  class Factory {
  public:
    virtual ~Factory() = default;

    virtual std::unique_ptr<Transport> create(
        std::shared_ptr<Logger> logger,
        std::shared_ptr<Looper> looper,
        std::shared_ptr<TaskRunner> runner,
        // config_logger is used to write any errors during create
        // when reading the config. No reference kept as with logger.
        Logger* config_logger,
        Config const* config,
        Handler* handler) = 0;

  protected:
    Factory() = default;
    Factory(Factory const&) = delete;
    Factory& operator=(Factory const&) = delete;
  };

  virtual ~Transport() = default;

  virtual void add_client(unique_fd&& fd) = 0;

protected:
  Transport() = default;
  Transport(Transport const&) = delete;
  Transport& operator=(Transport const&) = delete;
};

#endif  // TRANSPORT_HH