/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "StatisticDescriptorImpl.hpp"

namespace apache {
namespace geode {
namespace statistics {

using client::IllegalArgumentException;
using client::IllegalStateException;
using client::OutOfMemoryException;

const std::string StatisticDescriptorImpl::IntTypeName = "int_t";
const std::string StatisticDescriptorImpl::LongTypeName = "Long";
const std::string StatisticDescriptorImpl::DoubleTypeName = "Float";

/**
 * Describes an individual statistic whose value is updated by an
 * application and may be archived by Geode.  These descriptions are
 * gathered together in a {@link StatisticsType}.
 * <P>
 * To get an instance of this interface use an instance of
 * {@link StatisticsFactory}.
 * <P>
 * StatisticDescriptors are naturally ordered by their name.
 *
 */

StatisticDescriptorImpl::StatisticDescriptorImpl(
    const std::string& statName, FieldType statDescriptorType,
    const std::string& statDescription, const std::string& statUnit,
    bool statIsStatCounter, bool statIsStatLargerBetter)
    : name(statName),
      description(statDescription),
      unit(statUnit),
      isStatCounter(statIsStatCounter),
      isStatLargerBetter(statIsStatLargerBetter),
      id(-1),
      descriptorType(statDescriptorType) {}

StatisticDescriptorImpl::~StatisticDescriptorImpl() {}

/////////////////////// Create functions ///////////////////////////////////

StatisticDescriptor* StatisticDescriptorImpl::createIntCounter(
    const std::string& statName, const std::string& description,
    const std::string& units, bool isLargerBetter) {
  FieldType fieldType = INT_TYPE;
  StatisticDescriptorImpl* sdi = new StatisticDescriptorImpl(
      statName, fieldType, description, units, true, isLargerBetter);
  if (sdi == nullptr) {
    throw OutOfMemoryException(
        "StatisticDescriptorImpl::createIntCounter: out of memory");
  }
  return sdi;
}

StatisticDescriptor* StatisticDescriptorImpl::createLongCounter(
    const std::string& name, const std::string& description,
    const std::string& units, bool isLargerBetter) {
  FieldType fieldType = LONG_TYPE;
  StatisticDescriptorImpl* sdi = new StatisticDescriptorImpl(
      name, fieldType, description, units, true, isLargerBetter);
  if (sdi == nullptr) {
    throw OutOfMemoryException(
        "StatisticDescriptorImpl::createLongCounter: out of memory");
  }
  return sdi;
}

StatisticDescriptor* StatisticDescriptorImpl::createDoubleCounter(
    const std::string& name, const std::string& description,
    const std::string& units, bool isLargerBetter) {
  FieldType fieldType = DOUBLE_TYPE;
  StatisticDescriptorImpl* sdi = new StatisticDescriptorImpl(
      name, fieldType, description, units, true, isLargerBetter);
  if (sdi == nullptr) {
    throw OutOfMemoryException(
        "StatisticDescriptorImpl::createDoubleCounter: out of memory");
  }
  return sdi;
}

StatisticDescriptor* StatisticDescriptorImpl::createIntGauge(
    const std::string& name, const std::string& description,
    const std::string& units, bool isLargerBetter) {
  FieldType fieldType = INT_TYPE;
  StatisticDescriptorImpl* sdi = new StatisticDescriptorImpl(
      name, fieldType, description, units, false, isLargerBetter);
  if (sdi == nullptr) {
    throw OutOfMemoryException(
        "StatisticDescriptorImpl::createIntGauge: out of memory");
  }
  return sdi;
}

StatisticDescriptor* StatisticDescriptorImpl::createLongGauge(
    const std::string& name, const std::string& description,
    const std::string& units, bool isLargerBetter) {
  FieldType fieldType = LONG_TYPE;
  StatisticDescriptorImpl* sdi = new StatisticDescriptorImpl(
      name, fieldType, description, units, false, isLargerBetter);

  if (sdi == nullptr) {
    throw OutOfMemoryException(
        "StatisticDescriptorImpl::createLongGauge: out of memory");
  }
  return sdi;
}

StatisticDescriptor* StatisticDescriptorImpl::createDoubleGauge(
    const std::string& name, const std::string& description,
    const std::string& units, bool isLargerBetter) {
  FieldType fieldType = DOUBLE_TYPE;
  StatisticDescriptorImpl* sdi = new StatisticDescriptorImpl(
      name, fieldType, description, units, false, isLargerBetter);
  if (sdi == nullptr) {
    throw OutOfMemoryException(
        "StatisticDescriptorImpl::createDoubleGauge: out of memory");
  }
  return sdi;
}

/////////////////////// StatisticDescriptor(Base class)
/// Methods///////////////////////////

const std::string& StatisticDescriptorImpl::getName() const { return name; }

const std::string& StatisticDescriptorImpl::getDescription() const {
  return description;
}

int32_t StatisticDescriptorImpl::getStorageBits() {
  return getTypeCodeBits(descriptorType);
}

const std::string& StatisticDescriptorImpl::getTypeCodeName(FieldType code) {
  switch (code) {
    case INT_TYPE:
      return IntTypeName;
    case LONG_TYPE:
      return LongTypeName;
    case DOUBLE_TYPE:
      return DoubleTypeName;
    default: {
      std::string s = "Unknown type code:" + std::to_string(code);
      throw IllegalArgumentException(s.c_str());
    }
  }
}

/**
 * Returns the number of bits needed to represent a value of the given type
 * @throws IllegalArgumentException/
 *         <code>code</code> is an unknown type
 */
int32_t StatisticDescriptorImpl::getTypeCodeBits(FieldType code) {
  switch (code) {
    case INT_TYPE:
      return 32;
    case LONG_TYPE:
      return 64;
    case DOUBLE_TYPE:
      return 64;
    default:
      std::string temp(getTypeCodeName(code));
      std::string s = "Unknown type code: " + temp;
      throw IllegalArgumentException(s.c_str());
  }
}

bool StatisticDescriptorImpl::isCounter() const { return isStatCounter; }

bool StatisticDescriptorImpl::isLargerBetter() const {
  return isStatLargerBetter;
}

const std::string& StatisticDescriptorImpl::getUnit() const { return unit; }

int32_t StatisticDescriptorImpl::getId() const {
  if (id == -1) {
    std::string s = "The id has not been initialized yet.";
    throw IllegalStateException(s.c_str());
  }
  return id;
}

///////////////////////// Instance Methods///////////////// ////////////////////

FieldType StatisticDescriptorImpl::getTypeCode() const {
  return descriptorType;
}

void StatisticDescriptorImpl::setId(int32_t statId) { id = statId; }

int32_t StatisticDescriptorImpl::checkInt() const {
  if (descriptorType != INT_TYPE) {
    std::string sb;
    std::string typeCode(getTypeCodeName(getTypeCode()));
    sb = "The statistic " + name;
    sb += " is of type " + typeCode;
    sb += " and it was expected to be an int";
    throw IllegalArgumentException(sb.c_str());
  }
  return id;
}
int32_t StatisticDescriptorImpl::checkLong() const {
  if (descriptorType != LONG_TYPE) {
    std::string sb;
    std::string typeCode(getTypeCodeName(getTypeCode()));
    sb = "The statistic " + name;
    sb += " is of type " + typeCode;
    sb += " and it was expected to be an long";
    throw IllegalArgumentException(sb.c_str());
  }
  return id;
}

int32_t StatisticDescriptorImpl::checkDouble() const {
  if (descriptorType != DOUBLE_TYPE) {
    std::string sb;
    std::string typeCode(getTypeCodeName(getTypeCode()));

    sb = "The statistic " + name;
    sb += " is of type " + typeCode;
    sb += " and it was expected to be an long";
    throw IllegalArgumentException(sb.c_str());
  }
  return id;
}

}  // namespace statistics
}  // namespace geode
}  // namespace apache