#ifndef HUFFMAN_H
#define HUFFMAN_H

#include <cstdio>
#include <bitset>

// void* : "n, sign, 4 digits each except first int"

static const int NUMBER_OF_DIGITS = 10;

static const int SIZE_OF_INT_IN_NUMBER = 4;

template <size_t size>
class Huffman {

public :

    Huffman(short *encodingSizeDigits, std::bitset<NUMBER_OF_DIGITS> *encodingDigits, void *number) {
        for (int i = 0; i < NUMBER_OF_DIGITS; ++i) {
            this->encodingSizeDigits[i] = encodingSizeDigits[i];
            this->encodingDigits[i] = encodingDigits[i];
        }

        int *num = (int *)number;
        sign = (bool)num[1];
        numberOfArrays = (size_t)num[0];

        int n = num[0];
        size_t sz = 0;
        for (int i = 2; n > 0; ++i, --n) {
            if (i == 2) {
                addDigitFirstInt(sz, num[i]);
            } else {
                addDigitNotFirstInt(sz, num[i]);
            }
        }
    }

    friend size_t calculateHuffmanParameters(short *encodingSizeDigits, std::bitset<NUMBER_OF_DIGITS> *encodingDigits, void *number) {
        return 0;
    }

    void *getNumber() {
        size_t sz = size;
        int *number = new int[numberOfArrays + 2];
        number[0] = int(numberOfArrays);
        number[1] = sign;
        for (size_t position = numberOfArrays + 1; position > 1; --position) {
            short *digits = new short[SIZE_OF_INT_IN_NUMBER];
            int j = 0;
            if (position == 2) {
                while (sz > 0) {
                    for (j = SIZE_OF_INT_IN_NUMBER; j > 0; --j) {
                        digits[j - 1] = getDigit(sz);
                        sz -= encodingSizeDigits[digits[j - 1]];
                    }
                }
            } else {
                for (j = SIZE_OF_INT_IN_NUMBER; j > 0; --j) {
                    digits[j - 1] = getDigit(sz);
                    sz -= encodingSizeDigits[digits[j - 1]];
                }
            }
            int value = 0;
            for (; j < SIZE_OF_INT_IN_NUMBER; ++j) {
                value = value * 10 + digits[j];
            }
            number[position] = value;
        }
        return number;
    }

private :

    size_t numberOfArrays; // для более простого восстановления
    bool sign;
    std::bitset<size> data;

    short encodingSizeDigits[NUMBER_OF_DIGITS];
    std::bitset<NUMBER_OF_DIGITS> encodingDigits[NUMBER_OF_DIGITS];

    void addDigitFirstInt(size_t &sz, int value) {
        if (value >= 10) {
            addDigitFirstInt(sz, value / 10);
        }
        short digit = short(value % 10);
        for (short j = 0; j < encodingSizeDigits[digit]; ++j) {
            data[sz++] = encodingDigits[digit][j];
        }
    }

    void addDigitNotFirstInt(size_t &sz, int value, int depth = 0) {
        if (depth == SIZE_OF_INT_IN_NUMBER) {
            return;
        }
        addDigitNotFirstInt(sz, value / 10, depth + 1);
        short digit = short(value % 10);
        for (short j = 0; j < encodingSizeDigits[digit]; ++j) {
            data[sz++] = encodingDigits[digit][j];
        }
    }

    short getDigit(size_t &sz) {
        for (short digit = 0; digit < NUMBER_OF_DIGITS; ++digit) {
            if (size < encodingSizeDigits[digit]) {
                continue;
            }
            bool mark = true;
            for (short j = 0; j < encodingSizeDigits[digit]; ++j) {
                if (data[sz - j - 1] != encodingDigits[digit][encodingSizeDigits[digit] - j - 1]) {
                    mark = false;
                    break;
                }
            }
            if (mark) {
                return digit;
            }
        }
    }

};


#endif