/*
	Copyright © 2015 Gluzskiy Alexandr (sss)

    This file is part of Unknown Download Manager (UDM).

    UDM is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 2 of the License, or
    (at your option) any later version.

    UDM is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with UDM.  If not, see <http://www.gnu.org/licenses/>.

*/


#include <boost/bind.hpp>
#include <boost/log/trivial.hpp>
#include "server_session.h"
#include "../../protocol/udm.pb.h"
#include "utilities.h"
#include "config.h"
#include "socket_wraper.h"

extern runtime_config_s runtime_config;




server_session::server_session(boost::asio::io_service &s, boost::asio::ssl::context *c) : io_service_(s), context_(c)
{
}

socket_wraper* server_session::socket()
{
    return socket_;
}


void server_session::run()
{
	if(runtime_config.config_file.get<bool>("server.enable_encryption", false))
	{
		socket_ = new socket_wraper(new boost::asio::ssl::stream<boost::asio::ip::tcp::socket>(io_service_, *context_));
		socket_->get_ssl_socket().async_handshake(boost::asio::ssl::stream_base::server, boost::bind(&server_session::handle_handshake, this, boost::asio::placeholders::error));
	}
	else
	{
		socket_ = new socket_wraper(new boost::asio::ip::tcp::socket(io_service_));
		recv_data_ = new char[4];
		boost::asio::async_read(*socket_, boost::asio::buffer(recv_data_, 4), boost::bind(&server_session::handle_read, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
	}
}

void server_session::handle_handshake(const boost::system::error_code& error)
{
	if (!error)
	{
		recv_data_ = new char[4];
		boost::asio::async_read(*socket_, boost::asio::buffer(recv_data_, 4), boost::bind(&server_session::handle_read, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
	}
	else
	{
		delete this;
	}
}


void server_session::handle_read(const boost::system::error_code& error, size_t bytes_transferred)
{
    if (!error)
    {
        std::string s;
//        bool parsed = false;
        unsigned size =  ntohl(*(int32_t*)recv_data_);
        delete [] recv_data_;
        char *buf = new char[size];
        boost::system::error_code ec;
        boost::asio::read(*socket_, boost::asio::buffer(buf, size), ec);
        if(ec)
		{

		}
        //TODO: check for error
        s.append(buf, size);
        delete [] buf;
        if(size != s.length())
        {
            delete this;
            return;
        }
        //TODO:
        client_msg msg;
        if(msg.ParseFromString(s))
        {
            //parsed = true;
            handle_command(&msg);
            recv_data_ = new char[4];
            boost::asio::async_read(*socket_, boost::asio::buffer(recv_data_, 4), boost::bind(&server_session::handle_read, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
        }
//        if(!parsed)
		else
        {
        	BOOST_LOG_TRIVIAL(error)<<"failed to parse client message";
            delete this; //close connection
            return;
        }
    }
    else
    {
        delete this;
    }
}

void server_session::handle_command(client_msg *msg)
{
	switch(msg->type())
	{
	default:
		break;
	}
}

void server_session::send_message(server_msg *msg)
{
	int size = 0;
	std::shared_ptr<char*> ptr = pack_msg(msg, &size);
	boost::asio::async_write(*socket_, boost::asio::buffer(*ptr, size), boost::bind(&server_session::handle_write, this, boost::asio::placeholders::error));
}

void server_session::handle_write(const boost::system::error_code& error)
{
    if(!error)
    {
        //TODO:
    }
    else
    {
    	//TODO: handle error
    }
//    recv_data_ = new char[4];
//    boost::asio::async_read(socket_, boost::asio::buffer(recv_data_, 4), boost::bind(&server_session::handle_read, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}


server_session::~server_session()
{
	//dtor
}