using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Web.Http;
using XdCxRhDW.Dto;
using XdCxRhDW.Repostory;
using System.IO;
using XdCxRhDW.Entity;
using XdCxRhDW.Api;
using XdCxRhDW.WebApi;
using DPP_YH_Core.Extensions;
using XdCxRhDW.App.Model;
using System.Diagnostics;
using System.Configuration;
using DevExpress.Mvvm.Native;

namespace XdCxRhDW.App.Controllers
{
    /// <summary>
    /// 结果查询相关接口
    /// </summary>
    public class ResultController : BaseController
    {
        /// <summary>
        /// 根据时间范围查询参估结果
        /// </summary>
        /// <param name="dto"><see cref="CgResQueryDto"/>查询参数</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpPost]
        public async Task<AjaxResult<List<CgResDto>>> GetCgResByTimeRange(CgResQueryDto dto)
        {
            List<CgResDto> cgRes = null;
            try
            {
                var start = dto.BeginTime.ToString("yyyy-MM-dd HH:mm:ss");
                var end = dto.EndTime.ToString("yyyy-MM-dd HH:mm:ss");
                using (MySqlContext db = new MySqlContext())
                {
                    string sql = $"select a.*,b.SatTxLon,b.SatTxLat,b.CdbTxLon,b.CdbTxLat,b.CxLon,b.CxLat,b.RefLon,b.RefLat from cgres a left join stationres b on a.StationResID=b.ID and b.SigTime>='{start}' and b.SigTime<='{end}' where a.SigTime>='{start}' and a.SigTime<='{end}' and a.Deleted=0 and a.TaskID={dto.TaskInfoID} ";

                    if (dto.TarFrequpHz != null && dto.TarFrequpHz > 0)
                        sql = $"{sql} and TarFreqUp={dto.TarFrequpHz.Value} ";

                    sql = $"{sql} order by SigTime desc ";
                    cgRes = await db.SqlQueryAsync<CgResDto>(sql);
                }
                return Success(cgRes);
            }
            catch (TaskCanceledException)
            {
                string msg = $"参估结果时间范围查询超时.任务ID={dto.TaskInfoID},{dto.BeginTime:yyyyMMddHHmmss}-{dto.EndTime:yyyyMMddHHmmss}";
                XdCxRhDW.Framework.LogHelper.Error(msg);
                return Error<List<CgResDto>>("参估结果时间范围查询超时");
            }
            catch (Exception ex)
            {
                string msg = $"参估结果时间范围查询异常.任务ID={dto.TaskInfoID},{dto.BeginTime:yyyyMMddHHmmss}-{dto.EndTime:yyyyMMddHHmmss}";
                XdCxRhDW.Framework.LogHelper.Error(msg, ex);
                return Error<List<CgResDto>>("参估结果时间范围查询异常");
            }
        }

        /// <summary>
        /// 获取指定任务的所有上行频点
        /// </summary>
        /// <param name="dto">任务频点查询模型</param>
        /// <returns>任务所有频点信息</returns>
        /// <exception cref="Exception"></exception>
        [HttpPost]
        public async Task<AjaxResult<List<TaskFreqResDto>>> GetTaskFreqs(TaskFreqQueryDto dto)
        {
            List<long> posList = null;
            try
            {
                using (MySqlContext db = new MySqlContext())
                {
                    posList = await db.PosRes.Where(p => p.Deleted == 0 && p.TaskInfoID == dto.TaskInfoID).Select(p => p.FreqUpHz).Distinct().ToListAsync();
                }
                var res = posList.Select(p => new TaskFreqResDto() { FreqUpHz = p }).OrderBy(o => o.FreqUpHz).ToList();
                return Success(res);
            }
            catch (Exception ex)
            {
                string msg = $"任务上行频点查询异常-任务编号:{dto.TaskInfoID}";
                XdCxRhDW.Framework.LogHelper.Error(msg, ex);
                return Error<List<TaskFreqResDto>>("任务上行频点查询异常");
            }
        }

        /// <summary>
        /// 获取所有执行中的任务
        /// </summary>
        [HttpPost]
        public async Task<AjaxResult<List<TaskQueryResDto>>> GetRunningTasks()
        {
            try
            {
                using (MySqlContext db = new MySqlContext())
                {
                    var tasks = await db.TaskInfos.Where(p => p.TaskState == EnumTaskState.Running).ToListAsync();
                    var res = tasks.Select(t => new TaskQueryResDto()
                    {
                        TaskID = t.ID,
                        PosType = (EnumPosTypeDto)(int)t.PosType,
                        TaskType = (EnumTaskTypeDto)(int)t.TaskType,
                    });
                    return Success(res.ToList());
                }
            }
            catch (Exception ex)
            {
                string msg = $"查询执行中的任务异常";
                XdCxRhDW.Framework.LogHelper.Error(msg, ex);
                return Error<List<TaskQueryResDto>>("查询执行中的任务异常");
            }
        }

        #region 定位结果查询接口
        /// <summary>
        /// 根据时间范围查询定位结果
        /// </summary>
        /// <param name="dto"><see cref="PosRequestByTimeRangeDto"/>查询参数</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpPost]
        public async Task<AjaxResult<List<PosResDto>>> GetPosResByTimeRange(PosRequestByTimeRangeDto dto)
        {
            var response = (await GetPosResByTimeRangeObsolete(dto));
            if (response.code == 200)
            {
                var listDto = response.data?.Select(p => MapDto(p)).ToList();
                return Success(listDto);
            }
            else
            {
                return Error<List<PosResDto>>(response.msg);
            }
        }

        /// <summary>
        /// 查询最后X小时的的定位结果
        /// </summary>
        /// <param name="dto"><see cref="PosRequestByLastRangeDto"/>查询参数</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpPost]
        public async Task<AjaxResult<List<PosResDto>>> GetPosResByLastHours(PosRequestByLastRangeDto dto)
        {
            var response = (await GetPosResByLastHoursObsolete(dto));
            if (response.code == 200)
            {
                var listDto = response.data?.Select(p => MapDto(p)).ToList();
                return Success(listDto);
            }
            else
            {
                return Error<List<PosResDto>>(response.msg);
            }
        }


        /// <summary>
        /// 根据时间范围查询定位结果(此方法内部调用)
        /// </summary>
        /// <param name="dto"><see cref="PosRequestByTimeRangeDto"/>查询参数</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpPost]
        [Obsolete]
        public async Task<AjaxResult<List<ModelPosRes>>> GetPosResByTimeRangeObsolete(PosRequestByTimeRangeDto dto)
        {
            List<ModelPosRes> posRes = null;
            try
            {
                DateTime start = dto.BeginTime;
                DateTime end = dto.EndTime;
                List<TargetInfo> targets;
                using (MySqlContext db = new MySqlContext())
                {
                    var startStr = dto.BeginTime.ToString("yyyy-MM-dd HH:mm:ss");
                    var endStr = dto.EndTime.ToString("yyyy-MM-dd HH:mm:ss");
                    string sql = $"select a.*,b.UserName,b.PosCheckType,c.Snr1,c.Snr2,c.SnrCdb from posres a left join checkres b on a.CheckResID=b.ID and b.SigTime>='{startStr}' and b.SigTime<='{endStr}' left JOIN cgres c on a.CgResID=c.ID and c.SigTime>='{startStr}' and c.SigTime<='{endStr}'  where a.SigTime>='{startStr}' and a.SigTime<='{endStr}' and a.Deleted=0 and a.TaskInfoID={dto.TaskInfoID} ";

                    if (!dto.IncludeInvalidate)
                        sql = $"{sql} and PosLon!=999 ";

                    if (dto.TarFrequpHz != null && dto.TarFrequpHz > 0)
                        sql = $"{sql} and FreqUpHz={dto.TarFrequpHz.Value} ";

                    sql = $"{sql} order by SigTime desc ";

                    posRes = await db.SqlQueryAsync<ModelPosRes>(sql);
                    if (posRes.Any())
                    {
                        targets = await db.TargetInfos.ToListAsync();
                        foreach (var itemPos in posRes)
                        {
                            if (itemPos.TargetInfoID > 0)
                            {
                                var find = targets.FirstOrDefault(p => p.ID == itemPos.TargetInfoID);
                                itemPos.TargetName = find?.TargetName;
                                itemPos.ColorKey = find?.TargeColor;
                            }
                            if (itemPos.Snr2 == null && itemPos.SnrCdb != null)
                            {
                                itemPos.Snr2 = itemPos.SnrCdb;
                            }
                        }

                    }
                }
                return Success(posRes);
            }
            catch (Exception ex)
            {
                string msg = $"定位结果时间范围查询异常.任务ID={dto.TaskInfoID},{dto.BeginTime:yyyyMMddHHmmss}-{dto.EndTime:yyyyMMddHHmmss}";
                XdCxRhDW.Framework.LogHelper.Error(msg, ex);
                return Error<List<ModelPosRes>>("定位结果时间范围查询异常");
            }
        }
        /// <summary>
        /// 根据时间范围查询定位结果(此方法内部调用)
        /// </summary>
        /// <param name="dto"><see cref="PosRequestByTimeRangeDto"/>查询参数</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpPost]
        [Obsolete]
        public async Task<AjaxResult<List<RePosRes>>> GetPosCgResByTimeRangeObsolete(PosRequestByTimeRangeDto dto)
        {
            List<RePosRes> posList = new List<RePosRes>();
            try
            {
                DateTime start = dto.BeginTime;
                DateTime end = dto.EndTime;
                var dir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DbPart");
                if (!Directory.Exists(dir)) return Success(posList);
                List<string> list = new List<string>();
                DateTime tempStart = new DateTime(start.Year, start.Month, start.Day);
                while (end >= tempStart)
                {
                    list.Add(end.ToString("yyyy") + "\\" + end.ToString("MMdd") + ".db");
                    end = end.AddDays(-1);
                }
                end = dto.EndTime;
                List<TargetInfo> targets;
                using (MySqlContext db = new MySqlContext())
                {
                    targets = await db.TargetInfos.ToListAsync();
                }
                foreach (var item in list)
                {
                    var dayFile = Path.Combine(dir, item);
                    using (MySqlContext db = new MySqlContext())
                    {
                        if (db == null) continue;
                        var query = db.PosRes.Where(p => p.Deleted == 0 && p.SigTime >= start && p.SigTime <= end && p.TaskInfoID == dto.TaskInfoID);
                        if (!dto.IncludeInvalidate)
                            query = query.Where(p => p.PosLon != 999);
                        if (dto.TarFrequpHz != null && dto.TarFrequpHz > 0)
                            query = query.Where(p => p.FreqUpHz == dto.TarFrequpHz.Value);
                        var posRes = await query.OrderByDescending(p => p.SigTime).ToListAsync();

                        foreach (var itemPos in posRes)
                        {
                            var repos = new RePosRes();
                            repos.ID = itemPos.ID;
                            repos.SigTime = itemPos.SigTime;
                            repos.PosLon = itemPos.PosLon;
                            repos.PosLat = itemPos.PosLat;
                            repos.MirrLon = itemPos.MirrLon;
                            repos.MirrLat = itemPos.MirrLat;
                            repos.TaskInfoID = itemPos.TaskInfoID;
                            repos.FreqUpHz = itemPos.FreqUpHz;
                            repos.StationResID = itemPos.StationResID;
                            repos.CxResID = itemPos.CxResID;
                            repos.CgResID = itemPos.CgResID;
                            repos.CheckResID = itemPos.CheckResID;
                            repos.PosResType = itemPos.PosResType;
                            repos.TargetState = itemPos.TargetState;

                            repos.TargetInfo = targets?.FirstOrDefault(p => p.ID == itemPos.TargetInfoID);
                            if (itemPos.TargetInfo != null && !string.IsNullOrWhiteSpace(itemPos.TargetInfo.TargeColor))
                            {
                                repos.ColorKey = itemPos.TargetInfo.TargeColor;
                            }
                            repos.BaseTargetName = itemPos.TargetInfo?.TargetName;
                            repos.CheckRes = await db.CheckRes.FirstOrDefaultAsync(p => p.ID == itemPos.CheckResID);
                            repos.BaseCheckType = itemPos.CheckRes?.PosCheckType?.GetEnumDisplayName();
                            repos.CgRes = await db.CgRes.FirstOrDefaultAsync(p => p.ID == itemPos.CgResID);
                            repos.CxRes = await db.CxRes.FirstOrDefaultAsync(p => p.ID == itemPos.CxResID);
                            repos.StationRes = await db.StationRes.FirstOrDefaultAsync(p => p.ID == itemPos.StationResID);
                            posList.Add(repos);
                        }
                    }
                }
                return Success(posList);
            }
            catch (Exception ex)
            {
                string msg = $"定位结果时间范围查询异常.任务ID={dto.TaskInfoID},{dto.BeginTime:yyyyMMddHHmmss}-{dto.EndTime:yyyyMMddHHmmss}";
                XdCxRhDW.Framework.LogHelper.Error(msg, ex);
                return Error<List<RePosRes>>("定位结果时间范围查询异常");
            }
        }
        /// <summary>
        /// 查询最后X小时的的定位结果(此方法内部调用)
        /// </summary>
        /// <param name="dto"><see cref="PosRequestByLastRangeDto"/>查询参数</param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        [HttpPost]
        [Obsolete]
        public async Task<AjaxResult<List<ModelPosRes>>> GetPosResByLastHoursObsolete(PosRequestByLastRangeDto dto)
        {
            List<ModelPosRes> posList = new List<ModelPosRes>();
            try
            {
                DateTime? max = null;
                using (MySqlContext db = new MySqlContext())
                {
                    string sql = $"select max(SigTime) from PosRes where TaskInfoID={dto.TaskInfoID} and Deleted=0 ";
                    var query = db.PosRes.Where(p => p.TaskInfoID == dto.TaskInfoID && p.Deleted == 0);
                    if (!dto.IncludeInvalidate)
                    {
                        sql = $"{sql} and PosLon!=999 ";

                    }
                    if (dto.TarFrequpHz != null && dto.TarFrequpHz > 0)
                    {
                        sql = $"{sql} and FreqUpHz={dto.TarFrequpHz} ";
                    }
                    max = await db.SqlQueryOneAsync<DateTime?>(sql);
                }
                if (max == null) return Success(posList);
                DateTime min = max.Value.AddHours(-dto.Hours);
                var res = await GetPosResByTimeRangeObsolete(new PosRequestByTimeRangeDto()
                {
                    TaskInfoID = dto.TaskInfoID,
                    BeginTime = min,
                    EndTime = max.Value,
                    IncludeInvalidate = dto.IncludeInvalidate,
                    TarFrequpHz = dto.TarFrequpHz,
                });
                return res;
            }
            catch (Exception ex)
            {
                string msg = $"定位结果查询最新数据异常-任务编号:{dto.TaskInfoID},Hours:{dto.Hours}";
                XdCxRhDW.Framework.LogHelper.Error(msg, ex);
                return Error<List<ModelPosRes>>("定位结果查询最新数据异常");
            }
        }
        #endregion

        private PosResDto MapDto(ModelPosRes res)
        {
            var item = new PosResDto()
            {
                ID = res.ID,
                FreqUpHz = res.FreqUpHz,
                SigTime = res.SigTime,
                TaskInfoID = res.TaskInfoID,
                TarName = res.TargetName,
                PosLon = res.PosLon,
                PosLat = res.PosLat,
                MirrLon = res.MirrLon,
                MirrLat = res.MirrLat,
                CheckType = res.PosCheckType?.GetEnumDisplayName(),
                TargetState = (EnumTargetStateDto)res.TargetState,
                PosResType = (EnumPosResTypeDto)res.PosResType,
                Confidence = res.Confidence,
                CreateTime = res.CreateTime,
                UserName = res.UserName,
                Snr1 = res.Snr1,
                Snr2 = res.Snr2,
            };
            return item;
        }

    }
}