#ifndef MINIJSON_WRITER_H
#define MINIJSON_WRITER_H

#include <cstddef>
#include <iomanip>
#include <iterator>
#include <locale>
#include <ostream>
#include <string>
#include <utility>

#define MJW_CPP11_SUPPORTED __cplusplus > 199711L || _MSC_VER >= 1800

#if MJW_CPP11_SUPPORTED

#include <cmath>
#include <type_traits>
#define MJW_LIB_NS std
#define MJW_ISFINITE(X) std::isfinite(X)
#define MJW_STATIC_ASSERT(COND, MESSAGE) static_assert(COND, MESSAGE)

#else

#include <boost/type_traits/remove_cv.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_floating_point.hpp>
#include <boost/math/special_functions/fpclassify.hpp>
#define MJW_LIB_NS boost
#define MJW_ISFINITE(X) boost::math::isfinite(X)
#define MJW_STATIC_ASSERT(COND, MESSAGE) BOOST_STATIC_ASSERT(COND)

#endif

namespace minijson
{

enum null_t
{
    null = 0
};

class writer_configuration
{
private:

    size_t m_nesting_level;
    bool m_pretty_printing;
    size_t m_indent_spaces;
    bool m_use_tabs;
    bool m_horizontal_array;
    bool m_close_on_destroy;

public:

    explicit writer_configuration() :
        m_nesting_level(0),
        m_pretty_printing(false),
        m_indent_spaces(4),
        m_use_tabs(false),
        m_horizontal_array(false),
        m_close_on_destroy(true)
    {
    }

    size_t nesting_level() const
    {
        return m_nesting_level;
    }

    writer_configuration increase_nesting_level() const
    {
        writer_configuration result = *this;
        result.m_nesting_level++;

        return result;
    }

    bool pretty_printing() const
    {
        return m_pretty_printing;
    }

    writer_configuration pretty_printing(bool value) const
    {
        writer_configuration result = *this;
        result.m_pretty_printing = value;

        return result;
    }

    size_t indent_spaces() const
    {
        return m_indent_spaces;
    }

    writer_configuration indent_spaces(size_t value) const
    {
        writer_configuration result = *this;
        result.m_indent_spaces = value;

        return result;
    }

    bool use_tabs() const
    {
        return m_use_tabs;
    }

    writer_configuration use_tabs(bool value) const
    {
        writer_configuration result = *this;
        result.m_use_tabs = value;

        return result;
    }

    bool horizontal_array() const
    {
        return m_horizontal_array;
    }

    writer_configuration horizontal_array(bool value) const
    {
        writer_configuration result = *this;
        result.m_horizontal_array = value;

        return result;
    }

    writer_configuration& horizontal_array_inplace(bool value)
    {
        m_horizontal_array = value;
        return *this;
    }

    bool close_on_destroy() const
    {
        return m_close_on_destroy;
    }

    writer_configuration& close_on_destroy_inplace(bool value)
    {
        m_close_on_destroy = value;
        return *this;
    }
};

template<typename V, typename Enable = void>
struct default_value_writer;

template<typename InputIt>
void write_array(
        std::ostream& stream,
        InputIt begin, InputIt end,
        const writer_configuration& configuration = writer_configuration());

template<typename InputIt, typename ValueWriter>
void write_array(
        std::ostream& stream,
        InputIt begin, InputIt end,
        const ValueWriter& value_writer,
        const writer_configuration& configuration = writer_configuration());

namespace detail
{

template<bool>
struct enable_if;

template<>
struct enable_if<true>
{
    typedef void type;
};

template<typename InputIt>
struct get_value_type
{
    typedef typename MJW_LIB_NS::remove_cv<typename std::iterator_traits<InputIt>::value_type>::type type;
};

#if MJW_CPP11_SUPPORTED

template<size_t Rank>
struct overload_rank : overload_rank<Rank - 1>
{
};

template<>
struct overload_rank<0>
{
};

typedef overload_rank<63> call_ranked;

template<typename Functor>
struct two_or_three_args_functor
{
private:

    Functor functor;

    template<typename Arg1, typename Arg2, typename Arg3>
    auto operator_impl(Arg1&& arg1, Arg2&& arg2, Arg3&& arg3, overload_rank<1>)
        -> decltype(functor(std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3)))
    {
        functor(std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3));
    }

    template<typename Arg1, typename Arg2, typename Arg3>
    auto operator_impl(Arg1&& arg1, Arg2&& arg2, Arg3&&, overload_rank<0>)
        -> decltype(functor(std::forward<Arg1>(arg1), std::forward<Arg2>(arg2)))
    {
        functor(std::forward<Arg1>(arg1), std::forward<Arg2>(arg2));
    }

public:

    explicit two_or_three_args_functor(Functor functor) :
        functor(std::move(functor))
    {
    }

    template<typename Arg1, typename Arg2, typename Arg3>
    void operator()(Arg1&& arg1, Arg2&& arg2, Arg3&& arg3)
    {
        operator_impl(std::forward<Arg1>(arg1), std::forward<Arg2>(arg2), std::forward<Arg3>(arg3), call_ranked());
    }
};

#else

template<typename Functor>
struct two_or_three_args_functor : Functor
{
    mutable Functor functor;

    explicit two_or_three_args_functor(const Functor& functor) :
        Functor(functor),
        functor(functor)
    {
    }

    using Functor::operator();

    template<typename Arg1, typename Arg2, typename Arg3>
    void operator()(Arg1& arg1, Arg2& arg2, Arg3&) const
    {
        functor(arg1, arg2);
    }
};

template<typename R, typename X1, typename X2>
struct two_or_three_args_functor<R (*)(X1, X2)>
{
    typedef R (*Function)(X1, X2);

    Function function;

    explicit two_or_three_args_functor(Function function) :
        function(function)
    {
    }

    template<typename Arg1, typename Arg2, typename Arg3>
    void operator()(Arg1& arg1, Arg2& arg2, Arg3&) const
    {
        function(arg1, arg2);
    }
};

template<typename R, typename X1, typename X2, typename X3>
struct two_or_three_args_functor<R (*)(X1, X2, X3)>
{
    typedef R (*Function)(X1, X2, X3);

    Function function;

    explicit two_or_three_args_functor(Function function) :
        function(function)
    {
    }

    template<typename Arg1, typename Arg2, typename Arg3>
    void operator()(Arg1& arg1, Arg2& arg2, Arg3& arg3) const
    {
        function(arg1, arg2, arg3);
    }
};

#endif

template<typename Functor>
two_or_three_args_functor<Functor> wrap_two_or_three_args_functor(Functor functor)
{
    return two_or_three_args_functor<Functor>(functor);
}

template<size_t Size = 128>
class buffered_writer
{
    MJW_STATIC_ASSERT(Size != 0, "Illegal instantiation of buffered_writer");

private:

    std::ostream& m_stream;
    char m_buffer[Size];
    size_t m_offset;

    buffered_writer(const buffered_writer &);
    buffered_writer &operator=(const buffered_writer &);

public:

    explicit buffered_writer(std::ostream& stream) :
        m_stream(stream),
        m_offset(0)
    {
    }

    buffered_writer& operator<<(char c)
    {
        if (m_offset == Size)
        {
            flush();
        }

        m_buffer[m_offset++] = c;

        return *this;
    }

    template<size_t N>
    buffered_writer& operator<<(const char (&str)[N])
    {
        MJW_STATIC_ASSERT(N != 0, "Illegal instantiation of buffered_writer::operator<<(const char (&str)[N])");

        for (size_t i = 0; i < N - 1; i++)
        {
            operator<<(str[i]);
        }

        return *this;
    }

    void flush()
    {
        m_stream.write(m_buffer, m_offset);

        m_offset = 0;
    }
};

namespace
{

void adjust_stream_settings(std::ostream& stream)
{
    stream.imbue(std::locale::classic());
    stream << std::resetiosflags(std::ios::showpoint | std::ios::showpos);
    stream << std::dec << std::setw(0);
}

void write_quoted_string(std::ostream& stream, const char* str)
{
    stream << std::hex << std::right << std::setfill('0');

    buffered_writer<> writer(stream);

    writer << '"';

    while (*str != '\0')
    {
        switch (*str)
        {
        case '"':
            writer << "\\\"";
            break;

        case '\\':
            writer << "\\\\";
            break;

        case '\n':
            writer << "\\n";
            break;

        case '\r':
            writer << "\\r";
            break;

        case '\t':
            writer << "\\t";
            break;

        default:
            if ((*str > 0 && *str < 32) || *str == 127) // ASCII control characters (NUL is not supported)
            {
                writer << "\\u";

                writer.flush();
                stream << std::setw(4) << static_cast<unsigned>(*str);
            }
            else
            {
                writer << *str;
            }
            break;
        }
        str++;
    }

    writer << '"';

    writer.flush();

    stream << std::dec;
}

} // unnamed namespace

template<typename InputIt>
struct range
{
    InputIt begin;
    InputIt end;
};

template<typename InputIt>
range<InputIt> make_range(InputIt begin, InputIt end)
{
    const range<InputIt> range = { begin, end };

    return range;
}

template<typename InputIt, typename ValueWriter>
class range_writer
{
private:

    ValueWriter m_value_writer;

public:

    explicit range_writer(const ValueWriter& value_writer) :
        m_value_writer(value_writer)
    {
    }

    void operator()(std::ostream& stream, const range<InputIt>& range, const writer_configuration& configuration) const
    {
        write_array(stream, range.begin, range.end, m_value_writer, configuration);
    }
};

} // namespace detail

class writer
{
private:

    enum status
    {
        EMPTY,
        OPEN,
        CLOSED
    };

    bool m_array;
    status m_status;
    std::ostream* m_stream;
    writer_configuration m_configuration;

    enum pretty_print_token
    {
        BEFORE_ELEMENT,
        AFTER_COLON,
        BEFORE_CLOSING_BRACKET
    };

    void write_pretty_print_token(pretty_print_token token)
    {
        if (!m_configuration.pretty_printing())
        {
            return;
        }

        detail::buffered_writer<16> writer(*m_stream);

        if ((token == BEFORE_ELEMENT) || ((token == BEFORE_CLOSING_BRACKET) && (m_status != EMPTY)))
        {
            if (!m_configuration.horizontal_array())
            {
                const size_t base_depth = (token == BEFORE_ELEMENT) ? 1 : 0;
                const size_t no_indent_characters = m_configuration.use_tabs() ?
                        (base_depth + m_configuration.nesting_level()) :
                        (base_depth + m_configuration.nesting_level()) * m_configuration.indent_spaces();

                writer << '\n';

                for (size_t i = 0; i < no_indent_characters; i++)
                {
                    writer << ((m_configuration.use_tabs()) ? '\t' : ' ');
                }
            }
        }
        else if (token == AFTER_COLON)
        {
            writer << ' ';
        }

        writer.flush();
    }

    void write_opening_bracket()
    {
        if (m_array)
        {
            *m_stream << '[';
        }
        else
        {
            *m_stream << '{';
        }
    }

    void write_closing_bracket()
    {
        write_pretty_print_token(BEFORE_CLOSING_BRACKET);

        if (m_array)
        {
            *m_stream << ']';
        }
        else
        {
            *m_stream << '}';
        }
    }

protected:

    void next_field()
    {
        if (m_status == EMPTY)
        {
            write_opening_bracket();
        }
        else if (m_status == OPEN)
        {
            *m_stream << ',';
        }

        write_pretty_print_token(BEFORE_ELEMENT);

        m_status = OPEN;
    }

    void write_field_name(const char* name)
    {
        detail::write_quoted_string(*m_stream, name);

        *m_stream << ':';

        write_pretty_print_token(AFTER_COLON);
    }

    template<typename V, typename ValueWriter>
    void write_helper(const char* field_name, const V& value, const ValueWriter& value_writer)
    {
        if (m_status == CLOSED)
        {
            return;
        }

        detail::adjust_stream_settings(*m_stream);

        next_field();

        if (field_name != NULL)
        {
            write_field_name(field_name);
        }

        const writer_configuration nested_object_configuration = m_configuration.increase_nesting_level();
        detail::wrap_two_or_three_args_functor(value_writer)(*m_stream, value, nested_object_configuration);
    }

    explicit writer(std::ostream& stream, bool array, const writer_configuration& configuration) :
        m_array(array),
        m_status(EMPTY),
        m_stream(&stream),
        m_configuration(configuration)
    {
    }

public:
    ~writer()
    {
        if (m_configuration.close_on_destroy())
            close();
    }

    std::ostream& stream() const
    {
        return *m_stream;
    }

    const writer_configuration& configuration() const
    {
        return m_configuration;
    }

    writer_configuration& configuration()
    {
        return m_configuration;
    }

    void close()
    {
        if (m_status == CLOSED)
        {
            return;
        }

        detail::adjust_stream_settings(*m_stream);

        if (m_status == EMPTY)
        {
            write_opening_bracket();
        }

        write_closing_bracket();

        m_status = CLOSED;
        m_stream->flush();
    }

};

class object_writer;
class array_writer;

class object_writer : public writer
{
public:

    explicit object_writer(std::ostream& stream, const writer_configuration& configuration = writer_configuration()) :
        writer(stream, false, configuration)
    {
    }

    template<typename V>
    void write(const char* field_name, const V& value)
    {
        write_helper(field_name, value, default_value_writer<V>());
    }

    template<typename V, typename ValueWriter>
    void write(const char* field_name, const V& value, const ValueWriter& value_writer)
    {
        write_helper(field_name, value, value_writer);
    }

    template<typename InputIt>
    void write_array(const char* field_name, InputIt begin, InputIt end)
    {
        write_array(field_name, begin, end, default_value_writer<typename detail::get_value_type<InputIt>::type>());
    }

    template<typename InputIt, typename ValueWriter>
    void write_array(const char* field_name, InputIt begin, InputIt end, ValueWriter value_writer)
    {
        write(field_name, detail::make_range(begin, end), detail::range_writer<InputIt, ValueWriter>(value_writer));
    }

    object_writer nested_object(const char* field_name);

    array_writer nested_array(const char* field_name);

};

class array_writer : public writer
{
public:

    explicit array_writer(std::ostream& stream, const writer_configuration& configuration = writer_configuration()) :
        writer(stream, true, configuration)
    {
    }

    template<typename V>
    void write(const V& value)
    {
        write_helper(NULL, value, default_value_writer<V>());
    }

    template<typename V, typename ValueWriter>
    void write(const V& value, const ValueWriter& value_writer)
    {
        write_helper(NULL, value, value_writer);
    }

    template<typename InputIt>
    void write_array(InputIt begin, InputIt end)
    {
        write_array(begin, end, default_value_writer<typename detail::get_value_type<InputIt>::type>());
    }

    template<typename InputIt, typename ValueWriter>
    void write_array(InputIt begin, InputIt end, ValueWriter value_writer)
    {
        write(detail::make_range(begin, end), detail::range_writer<InputIt, ValueWriter>(value_writer));
    }

    object_writer nested_object();

    array_writer nested_array();

};

inline object_writer object_writer::nested_object(const char* field_name)
{
    detail::adjust_stream_settings(stream());

    next_field();
    write_field_name(field_name);

    return object_writer(stream(), configuration().increase_nesting_level());
}

inline array_writer object_writer::nested_array(const char* field_name)
{
    detail::adjust_stream_settings(stream());

    next_field();
    write_field_name(field_name);

    return array_writer(stream(), configuration().increase_nesting_level());
}

inline object_writer array_writer::nested_object()
{
    detail::adjust_stream_settings(stream());

    next_field();

    return object_writer(stream(), configuration().increase_nesting_level());
}

inline array_writer array_writer::nested_array()
{
    detail::adjust_stream_settings(stream());

    next_field();

    return array_writer(stream(), configuration().increase_nesting_level());
}

template<>
struct default_value_writer<null_t>
{
    void operator()(std::ostream& stream, null_t) const
    {
        stream << "null";
    }
};

#if MJW_CPP11_SUPPORTED
template<>
struct default_value_writer<std::nullptr_t>
{
    void operator()(std::ostream& stream, std::nullptr_t) const
    {
        default_value_writer<null_t>()(stream, null);
    }
};
#endif

template<typename IntegralType>
struct default_value_writer<
        IntegralType,
        typename detail::enable_if<MJW_LIB_NS::is_integral<IntegralType>::value && !MJW_LIB_NS::is_same<IntegralType, bool>::value>::type>
{
    void operator()(std::ostream& stream, IntegralType value) const
    {
        // the unary plus is used here to force chars to be printed as integers
        stream << +value;
    }
};

template<>
struct default_value_writer<bool>
{
    void operator()(std::ostream& stream, bool value) const
    {
        if (value)
        {
            stream << "true";
        }
        else
        {
            stream << "false";
        }
    }
};

template<typename FloatingPoint>
struct default_value_writer<
        FloatingPoint,
        typename detail::enable_if<MJW_LIB_NS::is_floating_point<FloatingPoint>::value>::type>
{
    void operator()(std::ostream& stream, FloatingPoint value) const
    {
        // Numeric values that cannot be represented as sequences of digits
        // (such as Infinity and NaN) are not permitted in JSON
        if (!MJW_ISFINITE(value))
        {
            default_value_writer<null_t>()(stream, null); // falling back to null
        }
        else
        {
            stream << value;
        }
    }
};

template<>
struct default_value_writer<char*>
{
    void operator()(std::ostream& stream, const char* str) const
    {
        detail::write_quoted_string(stream, str);
    }
};

template<>
struct default_value_writer<const char*> : public default_value_writer<char*>
{
};

template<size_t N>
struct default_value_writer<char[N]> : public default_value_writer<char*>
{
};

template<size_t N>
struct default_value_writer<const char[N]> : public default_value_writer<char*>
{
};

template<>
struct default_value_writer<std::string>
{
    void operator()(std::ostream& stream, const std::string& str) const
    {
        default_value_writer<char*>()(stream, str.c_str());
    }
};

template<typename InputIt>
void write_array(
        std::ostream& stream,
        InputIt begin, InputIt end,
        const writer_configuration& configuration)
{
    write_array(stream, begin, end, default_value_writer<typename detail::get_value_type<InputIt>::type>(), configuration);
}

template<typename InputIt, typename ValueWriter>
void write_array(
        std::ostream& stream,
        InputIt begin, InputIt end,
        const ValueWriter& value_writer,
        const writer_configuration& configuration)
{
    array_writer writer(stream, configuration);

    for (InputIt it = begin; it != end; ++it)
    {
        writer.write(*it, value_writer);
    }

    writer.close();
}

} // namespace minijson

#endif // MINIJSON_WRITER_H