/*
 * Author:          Patrick-Christopher Mattulat
 * Co-Author:       Claude Sonnet 4.6 (LLM)
 * Company:         Lynar Studios
 * E-Mail:          webmaster@lynarstudios.com
 * Created:         2020-08-07
 * Changed:         2026-06-23
 *
 * */

#include <ls-std/boxing/Integer.hpp>
#include <ls-std/core/exception/IllegalArithmeticOperationException.hpp>

using ls::standard::boxing::Integer;
using ls::standard::core::Class;
using ls::standard::core::IllegalArithmeticOperationException;
using std::stoi;
using std::string;
using std::to_string;

Integer::Integer(const int _value) : Class(_fetchClassName()), value(_value)
{}

Integer::Integer() : Class(_fetchClassName())
{}

Integer::~Integer() noexcept = default;

Integer &Integer::operator=(const int _value)
{
  this->value = _value;
  return *this;
}

int Integer::operator-() const
{
  return -this->value;
}

int Integer::operator+(const Integer &_integer) const
{
  return this->value + _integer.getValue();
}

int Integer::operator+(const int _value) const
{
  return this->value + _value;
}

int Integer::operator*(const Integer &_integer) const
{
  return this->value * _integer.getValue();
}

int Integer::operator*(const int _value) const
{
  return this->value * _value;
}

int Integer::operator-(const Integer &_integer) const
{
  return this->value - _integer.getValue();
}

int Integer::operator-(const int _value) const
{
  return this->value - _value;
}

int Integer::operator/(const Integer &_integer) const
{
  if (_integer == 0)
  {
    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
  }

  return this->value / _integer.getValue();
}

int Integer::operator/(const int _value) const
{
  if (_value == 0)
  {
    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
  }

  return this->value / _value;
}

int Integer::operator%(const Integer &_integer) const
{
  return this->value % _integer.getValue();
}

int Integer::operator%(const int _value) const
{
  return this->value % _value;
}

Integer &Integer::operator+=(const Integer &_integer)
{
  this->value += _integer.getValue();
  return *this;
}

Integer &Integer::operator+=(const int _value)
{
  this->value += _value;
  return *this;
}

Integer &Integer::operator-=(const Integer &_integer)
{
  this->value -= _integer.getValue();
  return *this;
}

Integer &Integer::operator-=(const int _value)
{
  this->value -= _value;
  return *this;
}

Integer &Integer::operator*=(const Integer &_integer)
{
  this->value *= _integer.getValue();
  return *this;
}

Integer &Integer::operator*=(const int _value)
{
  this->value *= _value;
  return *this;
}

Integer &Integer::operator/=(const Integer &_integer)
{
  if (_integer == 0)
  {
    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
  }

  this->value /= _integer.getValue();
  return *this;
}

Integer &Integer::operator/=(const int _value)
{
  if (_value == 0)
  {
    throw IllegalArithmeticOperationException{"division by zero is not allowed"};
  }

  this->value /= _value;
  return *this;
}

bool Integer::operator==(const Integer &_integer) const
{
  return this->value == _integer.getValue();
}

bool Integer::operator==(const int _value) const
{
  return this->value == _value;
}

bool Integer::operator!=(const Integer &_integer) const
{
  return this->value != _integer.getValue();
}

bool Integer::operator!=(const int _value) const
{
  return this->value != _value;
}

bool Integer::operator>(const Integer &_integer) const
{
  return this->value > _integer.getValue();
}

bool Integer::operator>(const int _value) const
{
  return this->value > _value;
}

bool Integer::operator>=(const Integer &_integer) const
{
  return this->value >= _integer.getValue();
}

bool Integer::operator>=(const int _value) const
{
  return this->value >= _value;
}

bool Integer::operator<(const Integer &_integer) const
{
  return this->value < _integer.getValue();
}

bool Integer::operator<(const int _value) const
{
  return this->value < _value;
}

bool Integer::operator<=(const Integer &_integer) const
{
  return this->value <= _integer.getValue();
}

bool Integer::operator<=(const int _value) const
{
  return this->value <= _value;
}

void Integer::operator++()
{
  this->value += 1;
}

void Integer::operator--()
{
  this->value -= 1;
}

void Integer::parse(const string &_parseText)
{
  this->value = stoi(_parseText);
}

string Integer::toString()
{
  return to_string(this->value);
}

int Integer::getValue() const
{
  return this->value;
}

string Integer::_fetchClassName()
{
  static const string className = "Integer";
  return className;
}
