//===-- Measurement.h -------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef __PerfTestDriver__Measurement__
#define __PerfTestDriver__Measurement__

#include "Gauge.h"
#include "Timer.h"
#include "Metric.h"
#include "MemoryGauge.h"

namespace lldb_perf
{
template <typename GaugeType, typename Callable>
class Measurement
{
public:
    Measurement () :
        m_gauge (),
        m_callable (),
        m_metric ()
    {
    }
    
    Measurement (Callable callable, const char* name, const char* desc)  :
        m_gauge (),
        m_callable (callable),
        m_metric (Metric<typename GaugeType::ValueType>(name, desc))
    {
    }

    Measurement (const char* name, const char* desc)  :
        m_gauge (),
        m_callable (),
        m_metric (Metric<typename GaugeType::ValueType>(name, desc))
    {
    }

    template <typename GaugeType_Rhs, typename Callable_Rhs>
    Measurement (const Measurement<GaugeType_Rhs, Callable_Rhs>& rhs) :
        m_gauge(rhs.GetGauge()),
        m_callable(rhs.GetCallable()),
        m_metric(rhs.GetMetric())
    {
    }

    template <typename... Args>
    void
    operator () (Args... args)
    {
        m_gauge.Start();
        m_callable(args...);
        m_metric.Append (m_gauge.Stop());
    }
    
    virtual const Callable&
    GetCallable () const
    {
        return m_callable;
    }
    
    virtual const GaugeType&
    GetGauge () const
    {
        return m_gauge;
    }
    
    virtual const Metric<typename GaugeType::ValueType>&
    GetMetric () const
    {
        return m_metric;
    }
    
    void
    Start ()
    {
        m_gauge.Start();
    }
    
    typename GaugeType::ValueType
    Stop ()
    {
        auto value = m_gauge.Stop();
        m_metric.Append(value);
        return value;
    }

    void
    WriteStartValue (Results &results)
    {
        auto metric = GetMetric ();
        results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetStartValue()));
    }
    
    void
    WriteStopValue (Results &results)
    {
        auto metric = GetMetric ();
        results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetStopValue()));
    }

    void
    WriteAverageValue (Results &results)
    {
        auto metric = GetMetric ();
        results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetAverage()));
    }
    
    void
    WriteAverageAndStandardDeviation (Results &results)
    {
        auto metric = GetMetric ();
        auto dictionary = (Results::Dictionary*)results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetAverage())).get();
        if (dictionary)
        {
            dictionary->Add("stddev", NULL, lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetStandardDeviation()));
        }
    }
    
    void
    WriteStandardDeviation (Results &results)
    {
        auto metric = GetMetric ();
        results.GetDictionary().Add(metric.GetName(), metric.GetDescription(), lldb_perf::GetResult<typename GaugeType::ValueType> (NULL, metric.GetStandardDeviation()));
    }

protected:
    GaugeType m_gauge;
    Callable m_callable;
    Metric<typename GaugeType::ValueType> m_metric;
};
    
template <typename Callable>
class TimeMeasurement : public Measurement<TimeGauge,Callable>
{
public:
    TimeMeasurement () :
        Measurement<TimeGauge,Callable> ()
    {
    }
    
    TimeMeasurement (Callable callable,
                     const char* name = NULL,
                     const char* descr = NULL) :
        Measurement<TimeGauge,Callable> (callable, name, descr)
    {
    }
    
    template <typename Callable_Rhs>
    TimeMeasurement (const TimeMeasurement<Callable_Rhs>& rhs) :
        Measurement<TimeGauge,Callable>(rhs)
    {
    }
    
    template <typename GaugeType_Rhs, typename Callable_Rhs>
    TimeMeasurement (const Measurement<GaugeType_Rhs, Callable_Rhs>& rhs) :
        Measurement<GaugeType_Rhs,Callable_Rhs>(rhs)
    {
    }
    
    template <typename... Args>
    void
    operator () (Args... args)
    {
        Measurement<TimeGauge,Callable>::operator()(args...);
    }
};

template <typename Callable>
class MemoryMeasurement : public Measurement<MemoryGauge,Callable>
{
public:
    MemoryMeasurement () : Measurement<MemoryGauge,Callable> ()
    {
    }
    
    MemoryMeasurement (Callable callable,
                       const char* name,
                       const char* descr) :
        Measurement<MemoryGauge,Callable> (callable, name, descr)
    {
    }

    MemoryMeasurement (const char* name, const char* descr) :
        Measurement<MemoryGauge,Callable> (name, descr)
    {
    }

    template <typename Callable_Rhs>
    MemoryMeasurement (const MemoryMeasurement<Callable_Rhs>& rhs) :
        Measurement<MemoryGauge,Callable>(rhs)
    {
    }
    
    template <typename GaugeType_Rhs, typename Callable_Rhs>
    MemoryMeasurement (const Measurement<GaugeType_Rhs, Callable_Rhs>& rhs) :
        Measurement<GaugeType_Rhs,Callable_Rhs>(rhs)
    {
    }
    
    template <typename... Args>
    void
    operator () (Args... args)
    {
        Measurement<MemoryGauge,Callable>::operator()(args...);
    }
};
    
}

#endif /* defined(__PerfTestDriver__Measurement__) */