using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Xml;
using System.Xml.Linq;

namespace StgSharp.Data
{
    public partial class HuffmanTree<T> where T : struct
    {
        HuffmanNodeList<T> leaves;

        public TreeNode<T> Root
        {
            get => leaves.Last;
        }

        public HuffmanNodeList<T> LeafList
        {
            get => leaves;
        }

        internal HuffmanTree(HuffmanNodeList<T> nodeList)
        {
            leaves = nodeList;
        }

        public static HuffmanTree<T> BuildHuffmanTree(List<(T, ulong)> metaData)
        {
            if (metaData.Count<=3)
            {
                throw new Exception("Data is too little, no need to compress");
            }
            HuffmanNodeList<T> leaves = new HuffmanNodeList<T>();
            HuffmanNodeList<T> all = new HuffmanNodeList<T>();

            foreach (var item in metaData)
            {
                leaves.Add(new TreeNode<T>(item));
            }

            int count = 0;

            while (leaves.Count >2)
            {
                TreeNode<T> node, toMove;
                if (leaves.Last._frequency < leaves.BeforeLast._frequency)
                {
                    if (leaves.BeforeLast._frequency < leaves.OverLast._frequency)
                    {
                        //第三节点最大
                        node = new TreeNode<T>(leaves.BeforeLast, leaves.Last);
                        toMove = leaves.RemoveAndGetLast; all.Add(toMove);
                        toMove = leaves.RemoveAndGetLast; all.Add(toMove);
                        leaves.Add(node);
                    }
                    else
                    {
                        //第二节点最大
                        node = leaves.Last._frequency < leaves.OverLast._frequency ?
                            new TreeNode<T>(leaves.OverLast, leaves.Last) :
                            new TreeNode<T>(leaves.Last, leaves.OverLast);
                        toMove = leaves.RemoveAndGetLast; all.Add(toMove);
                        toMove = leaves.RemoveAndGetBeforeLast; all.Add(toMove);
                        leaves.Add(node);
                    }
                }
                else
                {

                    if (leaves.Last._frequency < leaves.OverLast._frequency)
                    {
                        //第三节点最大
                        node = new TreeNode<T>(leaves.Last, leaves.BeforeLast);
                        toMove = leaves.RemoveAndGetLast; all.Add(toMove);
                        toMove = leaves.RemoveAndGetLast; all.Add(toMove);
                        leaves.Add(node);
                    }
                    else
                    {
                        //第一节点最大
                        node = leaves.BeforeLast._frequency < leaves.OverLast._frequency?
                            new TreeNode<T>(leaves.OverLast, leaves.BeforeLast):
                            new TreeNode<T>(leaves.BeforeLast, leaves.OverLast);
                        toMove = leaves.RemoveAndGetBeforeLast; all.Add(toMove);
                        toMove = leaves.RemoveAndGetBeforeLast; all.Add(toMove);
                        leaves.Add(node);
                    }
                }

                leaves = new HuffmanNodeList<T>( leaves.OrderByDescending(pair => pair.frequency)
                    .Select(pair => pair).ToList());
            }

            TreeNode<T> lastOne = leaves[0];
            TreeNode<T> lastTwo = leaves[1];
            TreeNode<T> root = lastOne.frequency>lastTwo.frequency?
                new TreeNode<T>(lastOne,lastTwo):
                new TreeNode<T>(lastTwo, lastOne);

            all.Add(lastOne);
            all.Add(lastTwo);
            all.Add(root);

            leaves = all;
            return new HuffmanTree<T>(all);
        }


    }

    public class HuffmanNodeList<T> : List<TreeNode<T>> where T : struct
    {
        public HuffmanNodeList():base()
        {
            
        }

        public HuffmanNodeList(IEnumerable<TreeNode<T>> values):base(values)
        {}

        public void Add(T element, ulong f)
        {
            base.Add(new TreeNode<T>(element,f));
        }

        public TreeNode<T> Last
        {
            get => this[Count-1 ];
        }

        public TreeNode<T> RemoveAndGetLast
        {
            get 
            {
                TreeNode<T> ret = this[Count-1];
                RemoveAt(Count-1);
                return ret;
            }
        }

        public TreeNode<T> BeforeLast
        {
            get => this[Count - 2];
        }

        public TreeNode<T> RemoveAndGetBeforeLast
        {
            get
            {
                TreeNode<T> ret = this[Count - 2];
                RemoveAt(Count - 2);
                return ret;
            }
        }

        public TreeNode<T> OverLast
        {
            get => this[Count - 3];
        }

        public TreeNode<T> RemoveAndGetOverLast
        {
            get
            {
                TreeNode<T> ret = this[Count - 3];
                RemoveAt(Count - 3);
                return ret;
            }
        }

    }

    public class TreeNode<T> where T: struct
    {
        internal TreeNode<T> _left;
        internal TreeNode<T> _right;
        internal T? _value;
        internal ulong _frequency;

        public ulong frequency => _frequency;

        public T? Value => _value;

        public TreeNode<T> Left => _left;
        public TreeNode<T> Right => _right;

        public TreeNode( T? value, ulong frequncy)
        {
            _value = value;
            _frequency = frequncy;

        }

        internal TreeNode(TreeNode<T> left, TreeNode<T> right)
        {
            _left = left;
            _right = right;
            _value = null;
            _frequency = left._frequency + right._frequency;
        }

        public TreeNode((T, ulong) data)
        {
            _value = data.Item1;
            _frequency = data.Item2;

        }
    }
}