using System;
using System.Collections;
using System.Collections.Generic;

namespace Clones
{
	public class CloneVersionSystem : ICloneVersionSystem
	{
        public class StackItem
        {
            public int Value { get; set; }
            public StackItem Next { get; set; }
        }

        public class Stack
        {
            public StackItem head = null;

            public Stack()
            {
                head = null;
            }

            public Stack(Stack programs)
            {
                head = programs.head;
            }

            public bool IsEmpty()
            {
                return head == null;
            }

            public int Peek()
            {
                return head.Value;
            }

            public void Push(int value)
            {
                head = new StackItem { Value = value, Next = head };
            }

            public int Pop()
            {
                if (head == null) throw new InvalidOperationException();
                var result = head.Value;
                head = head.Next;

                return result;
            }
        }

        public class Clones
        {
            Stack learnedPrograms = new Stack();
            Stack canceledPrograms = new Stack();

            public string Learn(int numberOfProgram)
            {
                learnedPrograms.Push(numberOfProgram);
                canceledPrograms.head = null;

                return null;
            }

            public string Rollback()
            {
                canceledPrograms.Push(learnedPrograms.Pop());

                return null;
            }

            public string Relearn()
            {
                learnedPrograms.Push(canceledPrograms.Pop());

                return null;
            }

            public Clones Clone()
            {
                var newClone = new Clones
                {
                    learnedPrograms = new Stack { head = learnedPrograms.head },
                    canceledPrograms = new Stack { head = canceledPrograms.head }
                };

                return newClone;
            }

            public string Check()
            {
                if (learnedPrograms.IsEmpty())
                    return "basic";

                return learnedPrograms.Peek().ToString();
            }
        }

        List<Clones> cloneList = new List<Clones>();
        public CloneVersionSystem()
        {
            cloneList.Add(new Clones());
        }

        public string Execute(string query)
        {
            var parts = query.Split(' ');
            var cloneNumber = int.Parse(parts[1]);
            switch (parts[0])
            {
                case "learn":
                    var programNumber = int.Parse(parts[2]);
                    cloneList[cloneNumber - 1].Learn(programNumber);
                    break;
                case "rollback":
                    cloneList[cloneNumber - 1].Rollback();
                    break;
                case "relearn":
                    cloneList[cloneNumber - 1].Relearn();
                    break;
                case "clone":
                    cloneList.Add(cloneList[cloneNumber - 1].Clone());
                    break;
                case "check":
                    return cloneList[cloneNumber - 1].Check();
            }

            return null;
        }
    }
}