using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices.ComTypes;

namespace Exercise
{
    public class Tree<T> : IEnumerable<T>
    {
        private EnumeratorOrder _order;

        public Tree(T root, EnumeratorOrder enumeratorOrder)
        {
            Value = root;
            Children = new LinkedList<Tree<T>>();
            Order = enumeratorOrder;
        }

        public EnumeratorOrder Order
        {
            get { return _order; }
            set
            {
                if (!(((EnumeratorOrder[])Enum.GetValues(typeof(EnumeratorOrder))).Any(e=>e == value)))
                {
                    throw new ArgumentOutOfRangeException();
                }
                _order = value;
                foreach (var child in Children)
                {
                    child.Order = _order;
                }
            }
        }

        public T Value { get; set; }
        public LinkedList<Tree<T>> Children { get; }

        private void AsDepthFirst(LinkedList<T> num)
        {
            num.AddLast(Value);
            foreach (var child in Children)
            {
                child.AsDepthFirst(num);
            }
        }

        private void AsBreadthFirst(LinkedList<T> num)
        {
            foreach (var child in Children)
            {
                num.AddLast(child.Value);
            }
            foreach (var child in Children)
            {
                child.AsBreadthFirst(num);
            }
        }

        public void Add(T i)
        {
            Children.AddLast(new Tree<T>(i, Order));
        }

        public void Add(Tree<T> subtree)
        {
            Children.AddLast(subtree);
            subtree.Order = Order;
        }

        #region IEnumerable

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        public IEnumerator<T> GetEnumerator()
        {
            var num = new LinkedList<T>();
            switch (Order)
            {
                case EnumeratorOrder.DepthFirstSearch:
                    AsDepthFirst(num);
                    break;
                case EnumeratorOrder.BreadthFirstSearch:
                    num.AddLast(Value);
                    AsBreadthFirst(num);
                    break;
                default:
                    return GetEnumerator();
            }
            return num.GetEnumerator();
        }

        #endregion
    }
}