#include <iostream>
#include <random>
#include <algorithm>
#include <array>
#include <numeric>
#include <list>
#include <string>

const size_t CARDS_COUNT = 250;
const size_t DIGITS_COUNT = 16;

const size_t BUCKET_SIZE = 4;
const size_t BUCKETS_PER_CARD = DIGITS_COUNT / BUCKET_SIZE;

typedef std::array<int, DIGITS_COUNT> CardDigits;
typedef std::array<int, BUCKET_SIZE> CardBucket;

typedef std::vector<CardBucket> CardsVector;

CardsVector generate_cards()
{
    CardsVector digits;

    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<int> dist(0, 9);

    for (size_t i = 0; i < CARDS_COUNT * BUCKETS_PER_CARD; ++i)
    {
        digits.push_back(CardBucket());
        for (size_t j = 0; j < BUCKET_SIZE; ++j)
            digits.back()[j] = dist(gen);
    }

    return digits;
}

CardDigits get_card_digits(CardsVector::const_iterator first)
{
    std::array<int, DIGITS_COUNT> digits;

    for (size_t i = 0; i < BUCKETS_PER_CARD; ++i, ++first)
        for (size_t j = 0; j < BUCKET_SIZE; ++j)
            digits[i * BUCKET_SIZE + j] = first->at(j);

    return digits;
}

bool is_valid_card(CardDigits digits)
{
    for (size_t i = 0; i < DIGITS_COUNT; i += 2)
        if (digits[i] *= 2 > 9)
            digits[i] -= 9;

    return std::accumulate(digits.begin(), digits.end(), 0) % 10 == 0;
}

void part2_print_valid(CardsVector& vecArr)
{
    for (size_t i = 0; i < vecArr.size();)
    {
        CardsVector::const_iterator begin = vecArr.begin() + i;

        CardDigits card = get_card_digits(begin);

        if (is_valid_card(card))
        {
            std::cout << "card #" << i / BUCKETS_PER_CARD << "\t<";
            for (int digit : card)
                std::cout << digit;
            std::cout << "> - Ok\n";

            vecArr.erase(begin, begin + BUCKETS_PER_CARD);
        }
        else
            i += BUCKETS_PER_CARD;
    }

    std::cout << "Total number of fake cards equals to " << vecArr.size() / BUCKETS_PER_CARD << '\n';
}

void part3_sort_and_print(CardsVector& vecArr)
{
    std::sort(vecArr.begin(), vecArr.end(), [](const CardBucket& left, const CardBucket& right)
    {
        return std::accumulate(left.begin(), left.end(), 0) < std::accumulate(right.begin(), right.end(), 0);
    });

    const size_t DISPLAY_ITEMS_COUNT = 7;
    if (vecArr.size() < DISPLAY_ITEMS_COUNT)
        std::cout << "VecArr size is less than " << DISPLAY_ITEMS_COUNT << '\n';
    else
    {

        for (size_t i = 0; i < DISPLAY_ITEMS_COUNT; ++i)
        {
            std::cout << "VecArr[" << i << "]\t<";
            for (int digit : vecArr[i])
                std::cout << digit;
            std::cout << ">\n";
        }

        std::cout << "... ... ...\n";

        for (size_t i = vecArr.size() - DISPLAY_ITEMS_COUNT; i < vecArr.size(); ++i)
        {
            std::cout << "VecArr[" << i << "]\t<";
            for (int digit : vecArr[i])
                std::cout << digit;
            std::cout << ">\n";
        }
    }
}

void part4_clear(CardsVector& vecArr)
{
    vecArr.clear();
    vecArr.shrink_to_fit();
}

void part5_list_and_move()
{
    const char indicator = '*';

    std::list<std::string> ListStr1{ "re*pr*esentative", "operati*o*n", "re*gr*et", "ex*am*ple", "lim*It*" };
    std::list<std::string> ListStr2;

    while (!ListStr1.empty())
    {
        std::string& s = ListStr1.front();

        size_t begin = s.find(indicator) + 1;
        size_t end = s.rfind(indicator);

        s = s.substr(begin, end - begin);

        ListStr2.splice(ListStr2.begin(), ListStr1, ListStr1.begin());
    }

    std::cout << "Part 5 - moving from ListStr1 to ListStr2\nListStr1: (size = 0)\nListStr2: ";
    for (std::string& s : ListStr2)
        std::cout << s;
    std::cout << " (size = " << ListStr2.size() << ")\n";
}

int main()
{
    CardsVector vecArr = generate_cards();
    std::cout << "Part 1 - all elements of VecArr got the values\n";

    std::cout << "Part 2 - valid card numbers\n";
    part2_print_valid(vecArr);

    std::cout << "Part 3 - sorted vector\n";
    part3_sort_and_print(vecArr);

    part4_clear(vecArr);
    std::cout << "Part 4 - the current size of VecArr[] equals to <" << vecArr.size() << ">\n";

    part5_list_and_move();

    std::cout.flush();

    system("pause");
}