#pragma once
#include <iostream>
#include <vector>
#include <cmath>
#include <string>
#include <fstream> // работа с файлами
#include <iomanip>

void permutation(int n, std::vector<char>& arr_comb, std::vector < std::vector <char> >& comb_s) { //Размещения с повторением 2^n

    if (n < 0) {
        std::cout << "нельзя отрицательные\n";
        return;

    }
    if (n == 0)
    {
        for (int i = 0; i <= arr_comb.size() - 1; i++)
            std::cout << arr_comb[i] << " ";
        std::cout << "\n";
        comb_s.push_back(arr_comb);
        return;
    }
    else {
        for (int i = 0;i <= 1;i++) {
            arr_comb[arr_comb.size() - n] = i + '0';
            permutation(n - 1, arr_comb, comb_s);
        }
    }
}

class DP_CODE
{
private:
    unsigned int n = 0;
    unsigned int t = 0;
    unsigned int flag = 0;
    std::vector < std::vector <char> > codes;
    unsigned int arr_rang[5][5] = { 2,2,2,2,2,3,3,3,3,3,5,4,4,4,4,8,6,5,5,5,14,8,7,6,6 };
    unsigned int rank = 0;
    std::vector < std::vector <char> > comb_s; //все комбинации 2^n
    std::vector <bool> bool_comb_s;// флажок, помогающий понять использован код или нет из 2 ^ n
public:
    class DP_CODE(unsigned int n, unsigned int t) {
        this->n = n;
        this->t = t;
        this->rank = arr_rang[n - 1][t - 1];
        std::cout << this->rank << " НАЧАЛО \n";
    }

    unsigned int H_comparison(std::vector <char> arr_comb1, std::vector <char> arr_comb2) { //функция сравнивает коды по условию
        int t1 = 0;
        unsigned int count = 0;
        for (int i = 0;i < n;i++)
        {
            t1 = abs((arr_comb1[i] - '0') - (arr_comb2[i] - '0'));
            if (t1 > 0) {
                count++;
            }
        }
        return count;
    }

    void print2(std::vector <char> arr_comb) {


        for (int j = 0; j < arr_comb.size(); j++) {

            std::cout << arr_comb[j];
        }
        std::cout << "\n";

    }

    void add_code(std::vector <char> arr_code,int index) {
        codes[index] = arr_code;

        for (int i = 0; i < n; i++)
        {
            codes[index][i] = arr_code[i];

        }



    }


    void fillingcodes(int size_codes) {

        std::cout << "rank=" << size_codes << "\n";
        if (size_codes == rank) {

            for (int i = 0;i < codes.size();i++) {

                print2(codes[i]);
            }
            //добавить флаг,что надо прерывать цикл
            flag = 1;
            return;
        }
        else {

            for (int i = 0;i < comb_s.size();i++) {
                if (flag == 1)
                    break;
                if (bool_comb_s[i] == 0) {

                    if (size_codes == 0) {

                        add_code(comb_s[i], size_codes);//добавить элемент
                        bool_comb_s[i] = 1;

                        fillingcodes(size_codes + 1);
                        if (flag == 0)
                            bool_comb_s[i] = 0;

                    }
                    else
                    {
                        int index = 0;
                        int count = 0;
                        for (int j = 0;j < size_codes; j++) { //сравниаем с теми ,которые уже есть в std::vector < std::vector <char> > codes;
                            if (H_comparison(comb_s[i], codes[j]) <= t) {
                                count = count + 1;
                                if (count == 1) {
                                    index = j;
                                }
                            }
                            if (count==1) { //дать вомзожность может когда встречается больеш чем надо?
                                if ((abs(size_codes - index) <= t) && ((size_codes - index) != 0)) {
                                    add_code(comb_s[i], size_codes);
                                    bool_comb_s[i] = 1;
                                    fillingcodes(size_codes + 1);
                                    if (flag == 0)
                                        bool_comb_s[i] = 0;
                            }
                            }
                            if (flag == 1)
                                break;
                        }
                    }

                }
            }
        }
    }

    void creating_codes() {
        if (n < 6 && t < 6) {

            int count_comb_s = pow(2, n);
            bool_comb_s.resize(count_comb_s);
            std::vector <char> arr_comb(n); //вспомогательный массив ,нужен только в permutation
            permutation(n, arr_comb, comb_s); //перебор всех комбинаций
            codes.resize(rank);
            fillingcodes(0);

        }
        else {
            codes =composition(n, t);
        }
    }
    std::vector <char> merge(std::vector <char> code_1, std::vector <char> code_2) {
        std::vector <char> code_3;
        code_3.resize(code_1.size() + code_2.size());//возможно ошибка
            for (int i = 0; i < code_1.size(); i++)
            {
                code_3[i] = code_1[i];
            }
            int j = 0;
            for (int i = code_1.size(); i < code_3.size(); i++)
            {
                code_3[i] = code_2[j];
                j++;
            }
            return code_3;
    }
    void  printf_file(std::string a) {
        std::string c = a + ".txt";
        std::ofstream fout(c, std::ofstream::app);
        if (!fout.is_open()) {
            std::cout << "Error";
            return;
        }
        else {
            std::cout << "All okey\n";
        for (int i = 0; i < codes.size(); i++) {
            for (int j = 0; j < n; j++) {
                std::cout<< codes[i][j]<<" ";
                fout << codes[i][j];
            }
            fout << "\n";
            std::cout <<  "\n";
        }
        }
        fout.close(); // закрываем файл

    }

    void  read_file(std::string a, std::vector < std::vector <char> > & codes_1) {
        char ch;
        int i = 0;
        int j = 0;
        std::cout << codes_1.size() <<" ";
        std::string c = a + ".txt";
        std::ifstream fin(c);//чтение данных
        if (!fin.is_open()) {
            std::cout << "Error";
        }
        else {
            std::cout << "All okey\n";
            while (fin.get(ch)) {
                if (ch == '0'|| ch == '1') {
                    codes_1[i][j] = ch;
                j++;
                if (j == codes_1[0].size()) {
                    j = 0;
                    i++;
                }
                }

            }
        }
        fin.close();

    }

    std::vector < std::vector <char> >add_limit(std::vector < std::vector <char> > codes_1, std::vector < std::vector <char> > codes_2, unsigned int t_1, unsigned int u_2, unsigned int rank_1) {
        std::vector < std::vector <char> > codes_3;
        codes_3.resize(rank_1);
        unsigned int rank_t=1;
        unsigned int i = 1;
        unsigned int g = 0;
        unsigned int j = 0;
        while (rank_t<=rank_1) //пока не набрали нужное количество по рангу
        {
            while (g < i * t_1) { //от 0 до i*t_1-1,по идее верно
                if (rank_t == rank_1) {
                    break;
                }
                codes_3[rank_t-1]=merge(codes_1[g], codes_2[j]);
                g++;
                rank_t++;

            }
            g++;
            while (j < i * u_2) {
                if (rank_t == rank_1) {
                    break;
                }
                codes_3[rank_t - 1]=merge(codes_1[g], codes_2[j]);
                j++;
                rank_t++;
            }
            j++;
            i++;
            if (rank_t == rank_1) {
                break;
            }

        }
        return codes_3;
    }
    std::vector < std::vector <char> > increase_rank(std::vector < std::vector <char> > codes_1, std::vector < std::vector <char> > codes_2, unsigned int t_1, unsigned int u_2, unsigned int rank_1) {
        std::vector < std::vector <char> > codes_3;
        //нужно учесть длину одного вектора
        codes_3.resize(rank_1);
        unsigned int rank_t = 1;
        unsigned int i = 1;
        unsigned int g = 0;
        int j = 0;
        unsigned int M = codes_2.size(); //всего M элелементов
        while (rank_t <= rank_1) //пока не набрали нужное количество по рангу
        {
            std::cout << rank_t<<"\n";
            while (j <M) {
                if (rank_t == rank_1) {
                    break;
                }
                codes_3[rank_t - 1] = merge(codes_1[g], codes_2[j]);
                j++;
                rank_t++;
                //M_1++;

            }
            g++;
            j--;
            //2)
            while (g < i * t_1 +i) {
                if (rank_t == rank_1) {
                    break;
                }
                codes_3[rank_t - 1] = merge(codes_1[g], codes_2[j]);
                g++;
                rank_t++;
            }
            g++;
            //3)
            while (j>=0) { //ошибка
                if (rank_t == rank_1) {
                    break;
                }
                codes_3[rank_t - 1] = merge(codes_1[g], codes_2[j]);
                j--;
                rank_t++;
            }
            j = 0; //чтобы убрать -1
            g++;
            i++;
            //4)
            while (g < i * t_1 + i) {
                if (rank_t == rank_1) {
                    break;
                }
                codes_3[rank_t - 1] = merge(codes_1[g], codes_2[j]);
                g++;
                rank_t++;
            }
            g++;
            i++;
            if (rank_t == rank_1) {
                break;
            }
        }

        return codes_3;

    }

    std::vector < std::vector <char> > composition(unsigned int n_1, unsigned int t_1) {
        unsigned int n_2 = 0, t_2 = 0, m = 0, u = 0;
        int mode=0;
        std::vector < std::vector <char> > codes_1;
        std::vector < std::vector <char> > codes_2;
        unsigned int rank_1=0;
        if (n_1 == 1 && t_1 > 6) {
            // обращаемся к файлу нужному
            codes_1.resize(2);
            for (int i = 0; i < 2; i++)

            {
                codes_1[i].resize(1);
            }
            read_file("11", codes_1);
            return codes_1;
        }

        if (n_1 < 6 && t_1 < 6) { //добавить условие для 1 и любыъ t
           // обращаемся к файлу нужному
            codes_1.resize(arr_rang[n_1 - 1][t_1 - 1]);
            for (int i = 0; i < arr_rang[n_1 - 1][t_1 - 1]; i++)

            {
                codes_1[i].resize(n_1);
            }
            std::string a = std::to_string(n_1);
            std::string b = std::to_string(t_1);
            read_file(a+b, codes_1);
            return codes_1;
        }
        mode = 0;
        n_2 = n_1 / 2;
        t_2 = t_1 / 2;
        m = n_1 / 2 + n_1 % 2;
        u = t_1 / 2 + t_1 % 2;
        if (t_1 > 5) { //возможно надо доработать условие
            mode = 0;
            n_2 = n_1 / 2;
            t_2 = t_1 / 2;
            m = n_1 / 2 + n_1 % 2;
            u = t_1 / 2 + t_1 % 2;
        }
        else {
            if (n_1 > 5) {
                mode = 1;

                n_2 = n_1 / 2;
                t_2 = t_1;
                m = n_1 / 2 + n_1 % 2;
                u = t_1;
            }

        }


        codes_1=composition(n_2,t_2); //левая часть
        codes_2=composition(m,u); //правая часть
        unsigned int N = codes_1.size(); //количество кодов
        unsigned int M = codes_2.size(); //количество кодов
        if (mode == 0) {
            if (((M - 1) / u) >= ((N - 1) / t_2))
                rank_1 = N + ((N - 1) / t_2) * u;
            else
                rank_1 = M+t_2+ ((M - 1) / u)*t_2;
            return add_limit(codes_1, codes_2, t_2, u, rank_1);
        }
        else
        {
            rank_1 = M * (N / (t_2 + 1)) + t_2 * (N / (t_2 + 1));
            return  increase_rank(codes_1, codes_2, t_2, u, rank_1);
        }



    }

};