//
//  tricky_number.h
//

#ifndef TRICKY_NUMBER_H
#define TRICKY_NUMBER_H

#include <iostream>
#include <string>
#include <vector>
#include <fstream>
#include <stdlib.h>
#include <cstring>


using namespace std;

//===============================
//
class alphabet
{
    public:
        vector<string> alphabet;
};
//===============================
//
class digit
{
    public:
        size_t value;
        alphabet alphabet_digit;
        digit(size_t ini) { value = ini; }
};
//===============================

class tricky_number
{
    public:
        vector<digit> num;
        string output_file_name;
        unsigned __int64 i;
        unsigned __int64 max_i;
        size_t current_thread;
        size_t max_thread;
        size_t work;

        tricky_number();
        virtual ~tricky_number();

        void ini_alphabet(size_t par_max);
        void ini(size_t min, size_t max, size_t current_thread, size_t max_thread, string output_file_name);
        void run();


    protected:
        void out_num(ofstream *file);
        void print_num();
        void add_num();
        void dec_to_tricky_number(unsigned __int64 dec);
        unsigned __int64 pow(unsigned __int64 base, size_t exponent);

    private:

};

#endif // TRICKY_NUMBER_H

//
//  main.cpp
//

#include <iostream>
#include <string>
#include <vector>
#include <windows.h>
#include <process.h>

#include "tricky_number.h"

using namespace std;

vector<string> sym_set;

string alpha        = "abcdefghijklmnopqrstuvwxyz";
string upper        = "ABCDEFGHIJLKMNOPQRSTUVWXWY";
string xdigits      = "0123456789ABCDEF";
string digits       = "0123456789";
string punct        = "!@#$%^&*()-=_+,./?~`\\|";

vector<tricky_number> nums;

tricky_number *threads[256]; // максимум 256 потоков

size_t min_len = 6;
size_t max_len = 6;

//////////////////////////////////////////
void string_to_vector(vector<string> *vec, const string &str)
{
    for(size_t i=0; i < str.size(); i++)
    {
        vec->push_back(string(1,str[i]));
    }
}
//////////////////////////////////////////
// запуск потока
void Run(void * i)
{
    threads[(int)i]->run();
}
//////////////////////////////////////////
int main(int argc,char **arg, char **env)
{
    // работаем в 3 потока
    nums.resize(3);

    // определяем алфавит для каждого разряда
    for(size_t i=0; i < nums.size(); i++)
        nums[i].ini_alphabet(max_len);

    sym_set.clear();
    string_to_vector(&sym_set, alpha);
    for(size_t k=0; k < nums.size(); k++)
        for(size_t i = 0, max_i = nums[k].num.size(); i < max_i; i++)
            nums[k].num[i].alphabet_digit.alphabet = sym_set;

    // определяем параметры
    for(size_t i=0; i < nums.size(); i++)
        nums[i].ini(min_len, max_len, i+1, nums.size(), "out_");

    // запускаем потоки
    for(size_t i=0; i < nums.size(); i++)
    {
        threads[i] = &nums[i];
        _beginthread( Run, 10000, (void *) i );

    }

    // ждем завершения потоков
    size_t work;
    do
    {
        Sleep(100);
        work = 0;
        for(size_t i=0; i < nums.size(); i++)
            work += nums[i].work;

    }while(work);

    return 0;
}
//////////////////////////////////////////


//
//  tricky_number.cpp
//

#include "tricky_number.h"

//////////////////////////////////////////
tricky_number::tricky_number()
{
    //
}
//////////////////////////////////////////
tricky_number::~tricky_number()
{
    //
}
//////////////////////////////////////////
// увеличиваем "хитрое" число на 1
void tricky_number::add_num()
{
    size_t i = 0;
    bool carry = false;

    do{
        num[i].value++;
        if(num[i].value > num[i].alphabet_digit.alphabet.size())
        {
            num[i].value = 1;
            carry = true;
        }
        else
        {
            carry = false;
        }

        i++;
    }while(carry);
}
//////////////////////////////////////////
void tricky_number::print_num()
{
    char str[256];
    str[0]=0;

    size_t i = 0;
    while(num[i].value && num.size() > i)
    {
        strcat(str, num[i].alphabet_digit.alphabet[num[i].value - 1].c_str());
        i++;
    }

    strcat(str,"\r\n");

    cout << str << endl;

}
//////////////////////////////////////////
// вывод в файл
void tricky_number::out_num(ofstream *file)
{
    string str;

    size_t i = 0;
    while(num[i].value)
    {
        str += num[i].alphabet_digit.alphabet[num[i].value - 1];
        i++;
    }

    str+="\r\n";

    file->write(str.c_str(),str.size());
}
//////////////////////////////////////////
void tricky_number::ini_alphabet(size_t par_max)
{
    num.resize( par_max + 1, 0);
}
//////////////////////////////////////////
unsigned __int64 tricky_number::pow(unsigned __int64 base, size_t exponent)
{
    __int64 rez = 1;

    for(size_t i = 0; i < exponent; i++)
        rez*=base;

    return rez;
}
//////////////////////////////////////////
void tricky_number::ini(size_t par_min, size_t par_max, size_t par_current_thread, size_t par_max_thread, string par_output_file_name)
{
    work = 0;

    char number[256];
    itoa(par_current_thread, number, 10);

    output_file_name = par_output_file_name + number + ".lst";
    current_thread = par_current_thread;
    max_thread = par_max_thread;

    // выводим чило в цикле
    // while(i < max_i) ВыводЧисла();
    // рассчитываем i и max_i  в зависимости от par_min, par_max
    i = 0;
    for(int k=0; k < par_min-1; k++)
        i += pow(num[k].alphabet_digit.alphabet.size(), k+1);

    max_i = 0;
    for(size_t i=0; i < par_max; i++)
        max_i += pow(num[i].alphabet_digit.alphabet.size(), i+1);

    //cout << "min = " << i << endl;
    //cout << "max = " << max_i << endl;

    // Корректируем i и max_i в зависимости от текущего потока
    unsigned __int64 delta = (max_i - i) / max_thread + 1;
    unsigned __int64 add = i;
    if( ((current_thread - 1)*delta + add) > max_i)
        i = max_i;
    else
        i = (current_thread - 1)*delta + add;

    if( ((current_thread - 1)*delta + delta + add + 1) < max_i )
        max_i = (current_thread - 1)*delta + delta + add + 1;

    //cout << "min = " << i << endl;
    //cout << "max = " << max_i << endl;

    dec_to_tricky_number(i + 1); //устанавливаем "хитрое" число
    //print_num();
    cout << endl;
}
//////////////////////////////////////////
void tricky_number::run()
{
    work = 1;

    ofstream outfile(output_file_name.c_str(), std::ofstream::binary);
    cout << "Start: " << output_file_name << endl;

    while(i < max_i)
    {
        out_num(&outfile);
        add_num();

        i++;
    }

    cout << "End: " << output_file_name << endl;
    //print_num();

    outfile.close();
    work = 0;
}
//////////////////////////////////////////
void tricky_number::dec_to_tricky_number(unsigned __int64 dec)
{
    size_t k=0;

    do
    {
        num[k].value = (dec % num[k].alphabet_digit.alphabet.size());
        dec /= num[k].alphabet_digit.alphabet.size();
        k++;

    }while(dec);
}
//////////////////////////////////////////