class LibSSH2 {
public:
  static void Init() {
     static LibSSH2 instance;
  }
private:
  explicit LibSSH2() {
     if (libssh2_init(0) != 0) {
        throw std::runtime_error("libssh2 initialization failed");
     }
  }
  ~LibSSH2() {
     std::cout << "shutdown libssh2" << std::endl;
     libssh2_exit();
  }
};

class Socket {
public:
  explicit Socket() : m_sock(socket(AF_INET, SOCK_STREAM, 0)) {
     if (m_sock == -1) {
        throw std::runtime_error("failed to create socket");
     }
  }

  ~Socket() { close(m_sock); }
private:
  int m_sock = -1;
}

class Session {
public:
  explicit Session(const bool enable_compression) : m_session(libssh2_session_init()) {
     if (m_session == nullptr) {
        throw std::runtime_error("failed to create libssh2 session");
     }

     libssh2_session_set_blocking(m_session, 0);
     if (enable_compression) {
        libssh2_session_flag(m_session, LIBSSH2_FLAG_COMPRESS, 1);
     }
  }

  ~Session() {
     const std::string desc = "Shutting down libssh2 session";
     libssh2_session_disconnect(m_session, desc.c_str());
     libssh2_session_free(m_session);
  }

private:
  LIBSSH2_SESSION *m_session;
}

int WaitSocket() const {
  pollfd fds{};
  fds.fd = sock;
  fds.events = 0;

  if ((libssh2_session_block_directions(session) & LIBSSH2_SESSION_BLOCK_INBOUND) != 0) { 
     fds.events |= POLLIN;
  }
  if ((libssh2_session_block_directions(session) & LIBSSH2_SESSION_BLOCK_OUTBOUND) != 0) {
     fds.events |= POLLOUT;
  }

  return poll(&fds, 1, 10);
}

class SimpleChannel {
public:
  explicit SimpleChannel(session) {
     while ((m_channel = libssh2_channel_open_session(session) == nullptr &&
           GetSessionLastError() == LIBSSH2_ERROR_EAGAIN) {
        WaitSocket();
     }
     if (m_channel == nullptr) {
        throw std::runtime_error("Critical error while opening simple channel");
     }
  }

  void SendEof() {
     while (libssh2_channel_send_eof(m_channel) == LIBSSH2_ERROR_EAGAIN) {
        WaitSocket();
     }

     while (libssh2_channel_wait_eof(m_channel) == LIBSSH2_ERROR_EAGAIN) {
       WaitSocket();
     }
  }

  ~SimpleChannel() {
     CloseChannel();
  }
private:
  void CloseChannel() {
     int rc;
     while ((rc = libssh2_channel_close(m_channel)) == LIBSSH2_ERROR_EAGAIN) {
        WaitSocket();
     }
     libssh2_channel_free(m_channel);
  }

  LIBSSH2_CHANNEL *m_channel;
};

class BaseConnectionImpl {
protected:
  explicit BaseConnectionImpl(const SshConnectData &connect_data) ///< Это любая удобная структура, содержащая информацию о подключении
        : m_session(connect_data.enable_compression)
        , m_connect_data(connect_data) {

     LibSSH2::Init();
     ConnectSocket();
     HandShake();
     ProcessKnownHosts();
     Auth();
  }

  ///Следующие три метода понадобятся нам чуть позже
  bool CheckSocket(int type) const {
     pollfd fds{};
     fds.fd = m_sock;
     fds.events = type;

     return poll(&fds, 1, 0) == 1;
  }

  bool WantRead() const {
     return CheckSocket(POLLIN);
  }

  bool WantWrite() const {
     return CheckSocket(POLLOUT);
  }

  /*Я не был уверен, что реализация соединения, которая почти полностью взята из примера
 * будет кому-то интересна.
 */
  void ConnectSocket() {...}

  void HandShake() {...}

  void Auth() {...}

  class Socket m_sock;
  class Session m_session;
  class SimpleChannel;
  SshConnectData m_connect_data;
}; 

class Connection::Impl : public BaseConnectionImpl {
public:
  explicit Impl(const SshConnectData &connect_data)
        : BaseConnectionImpl(connect_data) {}

  template <typename Begin>
  void WriteToChannel(LIBSSH2_CHANNEL *channel, Begin ptr, size_t size) {
     do {
        int rc;
        while ((rc = libssh2_channel_write(channel, ptr, size)) == LIBSSH2_ERROR_EAGAIN) {
           WaitSocket();
        }
        if (rc < 0) {
           break;
        }
        size -= rc;
        ptr += rc;
     } while (size != 0);
  }

  void ExecuteCommand(const std::string &command, const std::string &in = "") {
     SimpleChannel channel(*this);

     int return_code = libssh2_channel_exec(channel, command.c_str());
     if (return_code != 0 && return_code != LIBSSH2_ERROR_EAGAIN) {
        throw std::runtime_error("Critical error while executing ssh command");
     }

     if (!in.empty()) {
        WriteToChannel(channel, in.c_str(), in.size());
        channel.SendEof();
     }

     std::string response;
     for (;;) {
        int rc;
        do {
           std::array<char, 4096> buffer{};
           rc = libssh2_channel_read(channel, buffer.data(), buffer.size());
           if (rc > 0) {
              boost::range::copy(boost::adaptors::slice(buffer, 0, rc), std::back_inserter(response));
           } else if (rc < 0 && rc != LIBSSH2_ERROR_EAGAIN) {
              throw std::runtime_error("libssh2_channel_read error (" + std::to_string(rc) + ")");
           }
        } while (rc > 0);

        if (rc == LIBSSH2_ERROR_EAGAIN) {
           WaitSocket();
        } else {
           break;
        }
     }
   }
};

class AsyncConnection::Impl : public BaseConnectionImpl,
 public std::enable_shared_from_this<AsyncConnection::Impl> {
public:
Impl(boost::asio::io_context &context, const SshConnectData &connect_data)
     : BaseConnectionImpl(connect_data)
     , m_tcp_socket(context, tcp::v4(), m_sock.GetSocket()) {
  m_tcp_socket.non_blocking(true);
}
};

void TryWrite() {
  if (m_input.empty() || m_write_in_progress) {
     return;
  }
  m_tcp_socket.async_wait(tcp::socket::wait_write, [this, self = shared_from_this()](auto ec) {
     if (WantWrite()) {
        WriteHandler(ec);
     } 
     if (m_complete) {
        return;
     }

     TryWrite();
  });
}

void WriteHandler(const boost::system::error_code &error) {
  if (error != boost::system::errc::success) {
     return;
  }

  m_write_in_progress = true;

  int ec = LIBSSH2_ERROR_EAGAIN;
  while (!m_input.empty()) {
     auto ptr = m_input.c_str();
     auto read_size = m_input.size();

     while ((ec = libssh2_channel_write(*m_channel, ptr, read_size)) > 0) {
        read_size -= ec;
        ptr += ec;
     }

     AssertResult(ec);
     m_input.erase(0, m_input.size() - read_size);
     if (ec == LIBSSH2_ERROR_EAGAIN) {
        break;
     }
  }
  if (m_input.empty() && m_write_callback != nullptr) {
     m_write_callback();
  }
  m_write_in_progress = false;
}