#include <iostream>
#include <boost/array.hpp>
#include <boost/asio.hpp>
#include <boost/filesystem.hpp>
#include <stdlib.h>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
#include <time.h>
using boost::asio::ip::tcp;


void SaveFileInDirectory(std::string filename, std::string directory, std::string *file_content)
		{
			try
			{
				//std::cout << "Current Dir: " << boost::filesystem::current_path().string() << std::endl;
				//boost::filesystem::create_directories( "TempFolder" );
				if(!(boost::filesystem::exists(directory)))
				{
					//std::cout<<"Doesn't Exists"<<std::endl;
					if (boost::filesystem::create_directory(directory))
					{
						std::cout << "Successfully Created !" << std::endl;
					}
				}
				std::string full_path = directory+filename;
#if defined(_MSC_VER)
	full_path += ".dll";
#elif defined(__GNUC__)
	full_path += ".so";
#endif
				
				boost::system::error_code ec;
				try
				{
					if(boost::filesystem::exists(full_path, ec))
						boost::filesystem::remove(full_path);
				}
				catch(boost::filesystem::filesystem_error& er)
				{
					//??
					//WriteToLogForDebug(er.what());
				}
				std::ofstream ofs(full_path.c_str(), std::ios::out | std::ios::binary); 
				
				if (ofs) 
				{ 
					ofs << *file_content; 
					//std::cout << full_path << " received" << std::endl; 
				} 
				else 
				{
					std::cerr << full_path << " couldn't be created" << std::endl;
				}

			}
			catch(const boost::filesystem::filesystem_error& err)
			{
				std::cerr << err.what() << std::endl;
			}
		}
class Connection
{
	boost::asio::ip::tcp::socket socket_;
	boost::asio::io_service &io_service_;
	std::string ip_;
	std::string port_;
public:
	Connection(boost::asio::io_service &io_service, std::string ip, std::string port);
	void Connect();
	void SendData(std::string);
	std::string ReceiveData();
	void Close();
	bool DownloadFile(std::string filename);
	bool isConnected();
};

void Connection::Connect()
{
	try
	{
		tcp::resolver resolver(io_service_);
		tcp::resolver::query query(ip_, port_);
		tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
		socket_.connect(*endpoint_iterator);
	}
	catch(boost::system::system_error &ec)
	{
		std::cout << ec.code() << " " << ec.what() << std::endl;
	}
    
}
bool Connection::isConnected()
{
	bool response = socket_.is_open();
	return response;
}

void Connection::Close()
{
	try
	{
		socket_.close();
	}
	catch(boost::system::system_error &ec)
	{
		std::cout << ec.code() << " " << ec.what() << std::endl;
	}
	
}

void Connection::SendData(std::string message)
{
	try
	{
		socket_.send(boost::asio::buffer(message));
	}
	catch(boost::system::system_error &ec)
	{
		std::cout << ec.code() << " " << ec.what() << std::endl;
	}
}

std::string Connection::ReceiveData()
{
	std::string message;
	try
	{
		boost::asio::streambuf buf;
		size_t len;
		boost::asio::streambuf::mutable_buffers_type mbuf = buf.prepare(512);
		do {
			len = socket_.receive(mbuf);
			std::cout << len << std::endl;
			std::string str(boost::asio::buffers_begin(mbuf), boost::asio::buffers_begin(mbuf) + len);
			message = message + str;
		} while (len>=512); 
	}
	catch(boost::system::system_error &ec)
	{
		std::cout << ec.code() << " " << ec.what() << std::endl;
	}
	return message;
}

Connection::Connection(boost::asio::io_service &io_service, std::string ip, std::string port):io_service_(io_service),socket_(io_service)
{
	//Constructor
	port_ = port;
	ip_ = ip;;
}

bool Connection::DownloadFile(std::string json)
{
	try
	{
		uintmax_t file_size;
		boost::array<char, 512*1024> buffer;
		std::string file;
		boost::system::error_code ec_write;
		size_t bytes_written = socket_.write_some(boost::asio::buffer(json),ec_write);
		if(bytes_written == 0)
			std::cout << "Error Occured\n";
		boost::system::error_code ec;
		uintmax_t total_bytes_of_file_transferred =0;
		std::string filename = "";
		while(ec==0) 
		{ 
			size_t bytes_transferred= socket_.read_some(boost::asio::buffer(buffer),ec);
			if(bytes_transferred <= 0)
				break;
			total_bytes_of_file_transferred = total_bytes_of_file_transferred + bytes_transferred;
			std::string data(buffer.data(), bytes_transferred);
			if (filename.empty())
			{ 
				boost::iterator_range<std::string::iterator> r1 = boost::find_nth(data, "\n", 0);
				filename = std::string(data.begin(),r1.begin());
				boost::iterator_range<std::string::iterator> r2 = boost::find_nth(data, "\n", 1);
				std::string file_sizestr = std::string(r1.begin()+1,r2.begin());
				file_size = boost::lexical_cast<uintmax_t>(file_sizestr);
				std::string remaining_data = std::string(r2.end(),data.end());
				file+=remaining_data;
				total_bytes_of_file_transferred = total_bytes_of_file_transferred-(filename.length()+file_sizestr.length()+1);
			}
			else
			{
				file += data;
			}
			if(total_bytes_of_file_transferred>=file_size){
				break;
			}
		} 
		if(ec==0 || ec== boost::asio::error::eof)
		{
			if(total_bytes_of_file_transferred>=file_size){
				SaveFileInDirectory(filename,"asdf\\",&file);
				return true;
			}else{
				return false;
			}
		}
		else
		{
			return false;
		}
		
	}
	catch (boost::system::system_error err)
	{

	}
}

int main(int argc, char* argv[])
{
  try
  {
	  srand( (unsigned)time( NULL ) );
	  boost::asio::io_service io_service;
	  Connection *connection = new Connection(io_service, "127.0.0.1", "1936");
	  connection->Connect();
	  int first_fetch = 1;
	  while(true)
	  {
		  //int random = rand() % 3 + 1;
		  int random = 1;
		  switch(random)
		  {
			  case 1:
				  {
					  std::string message;
					  if(first_fetch)
					  {
						 message = "{\"heartbeat\":\"true\", \"first_fetch\":\"true\"}\\q\\q";
						 first_fetch = 0;
					  }
					  else
					  {
						   message = "{\"heartbeat\":\"true\", \"first_fetch\":\"false\"}\\q\\q";
					  }
					  std::cout << connection->isConnected() << std::endl;
					  if(connection->isConnected())
					  {
						  connection->SendData(message);
						  std::string messageReceived = connection->ReceiveData();
						  std::cout <<  messageReceived << std::endl;
					  }
					  else
					  {
						  std::cout << "Seems like connection is closed\n";
					  }
					  
				  }

				  break;

			  case 2:
				  {
					  std::string message = "{\"message\":\"This is some Message to be sent to Server\"}";
					  connection->SendData(message);
					  std::string messageReceived = connection->ReceiveData();
					  std::cout <<  messageReceived << std::endl;
				  }

				  break;
			 case 3:
				  {
					  std::string message = "{\"app\":\"filesystem_collector\"}";
					  connection->DownloadFile(message);
					  
				  }

				  break;

			  default:
				  break;

		   }
		 /* connection->Close();
		  connection->Connect();*/
		  Sleep(3000);
	   }
	
  }
  catch(std::exception& e)
  {
    std::cerr << e.what() << std::endl;
  }
  std::getchar();
  return 0;
}