using Prism.Mvvm;
using System;
using System.Collections.Generic;
using static TeamAAS_VP.Core.ScrewDriver.XYD_ScrewDriver;
using SqlSugar;

namespace TeamAAS_VP.Models
{
    public class LockResult : BindableBase
    {
        [SugarColumn(IsPrimaryKey = true, IsIdentity = true)]
        public int Id { get; set; }

        private string _ProductName;
        /// <summary>
        /// 产品名称
        /// </summary>
        public string ProductName
        {
            get { return _ProductName; }
            set { SetProperty(ref _ProductName, value); }
        }

        private int __Number;
        /// <summary>
        /// 螺丝编号
        /// </summary>
        public int Number
        {
            get { return __Number; }
            set { SetProperty(ref __Number, value); }
        }

        private string __ProductNumber;
        /// <summary>
        /// 产品编号
        /// </summary>
        [SugarColumn(IsNullable = true)]
        public string ProductNumber
        {
            get { return __ProductNumber; }
            set { SetProperty(ref __ProductNumber, value); }
        }

        private DateTime __Timestamp;
        /// <summary>
        /// 时间戳
        /// </summary>
        public DateTime Timestamp
        {
            get { return __Timestamp; }
            set { SetProperty(ref __Timestamp, value); }
        }

        private float __LockTurns;
        /// <summary>
        /// 锁付圈数
        /// </summary>
        public float LockTurns
        {
            get { return __LockTurns; }
            set { SetProperty(ref __LockTurns, value); }
        }

        private float __LockTorque;
        /// <summary>
        /// 锁付扭矩
        /// </summary>
        public float LockTorque
        {
            get { return __LockTorque; }
            set { SetProperty(ref __LockTorque, value); }
        }

        private float __LockDuration;
        /// <summary>
        /// 锁付用时
        /// </summary>
        public float LockDuration
        {
            get { return __LockDuration; }
            set { SetProperty(ref __LockDuration, value); }
        }

        private bool __LockPassed;
        /// <summary>
        /// 锁付结果（是否通过）
        /// </summary>
        public bool LockPassed
        {
            get { return __LockPassed; }
            set { SetProperty(ref __LockPassed, value); }
        }

        //
        private string _ResultDetails;
        /// <summary>
        /// 结果详情
        /// </summary>
        [SugarColumn(IsNullable = true)]
        public string ResultDetails
        {
            get { return _ResultDetails; }
            set { SetProperty(ref _ResultDetails, value); }
        }

        private int __ScrewdriverProgramNumber;
        /// <summary>
        /// 电批程序号
        /// </summary>
        public int ScrewdriverProgramNumber
        {
            get { return __ScrewdriverProgramNumber; }
            set { SetProperty(ref __ScrewdriverProgramNumber, value); }
        }

        private float __Pressure;
        /// <summary>
        /// 压力值
        /// </summary>
        public float Pressure
        {
            get { return __Pressure; }
            set { SetProperty(ref __Pressure, value); }
        }

        private float __TargetTorqueUpperLimit;
        /// <summary>
        /// 目标扭矩上限
        /// </summary>
        public float TargetTorqueUpperLimit
        {
            get { return __TargetTorqueUpperLimit; }
            set { SetProperty(ref __TargetTorqueUpperLimit, value); }
        }

        private float __TargetTorqueLowerLimit;
        /// <summary>
        /// 目标扭矩下限
        /// </summary>
        public float TargetTorqueLowerLimit
        {
            get { return __TargetTorqueLowerLimit; }
            set { SetProperty(ref __TargetTorqueLowerLimit, value); }
        }

        private float __TargetTurnsUpperLimit;
        /// <summary>
        /// 目标圈数上限
        /// </summary>
        public float TargetTurnsUpperLimit
        {
            get { return __TargetTurnsUpperLimit; }
            set { SetProperty(ref __TargetTurnsUpperLimit, value); }
        }

        private float __TargetTurnsLowerLimit;
        /// <summary>
        /// 目标圈数下限
        /// </summary>
        public float TargetTurnsLowerLimit
        {
            get { return __TargetTurnsLowerLimit; }
            set { SetProperty(ref __TargetTurnsLowerLimit, value); }
        }

        private float __TargetLockSpeed;
        /// <summary>
        /// 目标锁付速度
        /// </summary>
        public float TargetLockSpeed
        {
            get { return __TargetLockSpeed; }
            set { SetProperty(ref __TargetLockSpeed, value); }
        }

        private bool _ScrewdriverGetDataSucceed;
        /// <summary>
        /// 电批数据是否获取成功
        /// </summary>
        public bool ScrewdriverGetDataSucceed
        {
            get { return _ScrewdriverGetDataSucceed; }
            set { SetProperty(ref _ScrewdriverGetDataSucceed, value); }
        }

        private float __PositionX;
        /// <summary>
        /// 锁付位置坐标 X 值
        /// </summary>
        public float PositionX
        {
            get { return __PositionX; }
            set { SetProperty(ref __PositionX, value); }
        }

        private float __PositionY;
        /// <summary>
        /// 锁付位置坐标 Y 值
        /// </summary>
        public float PositionY
        {
            get { return __PositionY; }
            set { SetProperty(ref __PositionY, value); }
        }

        private float __StartPositionZ;
        /// <summary>
        /// 锁付位置坐标 Z 起始值
        /// </summary>
        public float StartPositionZ
        {
            get { return __StartPositionZ; }
            set { SetProperty(ref __StartPositionZ, value); }
        }

        private float __EndPositionZ;
        /// <summary>
        /// 锁付位置坐标 Z 终点值
        /// </summary>
        public float EndPositionZ
        {
            get { return __EndPositionZ; }
            set { SetProperty(ref __EndPositionZ, value); }
        }

        private float __LockDescentSpeed;
        /// <summary>
        /// 锁付下降速度
        /// </summary>
        public float LockDescentSpeed
        {
            get { return __LockDescentSpeed; }
            set { SetProperty(ref __LockDescentSpeed, value); }
        }

        private int __FeederNumber;
        /// <summary>
        /// 供料器编号
        /// </summary>
        public int FeederNumber
        {
            get { return __FeederNumber; }
            set { SetProperty(ref __FeederNumber, value); }
        }

        private float _FeederBatchNumber;
        /// <summary>
        /// 螺丝批次编号
        /// </summary>
        public float FeederBatchNumber
        {
            get { return _FeederBatchNumber; }
            set { SetProperty(ref _FeederBatchNumber, value); }
        }

        private string __NozzleNumber;
        /// <summary>
        /// 吸嘴编号
        /// </summary>
        [SugarColumn(IsNullable = true)]
        public string NozzleNumber
        {
            get { return __NozzleNumber; }
            set { SetProperty(ref __NozzleNumber, value); }
        }

        private string _HeadNumber;
        /// <summary>
        /// 披头编号
        /// </summary>
        [SugarColumn(IsNullable = true)]
        public string HeadNumber
            {
            get { return _HeadNumber; }
            set { SetProperty(ref _HeadNumber, value); }
        }

        //当前的操作员名称
        private string _OperatorName;
        [SugarColumn(IsNullable = true)]
        public string OperatorName
        {
            get { return _OperatorName; }
            set { SetProperty(ref _OperatorName, value); }
        }

        private string _ProductImagePath;
        /// <summary>
        /// 产品图片路径
        /// </summary>
        [SugarColumn(IsNullable = true)]
        public string ProductImagePath
        {
            get { return _ProductImagePath; }
            set { SetProperty(ref _ProductImagePath, value); }
        }

        private string _LockCurveImagePath;
        /// <summary>
        /// 锁付曲线图路径
        /// </summary>
        [SugarColumn(IsNullable = true)]
        public string LockCurveImagePath
        {
            get { return _LockCurveImagePath; }
            set { SetProperty(ref _LockCurveImagePath, value); }
        }

        /// <summary>
        /// 锁付曲线数据列表
        /// </summary>
        [SugarColumn(IsIgnore = true)]
        public List<WaveData> WaveDatas { get; set; } = new List<WaveData>();

        public LockResult()
        {
            // 默认构造函数
            Timestamp = DateTime.Now;
        }

        public LockResult(int number, string productNumber, float lockTurns, float lockTorque, bool lockPassed)
        {
            Number = number;
            ProductNumber = productNumber;
            Timestamp = DateTime.Now;
            LockTurns = lockTurns;
            LockTorque = lockTorque;
            LockPassed = lockPassed;
        }

        public LockResult Clone()
        {
            return new LockResult
            {
                Number = this.Number,
                ProductName = this.ProductName,
                ProductNumber = this.ProductNumber,
                Timestamp = this.Timestamp,
                LockTurns = this.LockTurns,
                LockTorque = this.LockTorque,
                LockDuration = this.LockDuration,
                LockPassed = this.LockPassed,
                ScrewdriverProgramNumber = this.ScrewdriverProgramNumber,
                Pressure = this.Pressure,
                TargetTorqueUpperLimit = this.TargetTorqueUpperLimit,
                TargetTorqueLowerLimit = this.TargetTorqueLowerLimit,
                TargetTurnsUpperLimit = this.TargetTurnsUpperLimit,
                TargetTurnsLowerLimit = this.TargetTurnsLowerLimit,
                TargetLockSpeed = this.TargetLockSpeed,
                PositionX = this.PositionX,
                PositionY = this.PositionY,
                StartPositionZ = this.StartPositionZ,
                EndPositionZ = this.EndPositionZ,
                LockDescentSpeed = this.LockDescentSpeed,
                FeederNumber = this.FeederNumber,
                NozzleNumber = this.NozzleNumber,
                HeadNumber= this.HeadNumber,
                OperatorName = this.OperatorName,
                ProductImagePath = this.ProductImagePath,
                ScrewdriverGetDataSucceed = this.ScrewdriverGetDataSucceed,
                WaveDatas = new List<WaveData>(this.WaveDatas),
                LockCurveImagePath = this.LockCurveImagePath,
            };
        }

        /// <summary>
        /// 将当前的锁付结果结果及波形数据存储至.csv文件中
        /// </summary>
        /// <param name="filePath"></param>
        public void SaveToCsv(string filePath)
        {
            string EscapeCsv(object value)
            {
                if (value == null) return "\"\"";
                string s;
                if (value is DateTime dt)
                {
                    s = dt.ToString("o"); // ISO 8601
                }
                else
                {
                    s = Convert.ToString(value, System.Globalization.CultureInfo.InvariantCulture);
                }
                s = s.Replace("\"", "\"\""); // escape quotes
                return $"\"{s}\"";
            }

            using (var writer = new System.IO.StreamWriter(filePath, false, System.Text.Encoding.UTF8))
            {
                // 写入锁付结果信息表头（已新增字段）
                writer.WriteLine("Number,ProductName,ProductNumber,Timestamp,LockTurns,LockTorque,LockDuration,LockPassed,ScrewdriverProgramNumber,Pressure,TargetTorque,TargetTurnsUpperLimit,TargetTurnsLowerLimit,TargetLockSpeed,StartPositionX,StartPositionY,StartPositionZ,EndPositionZ,LockDescentSpeed,FeederNumber,FeederBatchNumber,NozzleNumber,HeadNumber,ResultDetails,ScrewdriverGetDataSucceed,OperatorName,ProductImagePath,LockCurveImagePath");

                // 写入锁付结果数据行（所有字段均做 CSV 转义）
                writer.WriteLine(string.Join(",",
                    EscapeCsv(Number),
                    EscapeCsv(ProductName),
                    EscapeCsv(ProductNumber),
                    EscapeCsv(Timestamp),
                    EscapeCsv(LockTurns),
                    EscapeCsv(LockTorque),
                    EscapeCsv(LockDuration),
                    EscapeCsv(LockPassed),
                    EscapeCsv(ScrewdriverProgramNumber),
                    EscapeCsv(Pressure),
                    EscapeCsv(TargetTorqueUpperLimit),
                    EscapeCsv(TargetTorqueLowerLimit),
                    EscapeCsv(TargetTurnsUpperLimit),
                    EscapeCsv(TargetTurnsLowerLimit),
                    EscapeCsv(TargetLockSpeed),
                    EscapeCsv(PositionX),
                    EscapeCsv(PositionY),
                    EscapeCsv(StartPositionZ),
                    EscapeCsv(EndPositionZ),
                    EscapeCsv(LockDescentSpeed),
                    EscapeCsv(FeederNumber),
                    EscapeCsv(FeederBatchNumber),
                    EscapeCsv(NozzleNumber),
                    EscapeCsv(HeadNumber),
                    EscapeCsv(ResultDetails),
                    EscapeCsv(ScrewdriverGetDataSucceed),
                    EscapeCsv(OperatorName),
                    EscapeCsv(ProductImagePath),
                    EscapeCsv(LockCurveImagePath)
                ));

                // 写入波形数据
                writer.WriteLine();
                writer.WriteLine("WaveDataIndex,LockAngle,Torque,Turns,Speed,Slopes");
                for (int i = 0; i < WaveDatas.Count; i++)
                {
                    var waveData = WaveDatas[i];
                    writer.WriteLine(string.Join(",",
                        EscapeCsv(i),
                        EscapeCsv(waveData.LockAngle),
                        EscapeCsv(waveData.Torque),
                        EscapeCsv(waveData.Turns),
                        EscapeCsv(waveData.Speed),
                        EscapeCsv(waveData.Slopes)
                    ));
                }
            }
        }

        /// <summary>
        /// 异步保存到csv
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public async System.Threading.Tasks.Task SaveToCsvAsync(string filePath)
        {
            await System.Threading.Tasks.Task.Run(() =>
            {
                try
                {
                    SaveToCsv(filePath);
                }
                catch (Exception ex)
                {
                    LogHelper.WriteLogError("保存锁付数据至CSV时出错！", ex);
                }
            });
        }

    }
}