#include "stdafx.h"
 
#include <stdlib.h>
#include <iostream>
#include <string>
#include <cassert>
 
using namespace std;
 
// class List;
 
class Prvek {
public:
    string name;
    int r, g, b;
    Prvek* prev;
    Prvek* next;
    // List * owner;
 
    Prvek ();
    Prvek (string name0, int r0, int g0, int b0);
    ~ Prvek ();
};
 
Prvek::Prvek () 
    : name (""), r (0), g (0), b (0), prev (nullptr), next (nullptr)
{ }
 
Prvek::Prvek (string name0, int r0, int g0, int b0) :
    name (name0) , r (r0), g (g0), b (b0), prev (nullptr), next (nullptr)
{ }
 
Prvek::~Prvek ()
{ }
 
class List
{
public:
    Prvek* first;
    Prvek* last;
 
    List () : first (nullptr), last (nullptr) {}
    ~List ();
    void InsertLast (Prvek* p);
    void InsertAfter (Prvek * ref, Prvek* p);
    void Check ();
    void Print ();
    Prvek * Search (string name);
    void Remove (Prvek* p);
    void Move (List & target);
    void Rev (List & target);
};
 
struct Mat
{
    double data[10][10];
};
 
Mat a, b, c;
 
void add (Mat & x, Mat & y, Mat & z)
{
    for (int i = 0; i < 10; i++)
        for (int j = 0; j < 10; j++)
            z.data[i][j] = x.data[i][j] + y.data[i][j];
}
 
void mul (Mat  x, Mat   y, Mat & z)
{
    for (int i = 0; i < 10; i++)
        for (int j = 0; j < 10; j++)
        {
            double s = 0;
            for (int k = 0; k < 10; k++)
                s = s + x.data[i][k] + y.data[k][j];
            z.data[i][j] = s;
        }
}
 
void m ()
{
    add (a, b, c); // c := a+b
    mul (a, b, c); // c := a*b
    mul (a, b, a); // a := a*b
}
 
List::~List ()
{
    Prvek * p = first;
    while (p != nullptr)
    {
        Prvek * b = p->next;
        Remove (p);
        delete p;
        p = b;
    }
 
}
 
void List::Move (List & target)
{
    Prvek * p = first;
    while (p != nullptr)
    {
        Prvek * b = p->next;
        Remove (p);
        target.InsertLast (p);
        p = b;
    }
}
void List::Rev (List & target)
{
    Prvek * p = last;
    while (p != nullptr)
    {
        Prvek * b = p->prev;
        Remove (p);
        target.InsertLast (p);
        p = b;
    }
}
 
void List::Remove (Prvek* p)
{
    Prvek* a = p->prev;
    Prvek* b = p->next;
    if (a != nullptr)
        a->next = b;
    else
        first = b;
    if (b != nullptr)
        b->prev = a;
    else
        last = a;
    p->prev = nullptr;
    p->next = nullptr;
}
Prvek * List::Search (string name0)
{
    Prvek * p = first;
    while (p != nullptr && p->name != name0) p = p->next;
    /*
    while (p != nullptr)
     {
        if (p->name == name0)
        {
            break;
        }
        p = p->next;
    }
    */
    return p;
}
 
 
void List::InsertLast (Prvek* p)
{
    if (first == nullptr)
    {
        first = p;
        last = p;
        p->prev = nullptr;
        p->next = nullptr;
    }
    else
    {
        last->next = p;
        p->prev = last;
        last = p;
        p->next = nullptr;
 
    }
}
 
void List::InsertAfter (Prvek * ref, Prvek* p)
{
    Prvek* a = ref->next;
    if (a==nullptr)
        last = p;
    else 
        a->prev = p;
    p->next = a;
    p->prev = ref;
    ref->next = p;
}
 
void List::Print ()
{
    Prvek* p = this->first;
 
    while (p != nullptr)
    {
        cout << p->name << ", " << p->r << ", " << p->g << ", " << p->b;
        cout << endl;  
        p = p->next;
    }
}
 
#include <cassert>
void List::Check ()
{
    if (first == nullptr)
        assert (last == nullptr);
    else
    {
        assert (last != nullptr);
 
        int cnt = 0;
        Prvek* p = first;
        while (p != nullptr)
        {
            cnt++;
            p = p->next;
        }
 
        p = last;
        while (p != nullptr)
        {
            cnt--;
            p = p->prev;
        }
 
        assert (cnt == 0);
    }
}
 
int main ()
{
    cout << "Zacatek" << endl;
    List a;
    a.Check ();
    a.InsertLast (new Prvek ("cervena", 255, 0, 0));
    a.Check ();
    a.InsertLast (new Prvek ("modra", 0, 0, 255));
    a.InsertAfter (a.first, new Prvek ("zluta", 255, 255, 0));
    a.InsertAfter (a.last, new Prvek ("cerna", 0, 0, 0));
    a.Check ();
    a.Print ();
    cout << endl;
    List b;
    a.Rev (b);
    b.Print ();
    /*
    a.Remove (a.first->next);
    a.Remove (a.last);
    a.Remove (a.first);
    // a.Remove (a.last);
    a.Print ();
    */
    system ("pause");
    return 0;
}