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; }

        [SugarColumn(IsIgnore = true)]
        public string[] CsvData { get; set; }
        [SugarColumn(IsIgnore = true)]
        public DateTime TimeStart { get; set; }

        [SugarColumn(IsIgnore = true)]
        public DateTime TimeStop { get; set; }
        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 string _ProductName;
        /// <summary>
        /// 测量名称
        /// </summary>
        public string ProductName
        {
            get { return _ProductName; }
            set { SetProperty(ref _ProductName, value); }
        }
        private float __TargetTorque;
        /// <summary>
        /// 目标扭矩
        /// </summary>
        public float TargetTorque
        {
            get { return __TargetTorque; }
            set { SetProperty(ref __TargetTorque, 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 string _PhotoName;
        /// <summary>
        /// 拍照结果（是否通过）
        /// </summary>
        public string PhotoName
        {
            get { return _PhotoName; }
            set { SetProperty(ref _PhotoName, value); }
        }
        private string _ResultData;
        /// <summary>
        /// 测量结果
        /// </summary>
        public string ResultData
        {
            get { return _ResultData; }
            set { SetProperty(ref _ResultData, value); }
        }

        private string _ResultData1;
        /// <summary>
        /// 测量结果
        /// </summary>
        public string ResultData1
        {
            get { return _ResultData1; }
            set { SetProperty(ref _ResultData1, value); }
        }

        private string _UpLimit;
        /// <summary>
        /// 测量项的上限
        /// </summary>
        public string UpLimit
        {
            get { return _UpLimit; }
            set { SetProperty(ref _UpLimit, value); }
        }

        private string _DownLimit;
        /// <summary>
        /// 测量项的下限
        /// </summary>
        public string DownLimit
        {
            get { return _DownLimit; }
            set { SetProperty(ref _DownLimit, value); }
        }

        private string _MidLimit;
        /// <summary>
        /// 测量项平均值
        /// </summary>
        public string MidLimit
        {
            get { return _MidLimit; }
            set { SetProperty(ref _MidLimit, value); }
        }

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

        private float __StartPositionY;
        /// <summary>
        /// 锁付位置坐标 Y 起始值
        /// </summary>
        public float StartPositionY
        {
            get { return __StartPositionY; }
            set { SetProperty(ref __StartPositionY, 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 _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); }
        }

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

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

        private string _PhotoPassed;
        /// <summary>
        /// 拍照结果（是否通过）
        /// </summary>
        public string PhotoPassed
        {
            get { return _PhotoPassed; }
            set { SetProperty(ref _PhotoPassed, value); }
        }

        private string _PhotoCode;
        /// <summary>
        /// SN
        /// </summary>
        public string PhotoCode
        {
            get { return _PhotoCode; }
            set { SetProperty(ref _PhotoCode, value); }
        }
        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(int number, string productNumber, bool PhotoPassed)
        {
            Number = number;
            ProductNumber = productNumber;
            Timestamp = DateTime.Now;
            LockPassed = PhotoPassed;
        }
        public LockResult Clone()
        {
            return new LockResult
            {
                Number = this.Number,
                ProductNumber = this.ProductNumber,
                Timestamp = this.Timestamp,
                LockTurns = this.LockTurns,
                LockTorque = this.LockTorque,
                LockDuration = this.LockDuration,
                LockPassed = this.LockPassed,
                ScrewdriverProgramNumber = this.ScrewdriverProgramNumber,
                Pressure = this.Pressure,
                TargetTorque = this.TargetTorque,
                TargetTurnsUpperLimit = this.TargetTurnsUpperLimit,
                TargetTurnsLowerLimit = this.TargetTurnsLowerLimit,
                TargetLockSpeed = this.TargetLockSpeed,
                StartPositionX = this.StartPositionX,
                StartPositionY = this.StartPositionY,
                StartPositionZ = this.StartPositionZ,
                EndPositionZ = this.EndPositionZ,
                LockDescentSpeed = this.LockDescentSpeed,
                FeederNumber = this.FeederNumber,
                NozzleNumber = this.NozzleNumber,
                WaveDatas = new List<WaveData>(this.WaveDatas)
            };
        }

        /// <summary>
        /// 将当前的锁付结果结果及波形数据存储至.csv文件中
        /// </summary>
        /// <param name="filePath"></param>
        public void SaveToCsv(string filePath)
        {
            //using (var writer = new System.IO.StreamWriter(filePath))
            //{
            //    // 写入锁付结果信息
            //    writer.WriteLine("Number,ProductNumber,Timestamp,LockTurns,LockTorque,LockDuration,LockPassed,ScrewdriverProgramNumber,Pressure,TargetTorque,TargetTurnsUpperLimit,TargetTurnsLowerLimit,TargetLockSpeed,StartPositionX,StartPositionY,StartPositionZ,EndPositionZ,LockDescentSpeed,FeederNumber,NozzleNumber");
            //    writer.WriteLine($"{Number},{ProductNumber},{Timestamp},{LockTurns},{LockTorque},{LockDuration},{LockPassed},{ScrewdriverProgramNumber},{Pressure},{TargetTorque},{TargetTurnsUpperLimit},{TargetTurnsLowerLimit},{TargetLockSpeed},{StartPositionX},{StartPositionY},{StartPositionZ},{EndPositionZ},{LockDescentSpeed},{FeederNumber},{NozzleNumber}");
            //    // 写入波形数据
            //    writer.WriteLine();
            //    writer.WriteLine("WaveDataIndex,LockAngle,Torque,Turns,Speed,Slopes");
            //    for (int i = 0; i < WaveDatas.Count; i++)
            //    {
            //        var waveData = WaveDatas[i];
            //        writer.WriteLine($"{i},{waveData.LockAngle},{waveData.Torque},{waveData.Turns},{waveData.Speed},{waveData.Slopes}");
            //    }
            //}
            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}\"";
            }
            var dir = System.IO.Path.GetDirectoryName(filePath);
            if (!string.IsNullOrEmpty(dir) && !System.IO.Directory.Exists(dir))
            {
                System.IO.Directory.CreateDirectory(dir);
            }
            bool fileExists = System.IO.File.Exists(filePath);
            using (var writer = new System.IO.StreamWriter(filePath, fileExists, System.Text.Encoding.UTF8))

            {
                if (!fileExists)
                {
                    // 写入锁付结果信息表头（已新增字段）
                    writer.WriteLine("PPID,PROCESS_NAME,PROCESS_START_TIME,CTQ_NAME,CTQ_VALUE,CTQ_LSL,CTQ_USL,PROCESS_END_TIME,SUPPLIER_NAME,COMMODITY_TYPE,REVISION,WO#,MFG_LOT#," +
                    "MFG_ASSY_LINE,PROCESS_OUTCOME,PROCESS_MACHINE_ID,CTQ_UNIT_OF_MEASURE,ERROR_MESSAGE,PD_ATTR_01,PD_ATTR_02,PD_ATTR_03,PD_ATTR_04,PD_ATTR_05");
                }
                // 写入锁付结果数据行（所有字段均做 CSV 转义）
                writer.WriteLine(string.Join(",",
                    EscapeCsv(PhotoCode),      //PPID
                    EscapeCsv("C KB 3D AOI "),       //PROCESS_NAME
                    EscapeCsv(TimeStart),             //PROCESS_START_TIME
                    EscapeCsv(CsvData[1]),                    //CTQ_NAME
                    EscapeCsv(CsvData[2]),                    //CTQ_VALUE
                    EscapeCsv(CsvData[4]),                    //CTQ_LSL
                    EscapeCsv(CsvData[3]),                    //CTQ_USL
                    EscapeCsv(TimeStop),//PROCESS_END_TIME
                    EscapeCsv("Luxshare JS"),//SUPPLIER_NAME
                    EscapeCsv("Mechanical Hardware_DOOR"),//COMMODITY_TYPE
                    EscapeCsv("X00_DVT1.0"),//REVISION
                    EscapeCsv("xxxx1"),//WO#
                    EscapeCsv(""),//MFG_LOT#
                    EscapeCsv("C Sub"),//MFG_ASSY_LINE
                    EscapeCsv(PhotoPassed),//PROCESS_OUTCOME
                    EscapeCsv("C  SUB  KB 3D AOI  M08"),//PROCESS_MACHINE_ID
                    EscapeCsv("MM"),//CTQ_UNIT_OF_MEASURE
                    EscapeCsv(""),//ERROR_MESSAGE
                    EscapeCsv("xxxxxxxx1"),//PD_ATTR_01
                    EscapeCsv(CsvData[5]),//PD_ATTR_02
                    EscapeCsv(""),//PD_ATTR_03
                    EscapeCsv(""),//PD_ATTR_04
                    EscapeCsv("")  //PD_ATTR_05
                ));

                //// 写入波形数据
                //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);
                }
            });
        }
    }
}