/***************************************************************************
                          tcpclient.cpp  -  description
                             -------------------
    begin                : Tue Nov 18 01:45:35 2003
    copyright            : (C) 1999-2008 by Cavalli Andrea
    author               : : cavalli $
    date                 : : 2003/12/09 11:10:33 $
    id                   : : coor.h,v 1.1.2.2 2003/12/09 11:10:33 cavalli Exp $
    email                : cavalli@bioc.unizh.ch amc82@cam.ac.uk
**************************************************************************/
/***************************************************************************
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 ***************************************************************************/

#include <almost.h>


#include <iostream>
#include <istream>
#include <ostream>
#include <string>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
namespace Almost {

  using boost::asio::ip::tcp;

  class client
  {
  public:
    client(boost::asio::io_service& io_service,
	   const std::string& server, const std::string & port, const std::string& path)
      : resolver_(io_service),
	socket_(io_service)
    {
      // Form the request. We specify the "Connection: close" header so that the
      // server will close the socket after transmitting the response. This will
      // allow us to treat all data up until the EOF as the content.
      std::ostream request_stream(&request_);
      request_stream << "GET " << path << " HTTP/1.0\r\n";
      request_stream << "Host: " << server << "\r\n";
      request_stream << "Accept: */*\r\n";
      request_stream << "Connection: close\r\n\r\n";

      // Start an asynchronous resolve to translate the server and service names
      // into a list of endpoints.
      //    tcp::resolver::query query(server, "http");
      tcp::resolver::query query(server, port);
      resolver_.async_resolve(query,
			      boost::bind(&client::handle_resolve, this,
					  boost::asio::placeholders::error,
					  boost::asio::placeholders::iterator));
    }

  private:
    void handle_resolve(const boost::system::error_code& err,
			tcp::resolver::iterator endpoint_iterator)
    {
      if (!err)
	{
	  // Attempt a connection to the first endpoint in the list. Each endpoint
	  // will be tried until we successfully establish a connection.
	  tcp::endpoint endpoint = *endpoint_iterator;
	  socket_.async_connect(endpoint,
				boost::bind(&client::handle_connect, this,
					    boost::asio::placeholders::error, ++endpoint_iterator));
	}
      else
	{
	  std::cout << "Error: " << err.message() << "\n";
	}
    }

    void handle_connect(const boost::system::error_code& err,
			tcp::resolver::iterator endpoint_iterator)
    {
      if (!err)
	{
	  // The connection was successful. Send the request.
	  boost::asio::async_write(socket_, request_,
				   boost::bind(&client::handle_write_request, this,
					       boost::asio::placeholders::error));
	}
      else if (endpoint_iterator != tcp::resolver::iterator())
	{
	  // The connection failed. Try the next endpoint in the list.
	  socket_.close();
	  tcp::endpoint endpoint = *endpoint_iterator;
	  socket_.async_connect(endpoint,
				boost::bind(&client::handle_connect, this,
					    boost::asio::placeholders::error, ++endpoint_iterator));
	}
      else
	{
	  std::cout << "Error: " << err.message() << "\n";
	}
    }

    void handle_write_request(const boost::system::error_code& err)
    {
      if (!err)
	{
	  // Read the response status line.
	  boost::asio::async_read_until(socket_, response_, "\r\n",
					boost::bind(&client::handle_read_status_line, this,
						    boost::asio::placeholders::error));
	}
      else
	{
	  std::cout << "Error: " << err.message() << "\n";
	}
    }

    void handle_read_status_line(const boost::system::error_code& err)
    {
      if (!err)
	{
	  // Check that response is OK.
	  std::istream response_stream(&response_);
	  std::string http_version;
	  response_stream >> http_version;
	  unsigned int status_code;
	  response_stream >> status_code;
	  std::string status_message;
	  std::getline(response_stream, status_message);
	  if (!response_stream || http_version.substr(0, 5) != "HTTP/")
	    {
	      std::cout << "Invalid response\n";
	      return;
	    }
	  if (status_code != 200)
	    {
	      std::cout << "Response returned with status code ";
	      std::cout << status_code << "\n";
	      return;
	    }

	  // Read the response headers, which are terminated by a blank line.
	  boost::asio::async_read_until(socket_, response_, "\r\n\r\n",
					boost::bind(&client::handle_read_headers, this,
						    boost::asio::placeholders::error));
	}
      else
	{
	  std::cout << "Error: " << err << "\n";
	}
    }

    void handle_read_headers(const boost::system::error_code& err)
    {
      if (!err)
	{
	  // Process the response headers.
	  std::istream response_stream(&response_);
	  std::string header;
	  while (std::getline(response_stream, header) && header != "\r")
	    std::cout << header << "\n";
	  std::cout << "\n";

	  // Write whatever content we already have to output.
	  if (response_.size() > 0)
	    std::cout << &response_;

	  // Start reading remaining data until EOF.
	  boost::asio::async_read(socket_, response_,
				  boost::asio::transfer_at_least(1),
				  boost::bind(&client::handle_read_content, this,
					      boost::asio::placeholders::error));
	}
      else
	{
	  std::cout << "Error: " << err << "\n";
	}
    }

    void handle_read_content(const boost::system::error_code& err)
    {
      if (!err)
	{
	  // Write all of the data that has been read so far.
	  std::cout << &response_;

	  // Continue reading remaining data until EOF.
	  boost::asio::async_read(socket_, response_,
				  boost::asio::transfer_at_least(1),
				  boost::bind(&client::handle_read_content, this,
					      boost::asio::placeholders::error));
	}
      else if (err != boost::asio::error::eof)
	{
	  std::cout << "Error: " << err << "\n";
	}
    }

    tcp::resolver resolver_;
    tcp::socket socket_;
    boost::asio::streambuf request_;
    boost::asio::streambuf response_;
  };


  int tcp_get(string server, string port, string path)
  {
    try
      {

	boost::asio::io_service io_service;
	client c(io_service, server, port, path);
	io_service.run();
      }
    catch (std::exception& e)
      {
	std::cout << "Exception: " << e.what() << "\n";
      }

    return 0;
  }


}
// Local Variables:
// mode:C++
// End: