﻿using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;

namespace BaSys40.Utils.ModelHandling
{
    public class ObjectTreeBuilder : TreeBuilder<object>
    {
        protected new List<ObjectTreeBuilder> children;
        public ObjectTreeBuilder(string rootObjectName, object rootObjectValue) : this(rootObjectName, new List<object>() { rootObjectValue })
        { }
        public ObjectTreeBuilder(string rootObjectName, List<object> rootObjectValues) : base(rootObjectName, rootObjectValues)
        {
            this.children = new List<ObjectTreeBuilder>();
        }

        public T GetValue<T>()
        {
            if (value != null)
                return (T)value.FirstOrDefault(c => c.GetType().IsSubclassOf(typeof(T)) || c.GetType() == typeof(T));
            else
                return default(T);
        }

        public new ObjectTreeBuilder AddValue(object value)
        {
            this.value.Add(value);
            return this;
        }

        public ObjectTreeBuilder AddChild(ObjectTreeBuilder child)
        {
            child.Parent = this;
            this.children.Add(child);
            return this;
        }

        public new ObjectTreeBuilder AddChild(string name, params object[] value)
        {
            return (AddChild(name, value.ToList()));
        }

        public new ObjectTreeBuilder AddChild(string name, List<object> value)
        {
            var node = new ObjectTreeBuilder(name, value) { Parent = this };
            children.Add(node);
            return node;
        }

        public new ObjectTreeBuilder this[int i]
        {
            get { return children[i]; }
        }
       
        public new ObjectTreeBuilder this[string name]
        {
            get { return children.FirstOrDefault(s => s.Name == name); }
        }

        public new ReadOnlyCollection<ObjectTreeBuilder> Children => children.AsReadOnly();

        public new bool HasChild(string childName)
        {
            if (children == null || children.Count == 0)
                return false;
            else
            {
                var child = children.Find(c => c.Name == childName);
                if (child == null)
                    return false;
                else
                    return true;
            }
        }

        public new bool HasChildPath(string childPath)
        {
            if (string.IsNullOrEmpty(childPath))
                return false;

            if (children == null || children.Count == 0)
                return false;
            else
            {
                if (childPath.Contains("/"))
                {
                    string[] splittedPath = childPath.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
                    if (!HasChild(splittedPath[0]))
                        return false;
                    else
                    {
                        var child = this[splittedPath[0]];
                        return (child.HasChildPath(string.Join("/", splittedPath.Skip(1))));
                    }
                }
                else
                    return HasChild(childPath);
            }
        }

        public new ObjectTreeBuilder GetChild(string childPath)
        {
            if (string.IsNullOrEmpty(childPath))
                return null;

            if (children == null || children.Count == 0)
                return null;
            else
            {
                ObjectTreeBuilder superChild = null;
                if (childPath.Contains("/"))
                {
                    string[] splittedPath = childPath.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
                    if (!HasChild(splittedPath[0]))
                        return null;
                    else
                    {
                        var child = this[splittedPath[0]];
                        superChild = child.GetChild(string.Join("/", splittedPath.Skip(1)));
                    }
                }
                else
                    superChild = this[childPath];

                return superChild;
            }
        }

        public new bool HasChildren()
        {
            if (children == null)
                return false;
            else
            {
                if (children.Count == 0)
                    return false;
                else
                    return true;
            }
        }

       

        public new void Traverse(Action<List<object>> action)
        {
            action(Value);
            foreach (var child in children)
                child.Traverse(action);
        }
    }
    public class TreeBuilder<T>
    {
        protected List<T> value;
        protected List<TreeBuilder<T>> children;
        public TreeBuilder<T> Parent { get; protected set; }
        public List<T> Value { get { return value; } }
        public string Name { get; protected set; }

        public TreeBuilder(string name, T data) : this (name, new List<T>() { data })
        { }

        public TreeBuilder(string name, List<T> data)
        {
            this.Name = name;
            this.value = data;
            this.children = new List<TreeBuilder<T>>();
        }

        public ReadOnlyCollection<TreeBuilder<T>> Children
        {
            get { return children.AsReadOnly(); }
        }

        public TreeBuilder<T> AddValue(T value)
        {
            this.value.Add(value);
            return this;
        } 

        public TreeBuilder<T> this[int i]
        {
            get { return children[i]; }
        }

        public TreeBuilder<T> this[string name]
        {
            get { return children.FirstOrDefault(s => s.Name == name); }
        }

        public void Traverse(Action<List<T>> action)
        {
            action(Value);
            foreach (var child in children)
                child.Traverse(action);
        }

        #region Child-Operations
        public TreeBuilder<T> AddChild(TreeBuilder<T> child)
        {
            child.Parent = this;
            this.children.Add(child);
            return this;
        }

        public TreeBuilder<T> AddChild(string name, params T[] value)
        {
            return (AddChild(name, value.ToList()));
        }

        public TreeBuilder<T> AddChild(string name, List<T> value)
        {
            var node = new TreeBuilder<T>(name, value) { Parent = this };
            children.Add(node);
            return node;
        }
        public bool HasChildPath(string childPath)
        {
            if (string.IsNullOrEmpty(childPath))
                return false;

            if (children == null || children.Count == 0)
                return false;
            else
            {
                if (childPath.Contains("/"))
                {
                    string[] splittedPath = childPath.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
                    if (!HasChild(splittedPath[0]))
                        return false;
                    else
                    {
                        var child = this[splittedPath[0]];
                        return (child.HasChildPath(string.Join("/", splittedPath.Skip(1))));
                    }
                }
                else
                    return HasChild(childPath);
            }
        }
        public bool HasChildren()
        {
            if (children == null)
                return false;
            else
            {
                if (children.Count == 0)
                    return false;
                else
                    return true;
            }
        }
        public bool HasChild(string childName)
        {
            if (children == null || children.Count == 0)
                return false;
            else
            {
                var child = children.Find(c => c.Name == childName);
                if (child == null)
                    return false;
                else
                    return true;
            }
        }

        public TreeBuilder<T> GetChild(string childPath)
        {
            if (string.IsNullOrEmpty(childPath))
                return null;

            if (children == null || children.Count == 0)
                return null;
            else
            {
                TreeBuilder<T> superChild = null;
                if (childPath.Contains("/"))
                {
                    string[] splittedPath = childPath.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
                    if (!HasChild(splittedPath[0]))
                        return null;
                    else
                    {
                        var child = this[splittedPath[0]];
                        superChild = child.GetChild(string.Join("/", splittedPath.Skip(1)));
                    }
                }
                else
                    superChild = this[childPath];

                return superChild;
            }
        }
        #endregion
    }
}