#include <bits/stdc++.h>

using namespace std;

void create_ring();
int read_single_number();
long* read_n_elements(int n);
void add_elements();
void delete_elements_from_start();
void delete_every_k_element();
void show_start_message();
void run();
void show_input_message();
bool confirm_exit();
void print_ring();
bool is_created();
void show_not_created_message();
void show_add_elements_message(int _count);
void add_element(int value);
int read_positive_number();
void show_delete_error_message();

struct Node
{
    int value;
    Node* next;

    Node(int _value)
    {
        value = _value;
    }

    Node(int _value, Node* _next)
    {
        value = _value;
        next = _next;
    }
};

struct Ring
{
    Node* start_node;

    void add(int value)
    {
        if(start_node == nullptr)
        {
            start_node = new Node(value);
            start_node -> next = start_node;
        }
        else
        {
            add(start_node, value);
        }
    }

    void add(Node* parent, int value)
    {
        if(parent -> next == start_node)
        {
            Node* node = new Node(value);
            parent -> next = node;
            node -> next = start_node;
        }
        else
        {
            add(parent -> next, value);
        }
    }

    void delete_elements_from_start(int _count)
    {
        delete_node(start_node, _count);
    }

    void delete_node(Node* node, int remain)
    {
        if(remain == 0)
        {
            Node* node = start_node;
            start_node = node -> next;
            delete node;
        }
        else
        {
            remain--;
            delete_node(node -> next, remain);
        }
    }

    void delete_every_k_element(int _count, int k)
    {
        Node* current_node = start_node;
        while(_count != 0)
        {
            for(int i = 0; i < k; i ++)
            {
                current_node = current_node -> next;
            }
            current_node = current_node -> next;
            _count--;
        }
    }

    void print_self()
    {
        if(start_node != nullptr)
        {
            cout << "The content of ring is: " << endl;
            cout << start_node -> value << endl;

            Node* current_node = start_node;
            while(current_node -> next != start_node)
            {
                current_node = current_node -> next;
                cout << current_node -> value << endl;
            }
        }
        else
        {
               cout << "The ring is empty" << endl;
        }
    }

    Ring()
    {
        start_node = nullptr;
    }
};


Ring *ring = nullptr;

int main()
{
    show_start_message();
    run();
}

void run()
{
    bool is_running = true;
    while(is_running)
    {
        show_input_message();
        char c = getchar();
        switch(c)
        {
            case 'a':
                    add_elements();
                    cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    break;
            case 'c':
                    create_ring();
                    cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    break;
            case 'd':
                    delete_elements_from_start();
                    cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    break;
            case 'k':
                    delete_every_k_element();
                    cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    break;
            case 'v':
                    print_ring();
                    cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    break;
            default:
                    cout << "Unknown action\n";
                    cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    break;
            case 'x':
                    bool is_exiting = confirm_exit();
                    is_running = !is_exiting;
                    break;
        }
    }
}

void create_ring()
{
    if(ring == nullptr)
    {
        ring = new Ring();
        cout << "Ring successfully created" << endl;
    }
    else
    {
        cout << "Ring already created" << endl;
    }
}

void add_elements()
{
    if(!is_created())
    {
        show_not_created_message();
    }
    else
    {
        cout << "Enter N. N must be positive" << endl;
        int n = read_positive_number();
        show_add_elements_message(n);
        for(int i = 0; i < n; i++)
        {
            int value = read_single_number();
            ring -> add(value);
        }
    }
}

void delete_elements_from_start()
{
    if(!is_created())
    {
        show_not_created_message();
    }
    else
    {
        cout << "Enter M. M must be positive" << endl;
        int m = read_positive_number();

        if(ring -> start_node != nullptr)
        {
            show_delete_error_message();
        }
        ring -> delete_elements_from_start(m);
    }
}

void delete_every_k_element()
{
    if(!is_created())
    {
        show_not_created_message();
    }
    else
    {
        cout << "Enter M. M must be positive" << endl;
        int m = read_positive_number();

        cout << "Enter M. M must be positive" << endl;
        int k = read_positive_number();

        if(ring -> start_node != nullptr)
        {
            show_delete_error_message();
        }
        ring -> delete_every_k_element(m, k);
    }
}

void print_ring()
{
    if(!is_created())
    {
        show_not_created_message();
    }
    else
    {
        ring -> print_self();
    }
}

int read_single_number()
{
    string line;
    int number = -1;
    cin >> line;
    stringstream string_stream(line);
    string_stream >> number;
    return number;
}

int read_positive_number()
{
    bool is_valid = false;
    int number = -1;
    while(!is_valid)
    {
        number = read_single_number();
        is_valid = (number > 0);
    }
    return number;
}

bool is_created()
{
    bool is_created = (ring != nullptr);
    return is_created;
}

bool confirm_exit()
{
    cout << "Are you sure want to exit? Print y if so, n otherwise.\n";
    cin.ignore(numeric_limits<streamsize>::max(), '\n');
    char c = getchar();
    bool is_exit = (c == 'y');
    return is_exit;
}

void show_start_message()
{
    cout << "This program allows you to create empty ring, add elements, delete elements from first node, delete every k element, view elements\n";
}

void show_input_message()
{
    cout << "\nChoose what to do:\n";
    cout << "a - add new records\n";
    cout << "c - create ring\n";
    cout << "d - delete elements from start\n";
    cout << "k - delete every k element\n";
    cout << "v - view elements\n";
    cout << "x - exit\n";
}

void show_delete_error_message()
{
    cout << "Cannot perform action. M is greater than ring size" << endl;
}

void show_add_elements_message(int _count)
{
    cout << "Enter " << _count << " elements. Each element must be positive. Each element must be on a new line." << endl;
}

void show_not_created_message()
{
    cout << "Error! Cannot perform action: ring isn't created yet." << endl;
}