//
// basic_socket_streambuf.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2008 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#ifndef ASIO_BASIC_SOCKET_STREAMBUF_HPP
#define ASIO_BASIC_SOCKET_STREAMBUF_HPP

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)

#include "asio/detail/push_options.hpp"

#include "asio/detail/push_options.hpp"
#include <streambuf>
#include <boost/array.hpp>
#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/utility/base_from_member.hpp>
#include "asio/detail/pop_options.hpp"

#include "asio/basic_socket.hpp"
#include "asio/io_service.hpp"
#include "asio/stream_socket_service.hpp"
#include "asio/detail/throw_error.hpp"

#if !defined(ASIO_SOCKET_STREAMBUF_MAX_ARITY)
#define ASIO_SOCKET_STREAMBUF_MAX_ARITY 5
#endif // !defined(ASIO_SOCKET_STREAMBUF_MAX_ARITY)

// A macro that should expand to:
//   template <typename T1, ..., typename Tn>
//   basic_socket_streambuf<Protocol, StreamSocketService>* connect(
//       T1 x1, ..., Tn xn)
//   {
//     init_buffers();
//     asio::error_code ec;
//     this->basic_socket<Protocol, StreamSocketService>::close(ec);
//     typedef typename Protocol::resolver_query resolver_query;
//     resolver_query query(x1, ..., xn);
//     resolve_and_connect(query, ec);
//     return !ec ? this : 0;
//   }
// This macro should only persist within this file.

#define ASIO_PRIVATE_CONNECT_DEF( z, n, data ) \
  template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
  basic_socket_streambuf<Protocol, StreamSocketService>* connect( \
      BOOST_PP_ENUM_BINARY_PARAMS(n, T, x)) \
  { \
    init_buffers(); \
    asio::error_code ec; \
    this->basic_socket<Protocol, StreamSocketService>::close(ec); \
    typedef typename Protocol::resolver_query resolver_query; \
    resolver_query query(BOOST_PP_ENUM_PARAMS(n, x)); \
    resolve_and_connect(query, ec); \
    return !ec ? this : 0; \
  } \
  /**/

namespace asio {

/// Iostream streambuf for a socket.
template <typename Protocol,
    typename StreamSocketService = stream_socket_service<Protocol> >
class basic_socket_streambuf
  : public std::streambuf,
    private boost::base_from_member<io_service>,
    public basic_socket<Protocol, StreamSocketService>
{
public:
  /// The endpoint type.
  typedef typename Protocol::endpoint endpoint_type;

  /// Construct a basic_socket_streambuf without establishing a connection.
  basic_socket_streambuf()
    : basic_socket<Protocol, StreamSocketService>(
        boost::base_from_member<asio::io_service>::member),
      unbuffered_(false)
  {
    init_buffers();
  }

  /// Destructor flushes buffered data.
  virtual ~basic_socket_streambuf()
  {
    if (pptr() != pbase())
      overflow(traits_type::eof());
  }

  /// Establish a connection.
  /**
   * This function establishes a connection to the specified endpoint.
   *
   * @return \c this if a connection was successfully established, a null
   * pointer otherwise.
   */
  basic_socket_streambuf<Protocol, StreamSocketService>* connect(
      const endpoint_type& endpoint)
  {
    init_buffers();
    asio::error_code ec;
    this->basic_socket<Protocol, StreamSocketService>::close(ec);
    this->basic_socket<Protocol, StreamSocketService>::connect(endpoint, ec);
    return !ec ? this : 0;
  }

#if defined(GENERATING_DOCUMENTATION)
  /// Establish a connection.
  /**
   * This function automatically establishes a connection based on the supplied
   * resolver query parameters. The arguments are used to construct a resolver
   * query object.
   *
   * @return \c this if a connection was successfully established, a null
   * pointer otherwise.
   */
  template <typename T1, ..., typename TN>
  basic_socket_streambuf<Protocol, StreamSocketService>* connect(
      T1 t1, ..., TN tn);
#else
  BOOST_PP_REPEAT_FROM_TO(
      1, BOOST_PP_INC(ASIO_SOCKET_STREAMBUF_MAX_ARITY),
      ASIO_PRIVATE_CONNECT_DEF, _ )
#endif

  /// Close the connection.
  /**
   * @return \c this if a connection was successfully established, a null
   * pointer otherwise.
   */
  basic_socket_streambuf<Protocol, StreamSocketService>* close()
  {
    asio::error_code ec;
    sync();
    this->basic_socket<Protocol, StreamSocketService>::close(ec);
    if (!ec)
      init_buffers();
    return !ec ? this : 0;
  }

protected:
  int_type underflow()
  {
    if (gptr() == egptr())
    {
      asio::error_code ec;
      std::size_t bytes_transferred = this->service.receive(
          this->implementation,
          asio::buffer(asio::buffer(get_buffer_) + putback_max),
          0, ec);
      if (ec)
        return traits_type::eof();
      setg(get_buffer_.begin(), get_buffer_.begin() + putback_max,
          get_buffer_.begin() + putback_max + bytes_transferred);
      return traits_type::to_int_type(*gptr());
    }
    else
    {
      return traits_type::eof();
    }
  }

  int_type overflow(int_type c)
  {
    if (unbuffered_)
    {
      if (traits_type::eq_int_type(c, traits_type::eof()))
      {
        // Nothing to do.
        return traits_type::not_eof(c);
      }
      else
      {
        // Send the single character immediately.
        asio::error_code ec;
        char_type ch = traits_type::to_char_type(c);
        this->service.send(this->implementation,
            asio::buffer(&ch, sizeof(char_type)), 0, ec);
        if (ec)
          return traits_type::eof();
        return c;
      }
    }
    else
    {
      // Send all data in the output buffer.
      asio::const_buffer buffer =
        asio::buffer(pbase(), pptr() - pbase());
      while (asio::buffer_size(buffer) > 0)
      {
        asio::error_code ec;
        std::size_t bytes_transferred = this->service.send(
            this->implementation, asio::buffer(buffer),
            0, ec);
        if (ec)
          return traits_type::eof();
        buffer = buffer + bytes_transferred;
      }
      setp(put_buffer_.begin(), put_buffer_.end());

      // If the new character is eof then our work here is done.
      if (traits_type::eq_int_type(c, traits_type::eof()))
        return traits_type::not_eof(c);

      // Add the new character to the output buffer.
      *pptr() = traits_type::to_char_type(c);
      pbump(1);
      return c;
    }
  }

  int sync()
  {
    return overflow(traits_type::eof());
  }

  std::streambuf* setbuf(char_type* s, std::streamsize n)
  {
    if (pptr() == pbase() && s == 0 && n == 0)
    {
      unbuffered_ = true;
      setp(0, 0);
      return this;
    }

    return 0;
  }

private:
  void init_buffers()
  {
    setg(get_buffer_.begin(),
        get_buffer_.begin() + putback_max,
        get_buffer_.begin() + putback_max);
    if (unbuffered_)
      setp(0, 0);
    else
      setp(put_buffer_.begin(), put_buffer_.end());
  }

  template <typename ResolverQuery>
  void resolve_and_connect(const ResolverQuery& query,
      asio::error_code& ec)
  {
    typedef typename Protocol::resolver resolver_type;
    typedef typename Protocol::resolver_iterator iterator_type;
    resolver_type resolver(
        boost::base_from_member<asio::io_service>::member);
    iterator_type i = resolver.resolve(query, ec);
    if (!ec)
    {
      iterator_type end;
      ec = asio::error::host_not_found;
      while (ec && i != end)
      {
        this->basic_socket<Protocol, StreamSocketService>::close();
        this->basic_socket<Protocol, StreamSocketService>::connect(*i, ec);
        ++i;
      }
    }
  }

  enum { putback_max = 8 };
  enum { buffer_size = 512 };
  boost::array<char, buffer_size> get_buffer_;
  boost::array<char, buffer_size> put_buffer_;
  bool unbuffered_;
};

} // namespace asio

#undef ASIO_PRIVATE_CONNECT_DEF

#include "asio/detail/pop_options.hpp"

#endif // ASIO_BASIC_SOCKET_STREAMBUF_HPP