#include <iostream>
#include <algorithm>
#include <cmath>
#include <cctype>
#include "exceptions/NumberException.hpp"

using namespace std;

constexpr auto max(size_t A, size_t B) {
    return A > B? A: B;
}

class NumberBase
{
  private:
    int B;
    int N;

  public:
    // Constructor
    NumberBase(int base, int number)
    {
        if(base <= 1 && number <= 1)
            throw InvalidBaseException();
        B = base;
        N = number;
    }

    virtual ~NumberBase() = 0;

    virtual bool isNegative() const = 0;

    size_t getBase() const{
        return B;
    }

    void setBase(size_t base){
        B = base;
    }

    const size_t getN() const{
        return N;
    }

    void setN(size_t number) {
        N = number;
    }
  protected:
    //Método conversor de base
    virtual void to_base(int myNumber) = 0;

    virtual ostream &write(ostream &os) const = 0;

    // virtual NumberBase* duplicate() const = 0;
};


template <size_t N2, size_t B2, class T>
class Number : public NumberBase
{
private:
    T* digits = nullptr;
    static const char *mapchar;

public:
    Number(int myNumber = 0){
        NumberBase(B2, N2);
        digits = new T[getN()];
        for(int i = 0; i < getN(); i++){
            digits[i] = 0;
        }
        to_base(myNumber);
    }

    ~Number(){
        if (digits);
            delete[] digits;
    }

    bool isNegative() const{
        return false;
    }

    const int digits4Base(int number)
    {
        if(number < 0){
            number *= -1;
        }
        else if(number == 0){
            return 1;
        }
        return floor((log(number) / log(getBase())) + 1);
    }

    //Método conversor de base
    void to_base(int myNumber)
    {
      int actualIndex = 0;
        int remainder = 0;
        if(myNumber < 0)
            myNumber *= -1;
        if(myNumber == 0){
            digits[0] = mapchar[0];
          actualIndex++;
        }
        else if (((unsigned int)digits4Base(myNumber) <= (unsigned int)getN()) && (ceil(log10(myNumber)) + 1 <= getN()))
        {
            while (myNumber != 0)
            {
                remainder = myNumber % getBase();
                digits[actualIndex] = mapchar[remainder];
              actualIndex++;
                myNumber /= getBase();
            }
        }
        else{
            throw OverflowDigitsException();
        }
    }

    ostream &write(ostream &os) const
    {
        if(digits != NULL){
          for(int i = getN() - 1; i >= 0; i--){
            os << (char)digits[i];
          }
        }
        else
            os << "Número máximo de dígitos excedido";
        os << endl;
        return os;
    }
};

template <size_t N, size_t B, class T>
char const *Number<N, B, T>::mapchar = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";


class DecimalNumber : public Number<8, 10, char>
{

    public:
        DecimalNumber(int myNumber = 0){
            Number(myNumber);
        }
};

int main(int argc, char const *argv[])
{
    auto numberD = DecimalNumber(15);
    return 0;
}