using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MV485.model
{
    public class RunConfig
    {
        public byte MeterType { get; set; }
        public bool MeterTypeWRFlag { get; set; }

        public ushort DnValue { get; set; }
        public bool DnValueWRFlag { get; set; }

        public byte DigitCount { get; set; }
        public bool DigitCountWRFlag { get; set; }

        public byte IndCount { get; set; }
        public bool IndCountWRFlag { get; set; }

        public float BrightValue { get; set; }
        public bool BrightValueWRFlag { get; set; }

        public byte LastUnitLevel { get; set; }
        public bool LastUnitLevelWRFlag { get; set; }

        public byte UploadRedind { get; set; }
        public bool UploadRedindWRFlag { get; set; }

        public ulong LatestValue { get; set; }
        public bool LatestValueWRFlag { get; set; }

        public DateTime LatestTime { get; set; }

        public string LatestTimeStr
        {
            get
            {
                if(LatestTime == null)
                {
                    return "";
                }
                else
                {
                    return LatestTime.ToString("yyyy-MM-dd HH:mm:ss");
                }
            }
        }
        public bool LatestTimeWRFlag { get; set; }

        //采样间隔(分钟)
        public ushort SampleInterval { get; set; }
        public bool SampleIntervalFlag { get; set; }

        //首采时间(整点时)
        public byte FirstHour { get; set; }
        public bool FirstHourFlag { get; set; }


        public string MeterRegion { get; set; }
        public bool MeterRegionWRFlag { get; set; }

        public string DigitRegion { get; set; }
        public bool DigitRegionWRFlag { get; set; }

        public string FTIndRegion { get; set; }
        public bool FTIndRegionWRFlag { get; set; }


        // 新增属性：按大端序将 LatestValue 转换为 ushort[4]
        public ushort[] LatestValues
        {
            get
            {
                // 1. 将 ulong 转为大端序的字节数组
                byte[] bytes = BitConverter.GetBytes(LatestValue);
                if (BitConverter.IsLittleEndian)
                {
                    Array.Reverse(bytes); // 小端系统需反转字节数组
                }

                // 2. 将字节数组转为 ushort[4]（按大端序）
                ushort[] result = new ushort[4];
                for (int i = 0; i < 4; i++)
                {
                    int offset = i * 2;
                    result[i] = (ushort)((bytes[offset] << 8) | bytes[offset + 1]);
                }
                return result;
            }
        }

        public ushort[] LatestTimes
        {
            get
            {
                if (LatestTime != null)
                {
                    ushort[] result = new ushort[6];
                    result[0] = (ushort)(LatestTime.Year - 2000);
                    result[1] = (ushort)LatestTime.Month;
                    result[2] = (ushort)LatestTime.Day;
                    result[3] = (ushort)LatestTime.Hour;
                    result[4] = (ushort)LatestTime.Minute;
                    result[5] = (ushort)LatestTime.Second;

                    return result;
                }
                else
                {
                    return null;
                }

            }
        }

        /*public ushort[] LatestValues
        {
            get
            {
                // 1. 手动按大端序提取 ulong 的8个字节
                byte[] bytes = new byte[8];
                ulong value = LatestValue;
                bytes[0] = (byte)(value >> 56); // 最高有效字节
                bytes[1] = (byte)(value >> 48);
                bytes[2] = (byte)(value >> 40);
                bytes[3] = (byte)(value >> 32);
                bytes[4] = (byte)(value >> 24);
                bytes[5] = (byte)(value >> 16);
                bytes[6] = (byte)(value >> 8);
                bytes[7] = (byte)value;         // 最低有效字节

                // 2. 将字节按大端序转为 ushort[4]
                ushort[] result = new ushort[4];
                for (int i = 0; i < 4; i++)
                {
                    int offset = i * 2;
                    result[i] = (ushort)((bytes[offset] << 8) | bytes[offset + 1]);
                }
                return result;
            }
        }*/

        // 反向操作：从大端序 ushort[] 设置 LatestValue
        public void SetLatestValueFromShorts(ushort[] values)
        {
            byte[] bytes = new byte[8];
            for (int i = 0; i < 4; i++)
            {
                bytes[i * 2] = (byte)(values[i] >> 8);    // 高8位
                bytes[i * 2 + 1] = (byte)(values[i] & 0xFF); // 低8位
            }

            // 组合为 ulong（手动大端序）
            ulong value =
                ((ulong)bytes[0] << 56) |
                ((ulong)bytes[1] << 48) |
                ((ulong)bytes[2] << 40) |
                ((ulong)bytes[3] << 32) |
                ((ulong)bytes[4] << 24) |
                ((ulong)bytes[5] << 16) |
                ((ulong)bytes[6] << 8) |
                (ulong)bytes[7];
            LatestValue = value;
        }


        public ushort[] MeterRegions
        {
            get
            {
                ushort[] result = ConvertStringToUShortArray(MeterRegion, 4);

                return result;
            }
        }

        public ushort[] DigitRegions
        {
            get
            {
                ushort[] result = ConvertStringToUShortArray(DigitRegion, 8);
                return result;
            }
        }

        public ushort[] FTIndRegions
        {
            get
            {
                ushort[] result = ConvertStringToUShortArray(FTIndRegion, 4);
                return result;
            }
        }

        /// <summary>
        /// 将字符串按分隔符（逗号、空格）分割并转换为固定长度的 ushort 数组
        /// </summary>
        /// <param name="input">输入字符串</param>
        /// <param name="expectedLength">期望的数组长度</param>
        /// <returns>ushort数组（失败返回null）</returns>
        public static ushort[] ConvertStringToUShortArray(string input, int expectedLength)
        {
            // 1. 分割字符串（支持逗号和空格分隔）
            string[] parts = input.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);

            // 2. 验证分割后的元素数量
            if (parts.Length != expectedLength)
            {
                return null;
            }

            // 3. 尝试转换为ushort数组
            ushort[] array = new ushort[expectedLength];
            for (int i = 0; i < expectedLength; i++)
            {
                if (!ushort.TryParse(parts[i], out array[i]))
                {
                    return null; // 转换失败（非数字或超出ushort范围）
                }
            }

            return array;
        }

        public RunConfig()
        {
            MeterTypeWRFlag = false;
            DnValueWRFlag = false;
            DigitCountWRFlag = false;
            IndCountWRFlag = false;
            BrightValueWRFlag = false;
            LastUnitLevelWRFlag = false;
            UploadRedindWRFlag = false;
            LatestValueWRFlag = false;
            LatestTimeWRFlag = false;
            MeterRegionWRFlag = false;
            DigitRegionWRFlag = false;
            FTIndRegionWRFlag = false;
            SampleIntervalFlag = false;
            FirstHourFlag = false;
        }
        //-----------------------------------------------
    }
}