#include "socket.hpp"


namespace tinyfiber {
namespace tcp {

using namespace make_result;

Result<Socket> Socket::ConnectTo(const std::string& host, uint16_t port) {
  Socket socket;
  return socket.Connect(host, port);
}

Result<Socket> Socket::Connect(const std::string& host, uint16_t port) {
    auto addr = resolver_.resolve(host, std::to_string(port));
    std::cout << "size = " <<  addr.size() << std::endl;
    for (asio::ip::tcp::endpoint ep_iter : addr) {
        Fiber *fiber_ptr = GetCurrentFiber();
        socket_.async_connect(
                ep_iter,
                [this, fiber_ptr](const asio::error_code &error) {
                    this->error_code_ = error;
                    std::cout << "yeah" << std::endl;
                    GetCurrentScheduler()->MakeRunnable(fiber_ptr);
                });
        GetCurrentScheduler()->Wait();
        if (error_code_) {
            std::cout << "oops" << std::endl;
            continue;
        }
        std::cout << "break here" << std::endl;
        break;
    }

    if (error_code_)
        return make_result::Fail(error_code_);

    return make_result::Ok(std::move(*this));
}

Socket::Socket()
    : socket_(*(GetCurrentScheduler()->GetIoContext())),
    resolver_(*(GetCurrentScheduler()->GetIoContext())) {};

Result<Socket> Socket::ConnectToLocal(uint16_t port) {
    std::string local_host = "localhost";
    return ConnectTo(local_host, port);
}

Result<size_t> Socket::ReadSome(MutableBuffer buffer) {
    Fiber* fiber_ptr = GetCurrentFiber();
    socket_.async_read_some(
            asio::buffer(buffer, kBufCapacity),
            [this, fiber_ptr](const asio::error_code& error, std::size_t bytes_read) {
                this->error_code_ = error;
                this->bytes_transferred_ = bytes_read;
                GetCurrentScheduler()->MakeRunnable(fiber_ptr);
            });

    GetCurrentScheduler()->Wait();
    if (error_code_) {
        make_result::Fail(this->error_code_);
    }

  return Ok<std::size_t>(bytes_transferred_);
}

Result<size_t> Socket::Read(MutableBuffer buffer) {
    std::size_t size_buf = buffer.size();
    std::size_t read_bytes = 0;

    while (read_bytes != size_buf) {
        read_bytes += ReadSome(buffer);
    }


    if (error_code_) {
        return make_result::Fail(error_code_);
    }

    return make_result::Ok(read_bytes);
}

Status Socket::Write(ConstBuffer buffer) {
    Fiber* fiber_ptr = GetCurrentFiber();
    socket_.async_write_some(
            asio::buffer(buffer, kBufCapacity),
            [this, fiber_ptr](const asio::error_code& error, size_t bytes_transferred) {
                this->error_code_ = error;
                std::cout << "HEY" << std::endl;
                GetCurrentScheduler()->MakeRunnable(fiber_ptr);
            });
    GetCurrentScheduler()->Wait();

    return make_result::ToStatus(error_code_);
}

Status Socket::ShutdownWrite() {
  socket_.shutdown(asio::ip::tcp::socket::shutdown_send, error_code_);
  return make_result::ToStatus(error_code_);
}

Acceptor::Acceptor() : acceptor_(*(GetCurrentScheduler()->GetIoContext())) {};

Status Acceptor::Listen(uint16_t port) {
    asio::ip::tcp::endpoint end_point(asio::ip::tcp::v4(), port);

    acceptor_.open(end_point.protocol(), error_code_);
    acceptor_.bind(end_point, error_code_);
    acceptor_.listen();
    return make_result::ToStatus(error_code_);
}

Result<uint16_t> Acceptor::ListenAvailablePort() {
    Status st = Acceptor::Listen(0);
    if (!st) {
        return make_result::Fail(error_code_);
    }

    return make_result::Ok(GetPort());
}

Result<Socket> Acceptor::Accept() {
    Fiber* fiber_ptr = GetCurrentFiber();
    acceptor_.async_accept(
            [this, fiber_ptr](std::error_code error, asio::ip::tcp::socket) {
                this->error_code_ = error;
                std::cout << "y" << std::endl;
                GetCurrentScheduler()->MakeRunnable(fiber_ptr);
            });
    GetCurrentScheduler()->Wait();

    if (error_code_) {
        return make_result::Fail(error_code_);
    }
    return make_result::Ok(std::move(Socket::ConnectToLocal(GetPort())));
}

uint16_t Acceptor::GetPort() const {
    return acceptor_.local_endpoint().port();
}

}  // namespace tcp
}  // namespace tinyfiber