#include "io_service_pool.hpp"

#include <boost/thread/thread.hpp>
#include <algorithm>

namespace conn
{
    IoServicePool::IoServicePool(std::size_t size)
    {
        for (std::size_t i = 0; i < size; ++i)
        {
            std::shared_ptr<IoServiceInfo> info(new IoServiceInfo());

            info->m_connections = 0;
            info->m_io_service = std::make_shared<boost::asio::io_service>();
            std::shared_ptr<boost::asio::io_service::work> work(new boost::asio::io_service::work(*info->m_io_service));

            m_io_services.push_back(info);
            m_work.push_back(work);
        }

        m_worker_service = std::make_shared<boost::asio::io_service>();
        std::shared_ptr<boost::asio::io_service::work> work(new boost::asio::io_service::work(*m_worker_service));
        m_work.push_back(work);
    }

    void IoServicePool::Run()
    {
        for (std::size_t i = 0; i < m_io_services.size(); ++i)
        {
            std::shared_ptr<std::thread> thread(new std::thread(
                boost::bind(&boost::asio::io_service::run, m_io_services[i]->m_io_service)));

            m_io_services[i]->m_id = thread->get_id();
            m_threads.push_back(thread);
        }

        std::shared_ptr<std::thread> thread(new std::thread(
            boost::bind(&boost::asio::io_service::run, m_worker_service)));
        m_threads.push_back(thread);
    }

    void IoServicePool::Stop()
    {
        for (std::size_t i = 0; i < m_io_services.size(); ++i)
            m_io_services[i]->m_io_service->stop();

        m_worker_service->stop();

        for (std::size_t i = 0; i < m_threads.size(); i++)
            m_threads[i]->join();
    }

    void IoServicePool::ConnectionClosed(std::thread::id &id)
    {
        m_mutex.lock();

        for (dword i = 0; i < m_io_services.size(); i++)
        {
            if (m_io_services[i]->m_id == id)
                m_io_services[i]->m_connections -= 1;
        }

        m_mutex.unlock();
    }

    std::shared_ptr<IoServiceInfo> IoServicePool::get_io_service()
    {
        m_mutex.lock();

        dword pool = 0;
        dword lowest = m_io_services[0]->m_connections;

        for (dword i = 1; i < m_io_services.size(); i++)
        {
            if (m_io_services[i]->m_connections < lowest)
            {
                lowest = m_io_services[i]->m_connections;
                pool = i;
            }
        }

        m_io_services[pool]->m_connections += 1;

        m_mutex.unlock();

        return m_io_services[pool];
    }

    std::shared_ptr<boost::asio::io_service> IoServicePool::get_io_worker_service()
    {
        return m_worker_service;
    }
}