#ifndef __JLANG__JSTREAMAVAILABLE__
#define __JLANG__JSTREAMAVAILABLE__

#include <istream>
#include <ostream>
#include <type_traits>

#include "JLang/JBool.hh"


/**
 * \author mdejong
 */

/**
 * Test availability of stream operators.
 */
template<class T>
class JStreamAvailable {

  template<class U>   static auto is(U*)  -> decltype(std::declval<std::istream&>() >> std::declval<U&>());
  template<class U>   static auto os(U*)  -> decltype(std::declval<std::ostream&>() << std::declval<const U&>());
 
  template<typename>  static auto is(...) -> std::false_type;
  template<typename>  static auto os(...) -> std::false_type;
    
public:
  static const bool has_istream = std::is_same<std::istream&, decltype(is<T>(0))>::value;  //!< true if <tt>std::istream& operator>>(std::istream&, T&)</tt> is defined; else false
  static const bool has_ostream = std::is_same<std::ostream&, decltype(os<T>(0))>::value;  //!< true if <tt>std::ostream& operator<<(std::ostream&, const T&)</tt> is defined; else false
};


/**
 * Auxiliary data structure for handling std::ostream.
 */
struct STREAM {
protected:
  /**
   * Auxiliary class for format stream.
   */
  struct JStream
  {
    /**
     * Constructor.
     *
     * \param  out         output stream
     * \param  message     message printed in case operator std::ostream<< is unavailable
     */
    JStream(std::ostream& out, const std::string& message) :
      out    (out),
      message(message)
    {}


    /**
     * Write value to output stream.
     *
     * \param  value       value
     * \return             this JStream
     */
    template<class T>
    std::ostream& operator<<(const T& value)
    {
      using namespace JPP;

      return print(out, value, JBool<JStreamAvailable<T>::has_ostream>());
    }

  private:
    /**
     * Print value if given option is true.
     *
     * \param  out         output stream
     * \param  value       value
     * \param  option      true
     * \return             output stream
     */
    template<class T>
    std::ostream& print(std::ostream& out, const T& value, const JLANG::JBool<true>& option)
    {
      return out << value;
    }

    /**
     * Print value if given option is true.
     *
     * \param  out         output stream
     * \param  value       value
     * \param  option      false
     * \return             output stream
     */
    template<class T>
    std::ostream& print(std::ostream& out, const T& value, const JLANG::JBool<false>& option)
    {
      return out << message;
    }

    std::ostream& out; 
    std::string   message;
  };

  std::string message;

public:
  /**
   * Constructor.
   *
   * \param  message     message printed in case operator std::ostream<< is unavailable
   */
  STREAM(const std::string& message = "") :
    message(message)
  {}


  /**
   * Format specifier.
   *
   * \param  out           output stream
   * \param  format        format
   * \return               output stream
   */
  friend inline JStream operator<<(std::ostream& out, const STREAM& format)
  {
    return JStream(out, format.message);
  }
};

#endif