///////////////////////////////////////////////////////////
// CNetCopyServer 
class CNetCopyServer : public CWorkThread
{
private:
    asio::io_service io_service_;
    tcp::acceptor * pacceptor_;

    CCopyManager * m_pCopyMgmt;

    typedef shared_ptr<CNetClient> ClientPtr;
    typedef deque<ClientPtr> ClientList;
    ClientList clients_;

    void AcceptClients();
    void OnAccept(ClientPtr new_client,
        const boost::system::error_code& error);

protected:
    virtual void OnThreadProc();
    virtual void OnInitThread();

public:
    CNetCopyServer(CCopyManager * pCopyMgmt);
    virtual ~CNetCopyServer(void);

    bool StartServer();
    bool StopServer();

};

CNetCopyServer::CNetCopyServer(CCopyManager * pCopyMgmt) : 
    CWorkThread()
{
    m_pCopyMgmt = pCopyMgmt;
    InitThread();
}
CNetCopyServer::~CNetCopyServer(void)
{
    StopServer();

    ClientList::iterator it = clients_.begin();
    for (; it!=clients_.end(); ++it)
        (*it).reset();
    clients_.clear();
}
void CNetCopyServer::OnThreadProc()
{
    io_service_.run();
}
void CNetCopyServer::OnInitThread()
{
    pacceptor_ = new tcp::acceptor(io_service_, tcp::endpoint(tcp::v4(), 5010));
    AcceptClients();
}
void CNetCopyServer::AcceptClients()
{
    ClientPtr pclient = ClientPtr(new CNetClient(io_service_, m_pCopyMgmt));

    pacceptor_->async_accept(pclient->GetSocket(),
        boost::bind(&CNetCopyServer::OnAccept, this, pclient,
        boost::asio::placeholders::error));
}
void CNetCopyServer::OnAccept( ClientPtr new_client, const boost::system::error_code& error )
{
    if (error)
        return;

    clients_.push_back(new_client);
    new_client->OnConnect();
    AcceptClients();
}
bool CNetCopyServer::StartServer()
{
    return StartThread();
}
bool CNetCopyServer::StopServer()
{
    io_service_.stop();
    return StopThread();
}

/////////////////////////////////////////////////////////
// CNetClient 
class CNetClient : public boost::enable_shared_from_this<CNetClient>
{
private:
    asio::io_service & io_service_;
    tcp::socket socket_;

    CCopyManager * m_pCopyMgmt;

    BYTE recvdata_[1024];

    void OnRead(const boost::system::error_code& error,
        std::size_t bytes_transferred);
    void OnDisconnect();

public:
    CNetClient(asio::io_service & ios, CCopyManager * pCopyMgmt);
    virtual ~CNetClient(void);

    tcp::socket & GetSocket() { return socket_; }

    bool OnConnect();
    bool Read();
};

CNetClient::CNetClient(asio::io_service & ios, CCopyManager * pCopyMgmt) :
    io_service_(ios), socket_(ios)
{
    m_pCopyMgmt = pCopyMgmt;
}
CNetClient::~CNetClient(void)
{
}
bool CNetClient::OnConnect()
{
    return true;
}
void CNetClient::OnDisconnect()
{
}
bool CNetClient::Read()
{
    asio::async_read(socket_, boost::asio::buffer(recvdata_, 1024), 
        boost::bind(&CNetClient::OnRead, this,
        boost::asio::placeholders::error,
        boost::asio::placeholders::bytes_transferred));
    return true;
}
void CNetClient::OnRead( const boost::system::error_code& error, std::size_t bytes_transferred )
{
    if (error)
        OnDisconnect();
    else
    {
        // processing 
        //RecvData(recvdata_, bytes_transferred);
        //Translate();
        Read();
    }
}

//////////////////////////////////////////////////////////////////////
// CWorkThread
// Вспомогательный класс, используется как обертка над потоком
class CWorkThread  
{
private:
    bool m_bEnabled;

    HANDLE m_hThreadHandle; // поток
    HANDLE m_hStartEvent; // старт потока
    HANDLE m_hStarted; // когда поток запустился
    HANDLE m_hStopped; // когда поток остановился (пауза)

    bool m_bStarted;

protected:
    bool m_bServiceStop;

    void InitThread(); // создает поток и события управляющие им
    void TerminateThread(); // завершить поток

    bool StartThread();
    bool StopThread();

    static DWORD __stdcall ThreadProc(LPVOID lpParameter);

    virtual void OnThreadProc() = 0;
    virtual void OnInitThread() = 0;

public:
    CWorkThread();
    virtual ~CWorkThread();

};

DWORD CWorkThread::ThreadProc( LPVOID lpParameter )
{
    CWorkThread * Me = reinterpret_cast<CWorkThread *>(lpParameter);
    
    Me->OnInitThread();

    do
    {
        if (!Me->m_bStarted || Me->m_bServiceStop)
        {
            SetEvent(Me->m_hStopped);
            WaitForSingleObject(Me->m_hStartEvent, INFINITE);
            SetEvent(Me->m_hStarted);
        }
        else
        {
            Me->OnThreadProc();
        }
    }
    while (Me->m_bEnabled);
    
    return 0;    
}