#include "Variable/Variable.h"

#include <Common/debug.h>
#include <Data/DateTimeRange.h>
#include <Data/IDataSeries.h>
#include <QMutex>
#include <QReadWriteLock>
#include <QThread>
#include <optional>

Q_LOGGING_CATEGORY(LOG_Variable, "Variable")

/**
 * Searches in metadata for a value that can be converted to DataSeriesType
 * @param metadata the metadata where to search
 * @return the value converted to a DataSeriesType if it was found, UNKNOWN type
 * otherwise
 * @sa DataSeriesType
 */
static DataSeriesType findDataSeriesType(const QVariantHash& metadata)
{
  auto dataSeriesType = DataSeriesType::NONE;

  // Go through the metadata and stop at the first value that could be converted
  // to DataSeriesType
  for(auto it = metadata.cbegin(), end = metadata.cend();
      it != end && dataSeriesType == DataSeriesType::NONE; ++it)
  {
    dataSeriesType = DataSeriesTypeUtils::fromString(it.value().toString());
  }

  return dataSeriesType;
}

#define VP_PROPERTY(property, getter, setter, type)                            \
  type getter() noexcept                                                       \
  {                                                                            \
    QReadLocker lock{&m_Lock};                                                 \
    return property;                                                           \
  }                                                                            \
  void setter(const type& getter) noexcept                                     \
  {                                                                            \
    QWriteLocker lock{&m_Lock};                                                \
    property = getter;                                                         \
  }                                                                            \
  type property;

#define V_FW_GETTER_SETTER(getter, setter, type)                               \
  type Variable::getter() const noexcept { return impl->getter(); }            \
  void Variable::setter(const type& getter) noexcept                           \
  {                                                                            \
    impl->setter(getter);                                                      \
    emit updated(this->ID());                                                  \
  }

struct Variable::VariablePrivate
{
  explicit VariablePrivate(const QString& name, const QVariantHash& metadata)
      : m_Name{name}, m_Range{INVALID_RANGE}, m_CacheRange{INVALID_RANGE},
        m_Metadata{metadata}, m_DataSeries{nullptr}, m_RealRange{INVALID_RANGE},
        m_NbPoints{0}, m_Type{findDataSeriesType(m_Metadata)}
  {}

  VariablePrivate(const VariablePrivate& other)
      : m_Name{other.m_Name}, m_Range{other.m_Range},
        m_CacheRange{other.m_CacheRange}, m_Metadata{other.m_Metadata},
        m_DataSeries{other.m_DataSeries != nullptr ? other.m_DataSeries->clone()
                                                   : nullptr},
        m_RealRange{other.m_RealRange},
        m_NbPoints{other.m_NbPoints}, m_Type{findDataSeriesType(m_Metadata)}
  {}

  void lockRead() { m_Lock.lockForRead(); }
  void lockWrite() { m_Lock.lockForWrite(); }
  void unlock() { m_Lock.unlock(); }

  void purgeDataSeries()
  {
    if(m_DataSeries)
    { m_DataSeries->purge(m_CacheRange.m_TStart, m_CacheRange.m_TEnd); }
    updateRealRange();
    updateNbPoints();
  }
  void mergeDataSeries(const std::vector<IDataSeries*>& dataseries,
                       bool overwrite = false)
  {
    QWriteLocker lock{&m_Lock};
    for(auto ds : dataseries)
    {
      if(!overwrite & bool(m_DataSeries))
        m_DataSeries->merge(ds);
      else
        m_DataSeries = ds->clone();
    }
  }
  void updateNbPoints()
  {
    m_NbPoints = m_DataSeries ? m_DataSeries->nbPoints() : 0;
  }

  /// Updates real range according to current variable range and data series
  void updateRealRange()
  {
    if(m_DataSeries)
    {
      auto lock       = m_DataSeries->getReadLock();
      auto end        = m_DataSeries->cend();
      auto minXAxisIt = m_DataSeries->minXAxisData(m_Range.m_TStart);
      auto maxXAxisIt = m_DataSeries->maxXAxisData(m_Range.m_TEnd);
      if(minXAxisIt != end && maxXAxisIt != end &&
         minXAxisIt->x() <= maxXAxisIt->x())
        m_RealRange = DateTimeRange{minXAxisIt->x(), maxXAxisIt->x()};
      else
        m_RealRange = std::nullopt;
    }
    else
    {
      m_RealRange = std::nullopt;
    }
  }

  VP_PROPERTY(m_Name, name, setName, QString)
  VP_PROPERTY(m_Range, range, setRange, DateTimeRange)
  VP_PROPERTY(m_CacheRange, cacheRange, setCacheRange, DateTimeRange)
  VP_PROPERTY(m_Metadata, metadata, setMetadata, QVariantHash)
  VP_PROPERTY(m_DataSeries, dataSeries, setDataSeries,
              std::shared_ptr<IDataSeries>)
  VP_PROPERTY(m_RealRange, realRange, setRealRange,
              std::optional<DateTimeRange>)
  unsigned int m_NbPoints;
  VP_PROPERTY(m_Type, type, setType, DataSeriesType)
  QReadWriteLock m_Lock;
};

Variable::Variable(const QString& name, const QVariantHash& metadata)
    : impl{spimpl::make_unique_impl<VariablePrivate>(name, metadata)},
      _uuid{QUuid::createUuid()}
{}

Variable::Variable(const Variable& other)
    : impl{spimpl::make_unique_impl<VariablePrivate>(*other.impl)},
      _uuid{QUuid::createUuid()} // is a clone but must have a != uuid
{}

std::shared_ptr<Variable> Variable::clone() const
{
  return std::make_shared<Variable>(*this);
}

V_FW_GETTER_SETTER(name, setName, QString)

DateTimeRange Variable::range() const noexcept { return impl->range(); }

void Variable::setRange(const DateTimeRange& range, bool notify) noexcept
{
  impl->setRange(range);
  impl->updateRealRange();
  if(notify) emit this->updated(this->ID());
}

V_FW_GETTER_SETTER(cacheRange, setCacheRange, DateTimeRange)

unsigned int Variable::nbPoints() const noexcept { return impl->m_NbPoints; }

std::optional<DateTimeRange> Variable::realRange() const noexcept
{
  return impl->realRange();
}

void Variable::updateData(const std::vector<IDataSeries*>& dataSeries,
                          const DateTimeRange& newRange,
                          const DateTimeRange& newCacheRange, bool notify)
{
  {
    QWriteLocker lock{&m_lock};
    impl->mergeDataSeries(dataSeries);
    impl->setRange(newRange);
    impl->setCacheRange(newCacheRange);
    impl->purgeDataSeries();
  }
  if(notify) emit updated(this->ID());
}

void Variable::setData(const std::vector<IDataSeries*>& dataSeries,
                       const DateTimeRange& newRange,
                       const DateTimeRange& newCacheRange, bool notify)
{
  {
    QWriteLocker lock{&m_lock};
    impl->mergeDataSeries(dataSeries, true);
    impl->setRange(newRange);
    impl->setCacheRange(newCacheRange);
    impl->purgeDataSeries();
  }
  if(notify) emit updated(this->ID());
}

std::shared_ptr<IDataSeries> Variable::dataSeries() const noexcept
{
  return impl->dataSeries();
}

DataSeriesType Variable::type() const noexcept { return impl->type(); }

QVariantHash Variable::metadata() const noexcept
{
  impl->lockRead();
  auto metadata = impl->m_Metadata;
  impl->unlock();
  return metadata;
}