using DotNext;

namespace Common
{
    /// <summary>
    /// 数字处理工具
    /// </summary>
    public class Number
    {
        /// <summary>
        /// 整数转成二进制字节数组
        /// </summary>
        /// <param name="num">整数</param>
        /// <param name="length">整数长度</param>
        /// <param name="isRightHigh">是否高位在右边</param>
        /// <returns>二进制字节数组</returns>
        public static Result<byte[]> NumberToBytes(ulong num, uint length, bool isRightHigh = false)
        {
            if (length > 8)
            {
                return new(new ArgumentException(
                    "Unsigned long number can't over 8 bytes(64 bits).",
                    nameof(length)
                ));
            }

            var arr = new byte[length];

            if (isRightHigh)
            {
                for (var i = 0; i < length; i++)
                {
                    arr[length - 1 - i] = Convert.ToByte((num >> (i << 3)) & (0xFF));
                }
            }
            else
            {
                for (var i = 0; i < length; i++)
                {
                    arr[i] = Convert.ToByte((num >> ((int)(length - 1 - i) << 3)) & (0xFF));
                }
            }
            return arr;
        }

        /// <summary>
        /// 二进制字节数组转成整数
        /// </summary>
        /// <param name="bytes">二进制字节数组</param>
        /// <param name="isRightHigh">是否高位在右边</param>
        /// <returns>整数</returns>
        public static Result<ulong> BytesToNumber(byte[] bytes, bool isRightHigh = false)
        {
            if (bytes.Length > 8)
            {
                return new(new ArgumentException(
                    "Unsigned long number can't over 8 bytes(64 bits).",
                    nameof(bytes)
                ));
            }

            ulong num = 0;
            int len = bytes.Length;

            if (isRightHigh)
            {
                for (var i = 0; i < len; i++)
                {
                    num += Convert.ToUInt64((UInt64)bytes[len - 1 - i] << (i << 3));
                }
            }
            else
            {
                for (var i = 0; i < len; i++)
                {
                    num += Convert.ToUInt64((UInt64)bytes[i] << ((int)(len - 1 - i) << 3));
                }
            }

            return num;
        }



        /// <summary>
        /// 比特合并成二进制字节
        /// </summary>
        /// <param name="bits1">第一个比特值</param>
        /// <param name="bits1Len">第一个比特值的长度（位数）</param>
        /// <param name="bits2">第二个比特值</param>
        /// <param name="bits2Len">第二个比特值的长度（位数）</param>
        /// <returns>合并后的二进制字节数组</returns>
        public static Result<byte[]> MultiBitsToBytes(ulong bits1, uint bits1Len, ulong bits2, uint bits2Len)
        {
            return NumberToBytes(MultiBitsToNumber(bits1, bits1Len, bits2, bits2Len).Value,
                        (bits1Len + bits2Len) % 8 != 0 ? (bits1Len + bits2Len) / 8 + 1 : (bits1Len + bits2Len) / 8);
        }

        /// <summary>
        /// 比特合并成整型
        /// </summary>
        /// <param name="bits1">第一个比特值</param>
        /// <param name="bits1Len">第一个比特值的长度（位数）</param>
        /// <param name="bits2">第二个比特值</param>
        /// <param name="bits2Len">第二个比特值的长度（位数）</param>
        /// <returns>合并后的整型值</returns>
        public static Result<ulong> MultiBitsToNumber(ulong bits1, uint bits1Len, ulong bits2, uint bits2Len)
        {
            if (bits1Len + bits2Len > 64) return new(new ArgumentException("Two Bits is more than 64 bits"));

            ulong num = (bits1 << Convert.ToInt32(bits2Len)) | bits2;
            return num;
        }

        /// <summary>
        /// 比特合并成整型
        /// </summary>
        /// <param name="bits1">第一个比特值</param>
        /// <param name="bits1Len">第一个比特值的长度（位数）</param>
        /// <param name="bits2">第二个比特值</param>
        /// <param name="bits2Len">第二个比特值的长度（位数）</param>
        /// <returns>合并后的整型值</returns>
        public static Result<uint> MultiBitsToNumber(uint bits1, uint bits1Len, uint bits2, uint bits2Len)
        {
            if (bits1Len + bits2Len > 64) return new(new ArgumentException("Two Bits is more than 64 bits"));

            uint num = (bits1 << Convert.ToInt32(bits2Len)) | bits2;
            return num;
        }

        /// <summary>
        /// 比特位检查
        /// </summary>
        /// <param name="srcBits">源比特值</param>
        /// <param name="dstBits">目标比特值</param>
        /// <param name="mask">掩码（默认为全1）</param>
        /// <returns>检查结果（是否匹配）</returns>
        public static bool BitsCheck(ulong srcBits, ulong dstBits, ulong mask = 0xFFFF_FFFF_FFFF_FFFF)
        {
            return (srcBits & mask) == dstBits;
        }

        /// <summary>
        /// 比特位检查
        /// </summary>
        /// <param name="srcBits">源比特值</param>
        /// <param name="dstBits">目标比特值</param>
        /// <param name="mask">掩码（默认为全1）</param>
        /// <returns>检查结果（是否匹配）</returns>
        public static bool BitsCheck(uint srcBits, uint dstBits, uint mask = 0xFFFF_FFFF)
        {
            return (srcBits & mask) == dstBits;
        }


        /// <summary>
        /// 字符串转二进制字节数组
        /// </summary>
        /// <param name="str">输入的字符串</param>
        /// <param name="numBase">进制（默认为16进制）</param>
        /// <returns>转换后的二进制字节数组</returns>
        public static byte[] StringToBytes(string str, int numBase = 16)
        {
            var len = str.Length;
            var bytesLen = len / 2;
            var bytes = new byte[bytesLen];

            for (var i = 0; i < bytesLen; i++)
            {
                bytes[i] = Convert.ToByte(str.Substring(i * 2, 2), 16);
            }

            return bytes;
        }

        /// <summary>
        /// 反转字节数组中的子数组
        /// </summary>
        /// <param name="srcBytes">源字节数组</param>
        /// <param name="distance">子数组的长度（反转的步长）</param>
        /// <returns>反转后的字节数组</returns>
        public static Result<byte[]> ReverseBytes(byte[] srcBytes, int distance)
        {
            if (distance <= 0)
                return new(new ArgumentException("Distance can't be negetive", nameof(distance)));

            var srcBytesLen = srcBytes.Length;
            if (distance > srcBytesLen)
                return new(new ArgumentException(
                    "Distance is larger than bytesArray", nameof(distance)));
            if (srcBytesLen % distance != 0)
                return new(new ArgumentException(
                    "The length of bytes can't be divided by 2 without reminder", nameof(distance)));

            var dstBytes = new byte[srcBytesLen];
            var buffer = new byte[distance];

            for (int i = 0; i < srcBytesLen; i += distance)
            {
                var end = i + distance;
                buffer = srcBytes[i..end];
                Array.Reverse(buffer);
                Array.Copy(buffer, 0, dstBytes, i, distance);
            }

            return dstBytes;
        }


    }

    /// <summary>
    /// 字符串处理工具
    /// </summary>
    public class String
    {
        /// <summary>
        /// 反转字符串
        /// </summary>
        /// <param name="s">输入的字符串</param>
        /// <returns>反转后的字符串</returns>
        public static string Reverse(string s)
        {
            char[] charArray = s.ToCharArray();
            Array.Reverse(charArray);
            return new string(charArray);
        }

    }

}