using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using DQ.Construction.NewLook.DataManager;
using WorkData;
using WorkData.Entity;

#region 文件说明
/*-----------------------------------------------------
* 版权所有 （c） 2024 jdfcd
* CLR版本 4.0.30319.42000
* 命名空间 DQ.Construction.NewLook.Utility
* 
* 创建者：pnpe
* 电子邮件：pnpe@qq.com
* 创建时间：2024/7/6 16:52:09
*/
#endregion 文件说明
namespace WellWorkDataUI
{
    public delegate void ProgressCallback(double progress);
    public delegate void ProgressCallbackTwo(int progress, int count);
    public delegate void ProgressCallbackThree(string name, int progress, int count);
    public class CalcDataHelp
    {
        public static void Reset()
        {
            sysDeflectionsDict.Clear();
        }
        private static Dictionary<string, WellDeflectionHelp> sysDeflectionsDict = new Dictionary<string, WellDeflectionHelp>();
        /// <summary>
        ///  坐标计算
        /// </summary>
        /// <typeparam name="T">自定义类</typeparam>
        /// <param name="list">数据list</param>
        /// <param name="getName">获取井号</param>
        /// <param name="getHeight">获取深度</param>
        /// <param name="onXY">回写xy方法</param>
        /// <returns>返回数据</returns>
        public static List<T> ComputedXYCoreDetectionOrVertical<T>(List<T> list, Func<T, string> getName, Func<T, (double? sd, double? cs)> getHeight, Action<T, double, double> onXY)
            where T : class
        {
            WellDeflectionHelp deflectionHelp = new WellDeflectionHelp();
            deflectionHelp.Initialize();
            global::System.Collections.Concurrent.ConcurrentBag<T> listUpdate = new ConcurrentBag<T>();
            Parallel.ForEach(list, item =>
            {
                double? x = 0, y = 0; // , v = 0;
                double? sd1 = getHeight(item).sd;
                double? cs1 = getHeight(item).cs;
                if (sd1.HasValue && deflectionHelp.ComputedXYByDetection(getName(item), sd1, ref x, ref y))
                {
                    onXY(item, x.GetValueOrDefault(0), y.GetValueOrDefault(0));
                    listUpdate.Add(item);
                }
                else if (cs1.HasValue && deflectionHelp.ComputedXYByVerticalNew(getName(item), cs1, ref x, ref y))
                {
                    onXY(item, x.GetValueOrDefault(0), y.GetValueOrDefault(0));
                    listUpdate.Add(item);
                }
            });
            return listUpdate.ToList();
        }

        /// <summary>
        /// Computeds the x y and z2 core single.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="getItem">The get item.</param>
        /// <param name="dic_calc">The dic_calc.</param>
        /// <param name="updateItem">The update item.</param>
        /// <returns>A T.</returns>
        public static T ComputedXYAndZ2CoreSingle<T>(T item, WellDeflectionHelp deflectionHelp, string JH, double? sd1, double? sd2, double? cs1, double? cs2, double? hd, double? v_hd, double? x, double? y, HashSet<int> dic_calc, Action<T, Dictionary<string, double?>> updateItem)
        {
            // 井斜xy
            Dictionary<string, double?> update = new Dictionary<string, double?>();
            if (cs1.HasValue && v_hd.HasValue && !cs2.HasValue)
            {
                cs2 = cs1.Value + v_hd.Value;
                update.Add("CS_B", cs2);
            }
            else if (cs2.HasValue && v_hd.HasValue && !cs1.HasValue)
            {
                cs1 = cs2.Value - v_hd.Value;
                update.Add("CS_T", cs1);
            }
            if (sd1.HasValue && hd.HasValue && !sd2.HasValue)
            {
                sd2 = sd1.Value + hd.Value;
                update.Add("DJSD", sd2);
            }
            else if (sd2.HasValue && hd.HasValue && !sd1.HasValue)
            {
                sd1 = sd2.Value - hd.Value;
                update.Add("SD", sd1);
            }

            // bool csStatus = true;
            // bool sdStatus = true;
            // if (!sd2.HasValue || !sd1.HasValue)
            // {
            //    sdStatus = false;
            // }
            // if (!cs2.HasValue || !cs1.HasValue)
            // {
            //    csStatus = false;
            // }
            if (dic_calc.Contains(3) && !cs1.HasValue && deflectionHelp.ComputedZByDetection(JH, sd1, ref cs1))
            {
                update.Add("CS_T", cs1);
            }
            if (dic_calc.Contains(4) && !cs2.HasValue && deflectionHelp.ComputedZByDetection(JH, sd2, ref cs2))
            {
                update.Add("CS_B", cs2);
            }

            // 垂深算测深
            if (dic_calc.Contains(1) && !sd1.HasValue && deflectionHelp.ComputedZByVertical(JH, cs1, ref sd1))
            {
                update.Add("SD", sd1);
            }
            // 垂深算测深
            if (dic_calc.Contains(2) && !sd2.HasValue && deflectionHelp.ComputedZByVertical(JH, cs2, ref sd2))
            {
                update.Add("DJSD", sd2);
            }
            if (!x.HasValue || !y.HasValue)
            {
                if (dic_calc.Contains(7) && sd1.HasValue && deflectionHelp.ComputedXYByDetection(JH, sd1, ref x, ref y))
                {
                    update.Add("X", x);
                    update.Add("Y", y);
                }
                else if (dic_calc.Contains(7) && cs1.HasValue && deflectionHelp.ComputedXYByVerticalNew(JH, cs1, ref x, ref y))
                {
                    update.Add("X", x);
                    update.Add("Y", y);
                }
            }
            updateItem(item, update);
            return item;
        }

        /// <summary>
        /// 使用多线程计算xyz
        /// </summary>
        /// <param name="list">The list.</param>
        /// <param name="getItem">The get item.</param>
        /// <param name="dic_calc">The dic_calc.</param>
        /// <param name="updateItem">The update item.</param>
        /// <returns>A list of TS.</returns>
        public static List<T> ComputedXYAndZ2Core<T>(List<T> list, Func<T, (string JH, double? sd1, double? sd2, double? cs1, double? cs2, double? hd, double? v_hd, double? x, double? y)> getItem, HashSet<int> dic_calc, Action<T, Dictionary<string, double?>> updateItem, ProgressCallback progressCallback)
            where T : class
        {
            int totalCount = list.Count;
            int processedCount = 0;
            ConcurrentBag<T> listUpdate = new ConcurrentBag<T>();

            Stopwatch sw = Stopwatch.StartNew();

            SimpleWell[] simpleWells = DBHelp.Db.Queryable<WellBase>().Select(it => new SimpleWell() { JH = it.JH, X = it.X.Value, Y = it.Y.Value })
                   .Where(it => it.X > 0 && it.Y > 0).ToArray();

            int i = 0;
            List<WellDeflection> wds = DBHelp.Db.Queryable<WellDeflection>().ToList();
            List<SimpleDeflection> wellDeflections = new List<SimpleDeflection>();

            Parallel.ForEach(wds, EntityHelp.Options, item =>
            {
                try
                {
                    i++;
                    if (item == null || string.IsNullOrWhiteSpace(item.JH) || sysDeflectionsDict.ContainsKey(item.JH))
                    {
                        return;
                    }
                    List<WellDeflection> itemDatas = EntityHelp.GetWellDeflections(item.FileName);
                    List<SimpleDeflection> sds = new List<SimpleDeflection>();
                    if (itemDatas != null && itemDatas.Any())
                    {
                        for (var j = 0; j < itemDatas.Count; j++)
                        {
                            var itemData = itemDatas[j];
                            var sd = new SimpleDeflection
                            {
                                JH = item.JH,
                                BZB = itemData.BZB.HasValue ? itemData.BZB.Value : 0,
                                DZB = itemData.DZB.HasValue ? itemData.DZB.Value : 0,
                                JS = itemData.JS.HasValue ? itemData.JS.Value : 0,
                                CS = itemData.CS.HasValue ? itemData.CS.Value : 0,
                            };
                            sds.Add(sd);
                        }
                    }

                    var deflectionHelp1 = new WellDeflectionHelp();
                    if (sds != null && sds.Count > 0)
                    {
                        deflectionHelp1.Initialize(item.JH, simpleWells, sds?.ToList().ToArray());
                    }
                    try
                    {
                        //Console.WriteLine($"******************{item.JH}*******************");
                        if (deflectionHelp1 != null)
                        {
                            sysDeflectionsDict.Add(item.JH, deflectionHelp1);
                        }
                        else
                        {
                            sysDeflectionsDict.Add(item.JH, new WellDeflectionHelp());
                        }
                    }
                    catch (Exception iex)
                    {
                        //Console.WriteLine($"******************{item.JH}*******************");
                        Console.WriteLine($"计算数据异常：{iex.Message}");
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"=============计算XYZ异常：{ex.Message} =======================");
                }
            });

            Console.WriteLine($"数据准备完毕{sw.Elapsed}");
            object obj = new object();
            Parallel.ForEach(list, (item, index) =>
            {
                string jh = getItem(item).JH;
                if (jh != null)
                {
                    double? sd1 = getItem(item).sd1;
                    double? sd2 = getItem(item).sd2;
                    double? cs1 = getItem(item).cs1;
                    double? cs2 = getItem(item).cs2;
                    double? hd = getItem(item).hd;
                    double? v_hd = getItem(item).v_hd;
                    double? x = getItem(item).x;
                    double? y = getItem(item).y;
                    WellDeflectionHelp deflectionHelp;
                    if (!sysDeflectionsDict.ContainsKey(jh))
                    {
                        deflectionHelp = new WellDeflectionHelp();
                        deflectionHelp.Initialize(jh, simpleWells, new List<SimpleDeflection>().ToArray());
                    }
                    else
                    {
                        deflectionHelp = sysDeflectionsDict[jh];
                    }
                    listUpdate.Add(ComputedXYAndZ2CoreSingle(item, deflectionHelp, jh, sd1, sd2, cs1, cs2, hd, v_hd, x, y, dic_calc, updateItem));
                    //Console.WriteLine($"{processedCount}耗时:{sw.Elapsed.TotalMilliseconds}");
                }
                Interlocked.Increment(ref processedCount);
                double currentProgress = processedCount * 100.00 / totalCount;
                if (currentProgress <= 100)
                {
                    progressCallback(currentProgress);
                }
            });

            sw.Stop();
            Console.WriteLine($"总耗时:{sw.Elapsed.TotalMilliseconds}");

            progressCallback(100);
            return listUpdate.ToList();
        }
    }
}