#ifndef __HAYAI_JSONOUTPUTTER
#define __HAYAI_JSONOUTPUTTER
#include <iomanip>
#include <ostream>

#include "hayai_outputter.hpp"


#define JSON_OBJECT_BEGIN "{"
#define JSON_OBJECT_END "}"
#define JSON_ARRAY_BEGIN "["
#define JSON_ARRAY_END "]"
#define JSON_STRING_BEGIN "\""
#define JSON_STRING_END "\""
#define JSON_NAME_SEPARATOR ":"
#define JSON_VALUE_SEPARATOR ","
#define JSON_TRUE "true"
#define JSON_FALSE "false"

namespace hayai
{
    /// JSON outputter.

    /// Outputs the result of benchmarks in JSON format with the following
    /// structure:
    ///
    /// {
    ///     "format_version": 1,
    ///     "benchmarks": [{
    ///         "fixture": "DeliveryMan",
    ///         "name": "DeliverPackage",
    ///         "parameters": {
    ///             "declaration": "std::size_t distance",
    ///             "value": "1"
    ///         },
    ///         "iterations_per_run": 10,
    ///         "disabled": false,
    ///         "runs": [{
    ///             "duration": 3801.889831
    ///         }, ..]
    ///     }, {
    ///         "fixture": "DeliveryMan",
    ///         "name": "DisabledTest",
    ///         "iterations_per_run": 10,
    ///         "disabled": true
    ///     }, ..]
    /// }
    ///
    /// All durations are represented as milliseconds.
    class JsonOutputter
        :   public Outputter
    {
    public:
        /// Initialize JSON outputter.

        /// @param stream Output stream. Must exist for the entire duration of
        /// the outputter's use.
        JsonOutputter(std::ostream& stream)
            :   _stream(stream),
                _firstTest(true)
        {

        }


        virtual void Begin(const std::size_t& enabledCount,
                           const std::size_t& disabledCount)
        {
            (void)enabledCount;
            (void)disabledCount;

            _stream <<
                JSON_OBJECT_BEGIN

                JSON_STRING_BEGIN "format_version" JSON_STRING_END
                JSON_NAME_SEPARATOR
                "1"

                JSON_VALUE_SEPARATOR

                JSON_STRING_BEGIN "benchmarks" JSON_STRING_END
                JSON_NAME_SEPARATOR
                JSON_ARRAY_BEGIN;
        }


        virtual void End(const std::size_t& executedCount,
                         const std::size_t& disabledCount)
        {
            (void)executedCount;
            (void)disabledCount;

            _stream <<
                JSON_ARRAY_END
                JSON_OBJECT_END;
        }


        virtual void BeginTest(const std::string& fixtureName,
                               const std::string& testName,
                               const TestParametersDescriptor& parameters,
                               const std::size_t& runsCount,
                               const std::size_t& iterationsCount)
        {
            BeginTestObject(fixtureName,
                            testName,
                            parameters,
                            runsCount,
                            iterationsCount,
                            false);
        }


        virtual void SkipDisabledTest(const std::string& fixtureName,
                                      const std::string& testName,
                                      const TestParametersDescriptor& parameters,
                                      const std::size_t& runsCount,
                                      const std::size_t& iterationsCount)
        {
            BeginTestObject(fixtureName,
                            testName,
                            parameters,
                            runsCount,
                            iterationsCount,
                            true);
            EndTestObject();
        }


        virtual void EndTest(const std::string& fixtureName,
                             const std::string& testName,
                             const TestParametersDescriptor& parameters,
                             const TestResult& result)
        {
            (void)fixtureName;
            (void)testName;
            (void)parameters;

            _stream <<
                JSON_VALUE_SEPARATOR

                JSON_STRING_BEGIN "runs" JSON_STRING_END
                JSON_NAME_SEPARATOR
                JSON_ARRAY_BEGIN;

            const std::vector<uint64_t>& runTimes = result.RunTimes();

            for (std::vector<uint64_t>::const_iterator it = runTimes.begin();
                 it != runTimes.end();
                 ++it)
            {
                if (it != runTimes.begin())
                    _stream << JSON_VALUE_SEPARATOR;

                _stream << JSON_OBJECT_BEGIN
                           JSON_STRING_BEGIN "duration" JSON_STRING_END
                           JSON_NAME_SEPARATOR
                        << std::fixed
                        << std::setprecision(6)
                        << (double(*it) / 1000000.0)
                        << JSON_OBJECT_END;
            }

            _stream <<
                JSON_ARRAY_END;

            WriteDoubleProperty("mean", result.RunTimeAverage());
            WriteDoubleProperty("std_dev", result.RunTimeStdDev());
            WriteDoubleProperty("median", result.RunTimeMedian());
            WriteDoubleProperty("quartile_1", result.RunTimeQuartile1());
            WriteDoubleProperty("quartile_3", result.RunTimeQuartile3());

            EndTestObject();
        }
    private:
        void BeginTestObject(const std::string& fixtureName,
                             const std::string& testName,
                             const TestParametersDescriptor& parameters,
                             const std::size_t& runsCount,
                             const std::size_t& iterationsCount,
                             bool disabled)
        {
            (void)runsCount;

            if (_firstTest)
                _firstTest = false;
            else
                _stream << JSON_VALUE_SEPARATOR;

            _stream <<
                JSON_OBJECT_BEGIN

                JSON_STRING_BEGIN "fixture" JSON_STRING_END
                JSON_NAME_SEPARATOR;

            WriteString(fixtureName);

            _stream <<
                JSON_VALUE_SEPARATOR

                JSON_STRING_BEGIN "name" JSON_STRING_END
                JSON_NAME_SEPARATOR;

            WriteString(testName);

            _stream <<
                JSON_VALUE_SEPARATOR;

            const std::vector<TestParameterDescriptor>& descs =
                parameters.Parameters();

            if (!descs.empty())
            {
                _stream <<
                    JSON_STRING_BEGIN "parameters" JSON_STRING_END
                    JSON_NAME_SEPARATOR
                    JSON_ARRAY_BEGIN;

                for (std::size_t i = 0; i < descs.size(); ++i)
                {
                    if (i)
                        _stream << JSON_VALUE_SEPARATOR;

                    const TestParameterDescriptor& desc = descs[i];

                    _stream <<
                        JSON_OBJECT_BEGIN

                        JSON_STRING_BEGIN "declaration" JSON_STRING_END
                        JSON_NAME_SEPARATOR;

                    WriteString(desc.Declaration);

                    _stream <<
                        JSON_VALUE_SEPARATOR

                        JSON_STRING_BEGIN "value" JSON_STRING_END
                        JSON_NAME_SEPARATOR;

                    WriteString(desc.Value);

                    _stream <<
                        JSON_OBJECT_END;
                }

                _stream <<
                    JSON_ARRAY_END
                    JSON_VALUE_SEPARATOR;
            }

            _stream <<
                JSON_STRING_BEGIN "iterations_per_run" JSON_STRING_END
                JSON_NAME_SEPARATOR << iterationsCount <<

                JSON_VALUE_SEPARATOR

                JSON_STRING_BEGIN "disabled" JSON_STRING_END
                JSON_NAME_SEPARATOR << (disabled ? JSON_TRUE : JSON_FALSE);
        }


        inline void EndTestObject()
        {
            _stream <<
                JSON_OBJECT_END;
        }


        /// Write an escaped string.

        /// The escaping is currently very rudimentary and assumes that names,
        /// parameters etc. are ASCII.
        ///
        /// @param str String to write.
        void WriteString(const std::string& str)
        {
            _stream << JSON_STRING_BEGIN;

            std::string::const_iterator it = str.begin();
            while (it != str.end())
            {
                char c = *it++;

                switch (c)
                {
                case '\\':
                case '"':
                case '/':
                    _stream << "\\" << c;
                    break;

                case '\b':
                    _stream << "\\b";
                    break;

                case '\f':
                    _stream << "\\f";
                    break;

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

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

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

                default:
                    _stream << c;
                    break;
                }
            }

            _stream << JSON_STRING_END;
        }


        /// Write a property with a double value.

        /// @param key Property key.
        /// @param value Property value.
        void WriteDoubleProperty(const std::string& key, const double value)
        {
            _stream << JSON_VALUE_SEPARATOR
                    << JSON_STRING_BEGIN
                    << key
                    << JSON_STRING_END
                    << JSON_NAME_SEPARATOR
                    << std::fixed
                    << std::setprecision(6)
                    << (value / 1000000.0);
        }


        std::ostream& _stream;
        bool _firstTest;
    };
}

#undef JSON_OBJECT_BEGIN
#undef JSON_OBJECT_END
#undef JSON_ARRAY_BEGIN
#undef JSON_ARRAY_END
#undef JSON_STRING_BEGIN
#undef JSON_STRING_END
#undef JSON_NAME_SEPARATOR
#undef JSON_VALUE_SEPARATOR
#undef JSON_TRUE
#undef JSON_FALSE

#endif