using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Task1
{
    /*
     * class MyStack<T> : IMyStack<T>
    {
        private T[] inner;

        int size;

        public MyStack()
        {
            Inner = new T[10];
        }

        public MyStack(int length)
        {
            Inner = new T[length];
        }

        public T[] Inner { get => inner; set => inner = value; }

        public T Peek()
        {
            if (!isEmpty)
            {
                return this.Inner[size - 1];
            }
            else
            {
                throw new InvalidOperationException();
            }
        }

        public T Pop()
        {
            if (!isEmpty)
            {
                T curr = this.Inner[--size];
                this.Inner[size] = default(T);
                //size--;
                return curr;
            }
            else
            {
                throw new InvalidOperationException();
            }
        }

        public void Push(T item)
        {
            if (Inner.Length == size)
            {
                this.Resize();
            }

            this.Inner[size++] = item;
        }

        void Resize()
        {
            T[] newList = new T[size * 2];
            Array.Copy(this.Inner, newList, size);

            this.Inner = newList;
        }

        public bool isEmpty
        {
            get { return size == 0; }
        }
    }
    */

    public class Node<T>
    {
        T data;

        public Node(T item)
        {
            this.Data = item;
        }

        public T Data { get => data; set => data = value; }

        public Node<T> nextNode { get; set; }
    }

    public class MyStack<T> : IMyStack<T>
    {
        Node<T> head;
        int size;

        T IMyStack<T>.Peek()
        {
            if (!isEmpty)
            {
                return head.Data;
            }
            else
            {
                throw new InvalidOperationException();
            }
        }

        T IMyStack<T>.Pop()
        {
            if (!isEmpty)
            {
                Node<T> currNode = head;
                head = head.nextNode;
                size--;
                return currNode.Data;
            }
            else
            {
                throw new InvalidOperationException();
            }
        }

        void IMyStack<T>.Push(T item)
        {
            size++;
            Node<T> newNode = new Node<T>(item);
            newNode.nextNode = head;
            head = newNode;
        }

        public bool isEmpty
        {
            get { return size == 0; }
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            MyStack<int> myStack = new MyStack<int>();
            Test(myStack);
            Console.ReadKey();
        }

        static void Test(IMyStack<int> stack)
        {
            foreach (var i in Enumerable.Range(0, 9))
            {
                stack.Push(i);
            }
            Console.WriteLine(stack.Pop());
            Console.WriteLine(stack.Peek());
            foreach (int i in Enumerable.Repeat(2, 5))
            {
                stack.Push(i);
            }
            try
            {
                while (true) { Console.WriteLine(stack.Pop()); }
            }
            catch (InvalidOperationException)
            {
                Console.WriteLine("Stack is empty");
            }
        }
    }

    interface IMyStack<T>
    {
        void Push(T item);
        T Pop();
        T Peek();
    }
}