#include "server.h"
#include <iostream>

Server::Server(asio::io_context& io_context, short port)
    : io_context_(io_context), acceptor_(io_context, asio::ip::tcp::endpoint(asio::ip::tcp::v4(), port))
{
}

void Server::start()
{
    asio::ip::tcp::endpoint endpoint(asio::ip::tcp::v4(), 8080);
    try {
        acceptor_.open(endpoint.protocol());
        acceptor_.set_option(asio::socket_base::reuse_address(true));
        acceptor_.bind(endpoint);
        acceptor_.listen();
        do_accept();
    } catch (const std::exception& e) {
        std::cerr << e.what() << '\n';
    }
}

void Server::stop()
{
}

void Server::set_worker(std::shared_ptr<COpenAI> worker, std::shared_ptr<CJsonOper> json)
{
    worker_ = worker;
    json_ = json;
}

void Server::do_accept()
{
    auto socket = std::make_shared<asio::ip::tcp::socket>(io_context_);
    acceptor_.async_accept(*socket, [this, socket](const std::error_code& ec) {
        if (!ec) {
            auto endpoint = socket->remote_endpoint();
            std::string client_key = endpoint.address().to_string() + ":" + std::to_string(endpoint.port());
            std::unique_lock<std::mutex> lock(cli_mutex_);
            client_map_[client_key] = std::make_shared<ClientCache>();
            clients_.insert(std::make_pair(socket->remote_endpoint().address().to_string(),
                                           std::thread([this, socket, client_key]() { th_client(socket, client_key); })));
        }

        do_accept();
    });
}

void Server::th_client(const std::shared_ptr<asio::ip::tcp::socket>& socket, const std::string& client_key)
{
    asio::error_code error;
    std::shared_ptr<ClientCache> cache = nullptr;

    {
        std::unique_lock<std::mutex> lock(cli_mutex_);
        cache = client_map_[client_key];
    }

    while (true) {
        auto len = socket->read_some(asio::buffer(cache->tmp_buf_), error);
        if (error == asio::error::eof) {
            break;   // Connection closed cleanly by peer.
        } else if (error) {
            break;   // Some other error.
        }

        cache->buffer_.push(cache->tmp_buf_.data(), len);

        while (true) {
            auto frame = com_parse(cache->buffer_);
            if (frame == nullptr) {
                break;
            }
            if (frame->type == FrameType::TYPE_REQUEST) {
                ask_mutex_.lock();
                //
                ask_mutex_.unlock();
            }
            delete frame;
        }
    }
}