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 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 Dictionary<T, HuffmanKey<T>> BuildHuffmanDictionary()
        {
            Dictionary<T, HuffmanKey<T>> ret = new Dictionary<T, HuffmanKey<T>>();
            TreeNode<T> root = Root;
            HuffmanKey<T> key = new HuffmanKey<T>();
            key = key.SetSide(KeySide.Right);
            InternalBuildDictionary(ret, root, key);
            return ret;
        }

        public void InternalBuildDictionary(
            Dictionary<T, HuffmanKey<T>> dict,
            TreeNode<T> node,
            HuffmanKey<T> valueTemp
            )
        {
            valueTemp.AddIndexLevel();
            //检查左节点
            if (node._left.Value==null)
            {
                //左节点不是叶子节点，继续搜索
                InternalBuildDictionary(
                    dict,
                    node._left,
                    valueTemp.SetSide(KeySide.Left));
            }
            else
            {
                //左节点是叶子节点，添加值
                dict.Add(node._left.Value.Value,valueTemp.SetSide(KeySide.Left));
            }
            //检查右节点
            if (node._right.Value == null)
            {
                //右节点不是叶子节点，继续搜索
                InternalBuildDictionary(
                    dict,
                    node._right,
                    valueTemp.SetSide(KeySide.Left));
            }
            else
            {
                //右节点是叶子节点，添加值
                dict.TryAdd(node._right.Value.Value, valueTemp.SetSide(KeySide.Right));
            }
            //这里检查自己是不是叶子节点
            //但是上面已经检查过了，不需要被检查
        }
    }

    public struct HuffmanKey<T>where T : struct
    {
        internal T value;

        public T Value
        {
            get { return value; }
        }

        internal HuffmanKey(T value)
        {
            this.value= value;
        }

        public unsafe HuffmanKey<T> SetSide(KeySide side)
        {
            HuffmanKey<T> ret = new HuffmanKey<T>(value);
            T* p = &ret.value;
            switch (side)
            {
                case KeySide.Left:
                        byte* ptrLeft = (byte*)p;
                    *ptrLeft &= 0xfe;
                    break;
                case KeySide.Right:
                        byte* ptrRight = (byte*)p;
                    *ptrRight |= 1;
                        break;
                default:
                    break;
            }
            Console.WriteLine(*(byte*)p);
            return ret;
        }

        public unsafe void AddIndexLevel()
        {
            fixed (T* p = &value)
            {
                switch (Marshal.SizeOf<T>())
                {
                    case 1:
                        *(byte*)p <<= 1;
                        break;
                    case 2:
                        *(ushort*)p <<= 1;
                        break;
                    case 4:
                        *(uint*)p <<= 1;
                        break;
                    case 8:
                        *(ulong*)p <<= 1;
                        break;
                    case 16:
#if NET7_0_OR_GREATER
                        *(UInt128*)p <<= 1;
#else
                        ulong* hp = (ulong*)p;
                        if (*hp != 0)
                        {
                            *hp <<= 1;
                        }
                        *hp += ((*(ulong*)p) & 0x80_00_00_00_00_00_00_00) == 0 ? (ulong)0 : 1;
                        *(ulong*)p <<= 1;
#endif
                        break;
                    default:
                        break;
                }
            }
        }
        
        public bool IsSupported
        {
            get 
            {
                return
                    typeof(T) == typeof(byte) ||
                    typeof(T) == typeof(uint) ||
                    typeof(T) == typeof(ushort) ||
                    typeof(T) == typeof(ulong) ||
#if NET7_0_OR_GREATER
                    typeof(T) == typeof(UInt128) ||
#endif
                    typeof(T) == typeof(M128);
            }
        }
    }

    public enum KeySide
    {
        Left,
        Right
    }

    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;

        }
    }
}