using Assets.Scripts.Apis;
using Assets.Scripts.Apis.Models;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;

namespace Assets.Scenes.Ride.Scripts.Model
{
    public class RecorderDataModel
    {
        //private readonly MapWorkoutService service = new MapWorkoutService();

        public UserResultModel CurrentUser { get; set; }
        /// <summary>
        /// 所属人ID
        /// </summary>
        public int BelongUserId
        {
            get
            {
                return CurrentUser.Id;
            }
        }
        /// <summary>
        /// 记录是否完毕
        /// </summary>
        public bool IsCompleted { get; set; }
        /// <summary>
        /// 是否需要计算排名
        /// </summary>
        public bool IsNeedRanking { get; set; }
        /// <summary>
        /// 骑行记录索引(用于中断骑行,继续骑行)
        /// </summary>
        public int ContinueIndex { get; set; }
        /// <summary>
        /// 骑行状态
        /// </summary>
        public CyclingStateEnum CyclingState { get; set; }
        /// <summary>
        /// 赛事Id
        /// </summary>
        public int Competitionid { get; set; }
        /// <summary>
        /// 当前已经骑行的距离(表示用户现在在的距离，并不是实际骑的距离)
        /// </summary>
        public double EndDistance { get; set; }
        /// <summary>
        /// 上次骑行的距离
        /// </summary>
        public double PreDistance { get; set; }
        /// <summary>
        /// 继续骑行记录标志
        /// </summary>
        public string ContinueMark { get; set; }
        /// <summary>
        /// 厂商Id
        /// </summary>
        public int ManufacturerId { get; set; }

        public int? AntModelId { get; set; }
        /// <summary>
        /// 骑行数据
        /// </summary>
        public List<TargetData> RiderDatas = new List<TargetData>();
        /// <summary>
        /// 当前路线
        /// </summary>
        public Route CurrentRoute { get; set; }
        /// <summary>
        /// 骑行记录Id
        /// </summary>
        //public string RecordId { get; private set; }
        /// <summary>
        /// 设备号
        /// </summary>
        public string DeviceNumber { get; set; }

        /// <summary>
        /// 当前给骑行台发送数据的模式
        /// </summary>
        public SendDataMode SendDataMode { get; set; }
        /// <summary>
        /// 临时使用的坡度
        /// </summary>
        public double SlopeGrade { get; set; }
        /// <summary>
        /// 临时使用的海拔
        /// </summary>
        public double Elevation { get; set; }
        /// <summary>
        /// 当前路书开始的距离
        /// </summary>
        public double CurrentRouteStartDistance { get; set; }

        public DateTime StartTime { get; set; }
        /// <summary>
        /// 是否已经保存成功
        /// </summary>
        public bool Saved { get; set; }

        public int GlobalCyclingId { get; set; }

        public void SaveLocal(CyclingModel cyclingModel, RouteResultParam selectParam, string imageName,string recordId)
        {
            Dictionary<MapInterruptRecord, List<string>> recordData = new Dictionary<MapInterruptRecord, List<string>>();
            if (RiderDatas.Count <= 0)
            {
                return ;
            }
            string newFileName = Guid.NewGuid().ToString();
            int FTP = Helper.GetFtp();
            double NP = Helper.GetNP(RiderDatas);
            //强度
            double IF = NP / FTP;
            //训练量
            double TSS = (RiderDatas.Count * NP * IF) / (FTP * 3600) * 100;
            var averagePower = Helper.AveragePower(RiderDatas);
           
            // AntManufacturer manufacturer = service.GetAntManufacturer(ManufacturerId).data;
            //var recordId = Guid.NewGuid().ToString();
            var ticks = RiderDatas.Last().Ticks;
            var interruptRecord = new MapInterruptRecord
            {
                Id = recordId,
                RouteId = CurrentRoute.RouteInstance.Id,
                RouteName = CurrentRoute.RouteInstance.Name,
                TotalDistance = CurrentRoute.RouteInstance.Distance,
                UserId = BelongUserId,
                RecordFileName = newFileName + ".txt",
                Ftp = FTP,//FTP设置
                IF = Math.Round(IF, 2),
                Kj = RiderDatas.Sum(a => a._Power) / 1000,//消耗
                Tss = Math.Round(TSS, 2),
                EndDistance = EndDistance,
                IsCompleted = IsCompleted,

                //TrainingTime = TimeHelper.FormatSeconds(RiderDatas.Last().Ticks),//训练时间
                NormalizedPower = Math.Floor(NP),//标准化功率
                AveragePower = averagePower,//平均功率
                MaxPower = RiderDatas.Max(a => a._Power),//最大功率
                WeightKg = Math.Round(averagePower / App.CurrentUser.Weight, 2),
                Weight = App.CurrentUser.Weight,
                BicycleWeight = App.CurrentUser.BicycleWeight,
                ContinueMark = ContinueMark,
                ContinueIndex = ContinueIndex,
                IsDelete = false,
                MapCompetitionId = Competitionid,
                ManufacturerName = "",//manufacturer == null ? "" : manufacturer.Name,
                DeviceNumber = DeviceNumber,
                IsRanking = IsNeedRanking,
                CurrentRouteStartDistance = CurrentRouteStartDistance,
                ManufacturerId = ManufacturerId,
                AntModelId = AntModelId,
                StartTime = StartTime,
                CreateTime = StartTime.AddSeconds(ticks),
                Ticks = ticks,
                Mode = cyclingModel.ToString(),
                Param = Newtonsoft.Json.JsonConvert.SerializeObject(selectParam),
                GlobalCyclingId = 0,
                Source = "",
            };
            //var range = new MapSpeedRange().GetSpeedRange(RiderDatas, CurrentRoute.RouteInstance.Distance);
            interruptRecord.SpeedRange = null; //JsonConvert.SerializeObject(range);

            double process = Math.Round((EndDistance - interruptRecord.CurrentRouteStartDistance) / CurrentRoute.RouteInstance.Distance, 2);
            interruptRecord.Progress = process > 1 ? 1 : process;

            var cadences = RiderDatas.Where(a => a._Cadence.HasValue && a._Cadence.Value > 0);
            if (cadences.Any())
            {
                interruptRecord.AverageCadence = Math.Round(cadences.Average(a => a._Cadence.GetValueOrDefault(0)));
            }
            interruptRecord.MaxCadence = Math.Round(RiderDatas.Max(a => a._Cadence.GetValueOrDefault(0)));
            interruptRecord.AverageHeartRate = Math.Round(RiderDatas.Average(a => a._HeartRate.GetValueOrDefault(0)));
            interruptRecord.MaxHeartRate = RiderDatas.Max(a => a._HeartRate.GetValueOrDefault(0));
            //service.CreateRecordCyclingData(interruptRecord);
            //保存骑行记录txt
            var path = Helper.GetDataDir("MapWorkoutRecords" + "/" + interruptRecord.Id);
            var fname = path + "/" + newFileName + ".txt";
            var files = new List<string>();
            using (var fs = new FileInfo(fname).OpenWrite())
            {
                var stream = new StreamWriter(fs);
                stream.BaseStream.Seek(0, SeekOrigin.End);
                foreach (var item in RiderDatas)
                {
                    stream.Write(item.Write() + "\r\n");
                }
                stream.Flush();
                stream.Close();
                files.Add(fname);
            }
            //图片
            if (!string.IsNullOrEmpty(imageName))
            {
                files.Add(imageName);
            }
            //持久化序列化对象
            var recordString = JsonConvert.SerializeObject(interruptRecord);
            var recordFilePath = path + "/" + "record" + ".txt";
            System.IO.File.WriteAllText(recordFilePath, recordString);

            recordData.Add(interruptRecord, files);

            SaveDataAysnc(recordData);
        }
        /// <summary>
        /// 保存数据
        /// </summary>
        /// <param name="base64Image"></param>
        /// <returns></returns>
        public void SaveDataAysnc(Dictionary<MapInterruptRecord, List<string>> data)
        {
            if (data != null && data.Count > 0)
            {
                var path = Helper.GetDataDir("MapWorkoutRecords");
                Task.Run(() => {
                    var record = data.FirstOrDefault();
                    MapInterruptRecordApi service = new MapInterruptRecordApi();
                    var result = service.Add(record.Key, record.Value);
                    
                    //删除文件
                    try
                    {
                        path = path + "/" + record.Key.Id;
                        if (result.result && Directory.Exists(path))
                        {
                            Helper.DelectDir(path);
                        }
                    }
                    catch (Exception e)
                    {
                        Debug.Log(e.Message);
                    }
                });
            }
        }
    }
}