kev/Drawer/UCDraw/PcgDrawR_wellPole/WellWorkDataUI/helpers/DataHelp.cs

// ***********************************************************************
// Assembly         : Construction
// Author           : zjx
// Created          : 09-01-2020
//
// Last Modified By : zjx
// Last Modified On : 09-01-2020
// ***********************************************************************
// <copyright file="DataHelp.cs" company="jindongfang">
// Copyright (c) jindongfang. All rights reserved.
// </copyright>
// <summary></summary>
// ***********************************************************************
namespace WellWorkDataUI
{
    // using DQ.Construction.NewLook.Utility;
    using Newtonsoft.Json;
    using SqlSugar;
    using System;
    using System.Collections.Concurrent;
    using System.Collections.Generic;
    using System.Data;
    using System.Diagnostics;
    using System.IO;
    using System.Linq;
    using System.Linq.Expressions;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    using WorkData;
    using WorkData.Entity;

    /// <summary>
    /// 获取文件字符编码
    /// </summary>
    public class EncodingType
    {
        /// <summary>
        /// 给定文件的路径，读取文件的二进制数据，判断文件的编码类型
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <returns>文件的编码类型</returns>
        public static System.Text.Encoding GetType(string fileName)
        {
            FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
            Encoding r = GetType(fs);
            fs.Close();
            return r;
        }

        /// <summary>
        /// 通过给定的文件流，判断文件的编码类型
        /// </summary>
        /// <param name="fs">文件流</param>
        /// <returns>文件的编码类型</returns>
        public static System.Text.Encoding GetType(FileStream fs)
        {
            byte[] unicode = new byte[] { 0xFF, 0xFE, 0x41 };
            byte[] unicodeBIG = new byte[] { 0xFE, 0xFF, 0x00 };
            byte[] uTF8 = new byte[] { 0xEF, 0xBB, 0xBF }; // 带BOM

            BinaryReader r = new BinaryReader(fs, System.Text.Encoding.Default);
            int i;
            int.TryParse(fs.Length.ToString(), out i);
            byte[] ss = r.ReadBytes(i);
            Encoding reVal = GetType(ss);
            r.Close();
            return reVal;
        }
        /// <summary>
        /// 获得格式编码
        /// </summary>
        /// <param name="data">数据内容</param>
        /// <returns>编码</returns>
        public static System.Text.Encoding GetType(byte[] data)
        {
            Encoding reVal = Encoding.Default;
            if (IsUTF8Bytes(data) || (data[0] == 0xEF && data[1] == 0xBB && data[2] == 0xBF))
            {
                reVal = Encoding.UTF8;
            }
            else if (data[0] == 0xFE && data[1] == 0xFF && data[2] == 0x00)
            {
                reVal = Encoding.BigEndianUnicode;
            }
            else if (data[0] == 0xFF && data[1] == 0xFE && data[2] == 0x41)
            {
                reVal = Encoding.Unicode;
            }
            return reVal;
        }
        /// <summary>
        /// 判断是否是不带 BOM 的 UTF8 格式
        /// </summary>
        /// <param name="data">数据</param>
        /// <returns>是否UTF8</returns>
        private static bool IsUTF8Bytes(byte[] data)
        {
            int charByteCounter = 1;
            // 计算当前正分析的字符应还有的字节数
            byte curByte; // 当前分析的字节.
            for (int i = 0; i < data.Length; i++)
            {
                curByte = data[i];
                if (charByteCounter == 1)
                {
                    if (curByte >= 0x80)
                    {
                        // 判断当前
                        while (((curByte <<= 1) & 0x80) != 0)
                        {
                            charByteCounter++;
                        }
                        // 标记位首位若为非0 则至少以2个1开始 如:110XXXXX...........1111110X
                        if (charByteCounter == 1 || charByteCounter > 6)
                        {
                            return false;
                        }
                    }
                }
                else
                {
                    // 若是UTF-8 此时第一位必须为1
                    if ((curByte & 0xC0) != 0x80)
                    {
                        return false;
                    }
                    charByteCounter--;
                }
            }
            if (charByteCounter > 1)
            {
                throw new Exception("非预期的byte格式");
            }
            return true;
        }
    }
    /// <summary>
    /// 全局数据类(不变数据), 一次加载, 全局调用
    /// </summary>
    public static class DataHelp
    {
        private static ConcurrentDictionary<string, List<WellDeflection>> dictWellDeflection = new ConcurrentDictionary<string, List<WellDeflection>>();
        private static ConcurrentDictionary<string, List<InterpretDrillWellLayered>> dictWellLayer = new ConcurrentDictionary<string, List<InterpretDrillWellLayered>>();

        /// <summary>
        /// Gets the list system data tree.
        /// </summary>
        /// <value>The list system data tree.</value>
        public static List<GeologicalStratification> ListGeoLayer { get; } = new List<GeologicalStratification>();
        /// <summary>
        /// Gets the list system data tree.
        /// </summary>
        /// <value>The list system data tree.</value>
        public static List<SysDataTree> ListSysDataTree { get; } = new List<SysDataTree>();

        /// <summary>
        /// Gets the list table information.
        /// </summary>
        /// <value>The list table information.</value>
        public static List<TableInfo> ListTableInfo { get; } = new List<TableInfo>();

        /// <summary>
        /// Gets the list system dictionary.
        /// </summary>
        /// <value>The list system dictionary.</value>
        public static List<SysDictionary> ListSysDictionary { get; } = new List<SysDictionary>();

        /// <summary>
        /// 储层数据是否按(层位/井号)分组
        /// </summary>
        public static bool IsReservoirDataGroupByLayer { get; set; } = false;

        /// <summary>
        /// 井分层是否按(层位/井号)分组.
        /// </summary>
        public static bool IsDrillwelllayeredGroupByLayer { get; set; } = false;

        /// <summary>
        /// 井斜采样点大小, 为0表示不更新采样值
        /// </summary>
        public static double WellDeflectionCollectCount { get; set; } = 0d;

        /// <summary>
        /// 储层数据是否累加计算
        /// </summary>
        public static bool IsReservoirDataStat { get; set; } = true;

        /// <summary>
        /// ListColumnSearchWellName
        /// </summary>
        public static List<string> ListColumnSearchWellName { get; } = DBHelp.GetEntityColumnInfo(typeof(SearchWellName)).Select(o => o.DbColumnName).ToList();
        /// <summary>
        /// 工区边界缓存
        /// </summary>
      //  public static (DrawerRange range, string path) workBorder { get; set; } = (null, string.Empty);
        /// <summary>
        /// Resets the.
        /// </summary>
        public static void Reset()
        {
            dictWellDeflection.Clear();
            dictWellLayer.Clear();
            ListGeoLayer.Clear();
        }
        /// <summary>
        /// Clones the table.
        /// </summary>
        /// <param name="source">The source.</param>
        /// <param name="dest">The dest.</param>
        /// <param name="firstRowAsColumn">if set to <c>true</c> [first row as column].</param>
        /// <param name="count">The count.</param>
        public static void CloneTable(
            DataTable source,
            DataTable dest,
            bool firstRowAsColumn = false,
            int? count = null)
        {
            dest.Columns.Clear();
            dest.Rows.Clear();

            for (int i = 0; i < source.Columns.Count; i++)
            {
                string colName = firstRowAsColumn ? source.Rows[0][i].ToString() : source.Columns[i].ColumnName;

                while (dest.Columns.Contains(colName))
                {
                    colName += "_";
                }

                dest.Columns.Add(colName);
            }

            int startRow = firstRowAsColumn ? 1 : 0;
            int endRow = count == null ? source.Rows.Count : Math.Min(startRow + count.Value, source.Rows.Count);

            for (int i = startRow; i < endRow; i++)
            {
                dest.Rows.Add(source.Rows[i].ItemArray);
            }
        }

        /// <summary>
        /// Loads the data.
        /// </summary>
        /// <returns>Task</returns>
        public static async Task LoadData()
        {
            await LoadDataSysDataTree();

            await LoadDataTableInfo();

            await LoadDataSysDictionary();

            await LoadGeoLayer();
        }

        /// <summary>
        /// Loads the data system dictionary.
        /// </summary>
        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
        internal static async Task LoadDataSysDictionary()
        {
            ListSysDictionary.Clear();
            ListSysDictionary.AddRange(await DBHelp.NewDb.Queryable<SysDictionary>().ToListAsync());
        }
        /// <summary>
        /// Loads the data system data tree.
        /// </summary>
        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
        public static async Task LoadDataSysDataTree()
        {
            ListSysDataTree.Clear();
            ListSysDataTree.AddRange(await DBHelp.NewDb.Queryable<SysDataTree>().ToListAsync());
        }

        /// <summary>
        /// Loads the data system data tree.
        /// </summary>
        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
        public static async Task LoadGeoLayer()
        {
            ListGeoLayer.Clear();
            ListGeoLayer.AddRange(await DBHelp.NewDb.Queryable<GeologicalStratification>().ToListAsync());
        }
        /// <summary>
        /// Loads the data table information.
        /// </summary>
        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
        internal static async Task LoadDataTableInfo()
        {
            ListTableInfo.Clear();
            var list = await DBHelp.NewDb.Queryable<TableInfo>().ToListAsync();
            ListTableInfo.AddRange(list);
        }

        /// <summary>
        /// 同步井索引
        /// </summary>
        public static void SyncSearchWellName()
        {
            DBHelp.NewDb.UseTran(
                db =>
                {
                    db.Ado.ExecuteCommand(
                        @"insert into searchwellname(WellName, wellbase) 
                        select JH,1 from well_base a where not EXISTS(select wellname from searchwellname b where a.jh==b.wellname)");

                    db.Ado.ExecuteCommand(
                        @"delete from searchwellname where wellname is null");

                    db.Ado.ExecuteCommand(
                        @"update searchwellname as a set wellbase=(select count(*) from well_base b where a.wellname=b.jh)");

                    //曲线索引
                    List<string> wellCurves = db.Queryable<WellCurve>().Select(c => c.JH).ToList().Distinct().ToList();
                    db.Updateable<SearchWellName>().SetColumns(x => x.WellCurve == 1).Where(x => wellCurves.Contains(x.WellName)).ExecuteCommand();
                    db.Updateable<SearchWellName>().SetColumns(x => x.WellCurve == 0).Where(x => !wellCurves.Contains(x.WellName)).ExecuteCommand();

                    UpdateAllSearchWellNameCore(db);

                    // 清理全为0的井索引
                    db.Deleteable<SearchWellName>().Where(o => o.InterpretDrillWellLayered == 0
                        && o.WellBase == 0
                        && o.WellBreakPoint == 0
                        && o.WellCurve == 0
                        && o.WellTimeDepth == 0
                        && o.WellDeflection == 0
                        && o.CcsjYxhd == 0
                        && o.CcsjSyhd == 0
                        && o.CcsjBhd == 0
                        && o.CcsjKxd == 0
                        && o.CcsjStl == 0
                        && o.WellPerforation == 0).ExecuteCommand();
                });
        }

        /// <summary>
        /// 更新井索引
        /// </summary>
        /// <typeparam name="T">更新的列类型</typeparam>
        public static void UpdateSearchWellName<T>()
        {
            UpdateSearchWellNameCore<T>(DBHelp.NewDb);
        }

        /// <summary>
        /// Updates the name of the search well.
        /// </summary>
        /// <param name="t">The t.</param>
        public static void UpdateSearchWellName(Type t)
        {
            UpdateSearchWellNameCore(DBHelp.NewDb, t);
        }

        private static void UpdateSearchWellNameCore<T>(CustomSqlSugarClient db)
        {
            try
            {
                string columnname = typeof(T).Name;

                if (columnname.Equals("WellCurveFile"))
                {
                    columnname = "WellCurve";
                }//因为后面导入测井曲线都存到WellCurveFile表里去了，但是这个表里的字段名仍然为WellCurve

                string tablename = DBHelp.GetTableName<T>();

                string sql = string.Format(
                    @"update searchwellname as a set {0} = (select count(*) from {1} b where a.wellname=b.jh)",
                    columnname,
                    tablename);

                db.Ado.ExecuteCommand(sql);
            }
            catch (Exception /*ex*/)
            {
                // ex
            }
        }

        private static void UpdateSearchWellNameCore(CustomSqlSugarClient db, Type t)
        {
            try
            {
                string columnname = t.Name;
                string tablename = DBHelp.GetTableName(t);

                if (ListColumnSearchWellName.Any(o => string.Equals(o, columnname, StringComparison.CurrentCultureIgnoreCase)))
                {
                    string sql = string.Format(
                        @"update searchwellname as a set {0} = (select count(*) from {1} b where a.wellname=b.jh)",
                        columnname,
                        tablename);

                    db.Ado.ExecuteCommand(sql);
                }
            }
            catch (Exception /*ex*/)
            {
                // ex
            }
        }

        private static void UpdateAllSearchWellNameCore(CustomSqlSugarClient db)
        {
            Type tIdentify = typeof(IIdentifierEntity);

            List<SqlSugar.EntityInfo> list = EntityHelp.AllEntity
                .Where(o => tIdentify.IsAssignableFrom(o.Type))
                .ToList();

            foreach (SqlSugar.EntityInfo item in list)
            {
                UpdateSearchWellNameCore(db, item.Type);
            }
        }

        /// <summary>
        /// 更新井索引
        /// </summary>
        public static void UpdateAllSearchWellName()
        {
            UpdateAllSearchWellNameCore(DBHelp.NewDb);
        }

        /// <summary>
        /// 更新和同步层位名.
        /// </summary>
        /// <param name="id">The identifier.</param>
        /// <param name="name">The name.</param>
        public static void UpdateLayerName(int id, string name)
        {
            DBHelp.NewDb.UseTran(db =>
            {
                db.Updateable<InterpretLayer>(o => new InterpretLayer { CW = name })
                    .Where(o => o.ID == id)
                    .ExecuteCommand();

                db.Updateable<InterpretTimeLayer>(o => new InterpretTimeLayer { CW = name })
                    .Where(o => o.CWID == id)
                    .ExecuteCommand();

                db.Updateable<InterpretDepthLayer>(o => new InterpretDepthLayer { CW = name })
                    .Where(o => o.CWID == id)
                    .ExecuteCommand();

                db.Updateable<InterpretBoundary>(o => new InterpretBoundary { CW = name })
                    .Where(o => o.CWID == id)
                    .ExecuteCommand();

                db.Updateable<InterpretFault>(o => new InterpretFault { CW = name })
                    .Where(o => o.CWID == id)
                    .ExecuteCommand();

                db.Updateable<InterpretAttribute>(o => new InterpretAttribute { CW = name })
                    .Where(o => o.CWID == id)
                    .ExecuteCommand();
            });
        }

        /// <summary>
        /// 更新和同步层顺序.
        /// </summary>
        /// <param name="order">The order.</param>
        public static void UpdateLayerOrder(List<string> order)
        {
            DBHelp.NewDb.UseTran(db =>
            {
                for (int i = 0; i < order.Count; i++)
                {
                    db.Updateable<InterpretTimeLayer>(o => new InterpretTimeLayer { XHID = i })
                        .Where(o => o.CW == order[i])
                        .ExecuteCommand();

                    db.Updateable<InterpretDepthLayer>(o => new InterpretDepthLayer { XHID = i })
                        .Where(o => o.CW == order[i])
                        .ExecuteCommand();

                    db.Updateable<InterpretBoundary>(o => new InterpretBoundary { XHID = i })
                        .Where(o => o.CW == order[i])
                        .ExecuteCommand();

                    db.Updateable<InterpretFault>(o => new InterpretFault { XHID = i })
                        .Where(o => o.CW == order[i])
                        .ExecuteCommand();
                }
            });
        }

        /// <summary>
        /// 同步储层数据 （有效厚度发生变化）
        /// </summary>
        //public static void SyncReservoirData<T>(string v_jh, ProgressCallbackThree progressCallback = null)
        //{
        //    try
        //    {
        //        List<string> arys = new List<string>();
        //        if (typeof(T) == typeof(CcsjKxd))
        //        {
        //            arys = new List<string>() { "kxd", "bhd" };
        //        }
        //        else if (typeof(T) == typeof(CcsjBhd))
        //        {
        //            arys = new List<string>() { "bhd" };
        //        }
        //        else if (typeof(T) == typeof(CcsjStl))
        //        {
        //            arys = new List<string>() { "stl" };
        //        }
        //        else
        //        {
        //            arys = new List<string>() { "kxd", "bhd", "stl" };
        //        }

        //        //获取有效厚度
        //        List<CcsjYxhd> yxhds = DBHelp.NewDb.Queryable<CcsjYxhd>().WhereIF(!string.IsNullOrWhiteSpace(v_jh), x => x.JH == v_jh).ToList();

        //        Dictionary<string, List<CcsjYxhd>> dict_yxhds = yxhds.GroupBy(x => x.JH).ToDictionary(x => x.Key, x => x.ToList());

        //        List<CcsjKxd> kxds = DBHelp.NewDb.Queryable<CcsjKxd>().WhereIF(!string.IsNullOrWhiteSpace(v_jh), x => x.JH == v_jh).ToList();
        //        if (arys.Contains("kxd"))
        //        {
        //            int processedCount = 0;
        //            int totalCount = kxds.Count;
        //            Parallel.ForEach(kxds, kxd =>
        //            {
        //                if (dict_yxhds.TryGetValue(kxd.JH, out List<CcsjYxhd> hds))
        //                {
        //                    var hd = hds.Where(x => x.CW == kxd.CW);
        //                    if (kxd.DJSD1.HasValue)
        //                    {
        //                        hd = hd.Where(x => x.DJSD1 == kxd.DJSD1);
        //                    }
        //                    else
        //                    {
        //                        hd = hd.Where(x => x.YXCS_T == kxd.YXCS_T);
        //                    }
        //                    if (hd.Count() > 0)
        //                    {
        //                        if (kxd.YXHD == null)
        //                        {
        //                            kxd.YXHD = hd.Average(x => x.YXHD);
        //                        }

        //                        if (kxd.YXHD_CS == null)
        //                        {
        //                            kxd.YXHD_CS = hd.Average(x => x.YXCS_HD);
        //                        }
        //                    }
        //                }
        //                Interlocked.Increment(ref processedCount);
        //                progressCallback?.Invoke("同步有效到孔隙度", processedCount, totalCount);
        //            });
        //            DBHelp.NewDb.Fastest<CcsjKxd>().BulkUpdateAsync(kxds, new string[] { "JH", "CW", "ID" }, new string[] { "YXHD", "YXHD_CS" });
        //        }
        //        List<CcsjBhd> bhds = new List<CcsjBhd>();
        //        if (arys.Contains("bhd"))
        //        {
        //            bhds = DBHelp.NewDb.Queryable<CcsjBhd>().WhereIF(!string.IsNullOrWhiteSpace(v_jh), x => x.JH == v_jh).ToList();
        //            int processedCount = 0;
        //            int totalCount = bhds.Count;
        //            Parallel.ForEach(bhds, bhd =>
        //            {
        //                if (dict_yxhds.TryGetValue(bhd.JH, out List<CcsjYxhd> hds))
        //                {
        //                    var hd = hds.Where(x => x.CW == bhd.CW);
        //                    if (bhd.DJSD1.HasValue)
        //                    {
        //                        hd = hd.Where(x => x.DJSD1 == bhd.DJSD1);
        //                    }
        //                    else
        //                    {
        //                        hd = hd.Where(x => x.YXCS_T == bhd.YXCS_T);
        //                    }
        //                    if (hd.Count() > 0)
        //                    {
        //                        if (bhd.YXHD == null)
        //                        {
        //                            bhd.YXHD = hd.Average(x => x.YXHD);
        //                        }

        //                        if (bhd.YXHD_CS == null)
        //                        {
        //                            bhd.YXHD_CS = hd.Average(x => x.YXCS_HD);
        //                        }

        //                        var kx = kxds.Where(x => x.JH == bhd.JH && x.CW == bhd.CW);
        //                        if (bhd.DJSD1.HasValue)
        //                        {
        //                            kx = kx.Where(x => x.DJSD1 == bhd.DJSD1);
        //                        }
        //                        else
        //                        {
        //                            kx = kx.Where(x => x.YXCS_T == bhd.YXCS_T);
        //                        }
        //                        if (kx.Count() > 0)
        //                        {
        //                            bhd.KXD = kx.Average(x => x.KXD);
        //                        }
        //                    }
        //                }
        //                Interlocked.Increment(ref processedCount);
        //                progressCallback?.Invoke("同步有效和孔隙度到饱和度", processedCount, totalCount);
        //            });
        //            DBHelp.NewDb.Fastest<CcsjBhd>().BulkUpdateAsync(bhds, new string[] { "JH", "CW", "ID" }, new string[] { "YXHD", "YXHD_CS", "KXD" });
        //        }
        //        List<CcsjStl> stls = new List<CcsjStl>();
        //        if (arys.Contains("stl"))
        //        {
        //            stls = DBHelp.NewDb.Queryable<CcsjStl>().WhereIF(!string.IsNullOrWhiteSpace(v_jh), x => x.JH == v_jh).ToList();
        //            int processedCount = 0;
        //            int totalCount = stls.Count;
        //            Parallel.ForEach(stls, stl =>
        //            {
        //                if (dict_yxhds.TryGetValue(stl.JH, out List<CcsjYxhd> hds))
        //                {
        //                    var hd = hds.Where(x => x.CW == stl.CW);
        //                    if (stl.DJSD1.HasValue)
        //                    {
        //                        hd = hd.Where(x => x.DJSD1 == stl.DJSD1);
        //                    }
        //                    else
        //                    {
        //                        hd = hd.Where(x => x.YXCS_T == stl.YXCS_T);
        //                    }
        //                    if (hd.Count() > 0)
        //                    {
        //                        if (stl.YXHD == null)
        //                        {
        //                            stl.YXHD = hd.Average(x => x.YXHD);
        //                        }

        //                        if (stl.YXHD_CS == null)
        //                        {
        //                            stl.YXHD_CS = hd.Average(x => x.YXCS_HD);
        //                        }
        //                    }
        //                }
        //                Interlocked.Increment(ref processedCount);
        //                progressCallback?.Invoke("同步有效到渗透率", processedCount, totalCount);
        //            });
        //            DBHelp.NewDb.Fastest<CcsjStl>().BulkUpdateAsync(stls, new string[] { "JH", "CW", "ID" }, new string[] { "YXHD", "YXHD_CS" });
        //        }
        //    }
        //    catch (Exception)
        //    {
        //        // ignore Exception
        //    }
        //}

        /// <summary>
        /// 获取工区边界静态存储,如果导入新边界请清空此值
        /// </summary>
        public static object locker = new object();
        /// <summary>
        /// 获取工区边界对象
        /// </summary>
        /// <returns>工区边界及路径</returns>
        //public static (DrawerRange range, string path) GetWorkAreaOutLineRange()
        //{
        //    if (workBorder.range != null)
        //    {
        //        return workBorder;
        //    }
        //    else
        //    {
        //        lock (locker) // 存在并行调用，写入时加锁
        //        {
        //            WorkArea areaBorder = DBHelp.NewDb.Queryable<WorkArea>().First();
        //            if (areaBorder != null)
        //            {
        //                string workOutLinePath = Config.ProjectPath + areaBorder.PATH + "\\" + areaBorder.OUTFILENAME;
        //                if (File.Exists(workOutLinePath))
        //                {
        //                    CsharpFileUtility.DecodeOverrideFile(workOutLinePath);
        //                    Xy xy = new Xy();
        //                    xy.DfdRead(workOutLinePath);
        //                    var range = xy.GetCoordinateRange();
        //                    CsharpFileUtility.EncodeFile(workOutLinePath);
        //                    workBorder = (range, workOutLinePath);
        //                    return workBorder;
        //                }
        //            }
        //            return (null, string.Empty);
        //        }
        //    }
        //}

        /// <summary>
        // 更新序号
        // </summary>
        /// <param name="table">表</param>
        /// <param name="idColumn">序号列</param>
        /// <param name="orderColumn">排序列</param>
        public static void UpdateTableOrder(string table, string idColumn, string orderColumn)
        {
            DBHelp.NewDb.Ado.ExecuteCommandAsync($@"
with tmp as (select {idColumn}, row_number() over (order by {idColumn}) rn from {table} )

update {table}
set {orderColumn} = (
  select rn from tmp
  where tmp.{idColumn} = {table}.{idColumn}
);
");
        }

        /// <summary>
        /// 更新井斜xy
        /// </summary>
        public static void UpdateWellDeflectionXY()
        {
            DBHelp.NewDb.Ado.ExecuteCommandAsync($@"
with tmp as (select x,y,jh from well_base where jh in (select jh from well_deflection))

update well_deflection
set (x, y) = (
    select 
        x + well_deflection.DZB,
        y + well_deflection.BZB 
    from tmp 
    where tmp.jh == well_deflection.jh
);
");
            // KEPDataManager.NotifyChange<WellDeflection>();
        }

        /// <summary>
        /// Gets the column to rows.
        /// </summary>
        /// <param name="tableData">表名</param>
        /// <param name="columnNamesToReturn">返回值</param>
        /// <returns>A Dictionary.</returns>
        public static Dictionary<string, Dictionary<string, string>> GetCustomTableToRows(List<TableInfoValue> tableData, List<string> columnNamesToReturn = null)
        {
            // 并行将 List 转换为字典
            Dictionary<string, Dictionary<string, string>> dictionary = tableData
                .AsParallel()
                .GroupBy(data => data.RowGuid)
                .ToDictionary(
                    group => group.Key,
                    group => group.Where(data => columnNamesToReturn != null ? columnNamesToReturn.Contains(data.ColumnName) : true).ToDictionary(data => data.ColumnName, data => data.ColumnValue));

            return dictionary;
        }
        /// <summary>
        /// 获取动态表的压裂段
        /// </summary>
        /// <param name="expression">条件</param>
        /// <param name="columnNamesToReturn">返回列</param>
        /// <returns>返回对象压裂段</returns>
        public static List<T> GetCustomTable<T>(Expression<Func<T, bool>> expression = null, List<string> columnNamesToReturn = null)
        {
            //获取表名称
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            var tb = DBHelp.NewDb.Queryable<T>();
            if (expression != null)
            {
                tb = tb.Where(expression);
            }
            List<T> results = tb.ToList();
            stopwatch.Stop();
            Console.WriteLine($"曲线获取耗时：{stopwatch.Elapsed.TotalMilliseconds},条数：{results.Count}");
            if (typeof(T) == typeof(HoriWellFracturParameter))
            {
                List<HoriWellFracturParameter> specificResults = results.Cast<HoriWellFracturParameter>().ToList();
                specificResults.AsParallel().ForAll(x => x.ColumnValues = JsonConvert.DeserializeObject<Dictionary<string, string>>(x.ColumnValue));
                return specificResults.Cast<T>().ToList();
            }
            else
            {
                List<WellCurve> specificResults = results.Cast<WellCurve>().ToList();
                specificResults.AsParallel().ForAll(x => x.ColumnValues = JsonConvert.DeserializeObject<Dictionary<string, string>>(x.ColumnValue));
                return specificResults.Cast<T>().ToList();
            }
        }
        /// <summary>
        /// Gets the column to rows.
        /// </summary>
        /// <param name="expression">条件</param>
        /// <param name="columnNamesToReturn">返回值</param>
        /// <returns>A Dictionary.</returns>
        //public static List<WellCurve> GetCustomTableWellCurveT(Expression<Func<TableInfoValue, bool>> expression = null, List<string> columnNamesToReturn = null)
        //{
        //    Stopwatch stopwatch = new Stopwatch();
        //    stopwatch.Start();
        //    string tableName = DBHelp.GetTableName<WellCurve>();
        //    var tb = DBHelp.NewDb.Queryable<TableInfoValue>().Where(x => x.TableName == tableName);
        //    if (expression != null)
        //    {
        //        tb = tb.Where(expression);
        //    }
        //    List<TableInfoValue> tableData = tb.ToList();
        //    Console.WriteLine($"曲线获取耗时：{stopwatch.Elapsed.TotalMilliseconds},条数：{tableData.Count}");
        //    List<WellCurve> wellCurves = tableData
        //        .AsParallel()
        //        .GroupBy(data => new { data.RowGuid, data.RowID })
        //        .Select(group => new WellCurve() { RowID = group.Key.RowID, RowGuid = group.Key.RowGuid, DEPTH = Convert.ToDouble(group.FirstOrDefault(x => x.ColumnName == "DEPTH").ColumnValue), JH = group.FirstOrDefault(x => x.ColumnName == "JH").ColumnValue, ColumnValues = group.Where(data => columnNamesToReturn != null ? columnNamesToReturn.Contains(data.ColumnName) : true).ToDictionary(data => data.ColumnName, data => data.ColumnValue) }).ToList();

        //    stopwatch.Stop();
        //    Console.WriteLine($"列曲线转行耗时：{stopwatch.Elapsed.TotalMilliseconds},条数：{wellCurves.Count}");
        //    return wellCurves;
        //}

        /// <summary>
        /// 自定义表格行
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dictionary">传入数据</param>
        /// <param name="columnNamesToReturn">返回</param>
        /// <param name="columnName">列名</param>
        /// <param name="searchValues">搜索值</param>
        /// <returns>返回字典</returns>
        public static List<Dictionary<string, string>> SearchCustomTableToRows(Dictionary<string, Dictionary<string, string>> dictionary, List<string> columnNamesToReturn, string columnName, List<string> searchValues)
        {
            // 在字典中搜索并返回满足条件的所有行
            List<Dictionary<string, string>> searchResults = dictionary.AsParallel()
                .Where(kv => kv.Value.ContainsKey(columnName) && searchValues.Contains(kv.Value[columnName]))
                .Select(kv => kv.Value)
                .ToList();

            return searchResults;
        }

        /// <summary>
        /// 自定义表格行
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dictionary">字典</param>
        /// <param name="searchKeyValues">搜索值</param>
        /// <returns>List</returns>
        public static List<Dictionary<string, string>> SearchCustomTableToRows(Dictionary<int, Dictionary<string, string>> dictionary, Dictionary<string, string> searchKeyValues)
        {
            // 在字典中搜索并返回满足条件的所有行
            List<Dictionary<string, string>> searchResults = dictionary.AsParallel()
               .Where(kv => kv.Value.Keys.Intersect(searchKeyValues.Keys).Count() == searchKeyValues.Keys.Count)
               .Where(kv => searchKeyValues.All(entry => kv.Value.ContainsKey(entry.Key) && searchKeyValues[entry.Key] == entry.Value))
               .Select(kv => kv.Value)
               .ToList();
            return searchResults;
        }

        ///// <summary>
        ///// 获取压裂段坐标数据
        ///// </summary>
        ///// <returns>List<StagePointParameterData></returns>
        //public static List<StagePointParameterData> CalcHoriWellFracturCoord()
        //{
        //    List<StagePointParameterData> stageParamtersResult = new List<StagePointParameterData>();
        //    try
        //    {
        //        string tableName = DBHelp.GetTableName<HoriWellFracturParameter>();
        //        var columnNames = DBHelp.NewDb.Queryable<TableInfo>().Where(x => x.TableName == tableName).Select(x => new { En = x.ColumnName, CH = x.ChineseName }).ToList();
        //        var lst_coords = DBHelp.NewDb.Queryable<HoriWellFracturCoord>().ToList();
        //        List<HoriWellFracturParameter> list = GetCustomTable<HoriWellFracturParameter>();

        //        var lst_jhs = list.GroupBy(x => x.JH).Select(x => x.Key).ToList();

        //        string[] notColumns = { "ID", "XHID", "SYWZ1", "SYWZ2", "JH" };

        //        ConcurrentBag<StagePointParameterData> stageParamters = new ConcurrentBag<StagePointParameterData>();
        //        List<WellStagePoint> wellStagePoint = new List<WellStagePoint>();
        //        lst_coords.Select(x => new WellStagePoint()
        //        {
        //            JH = x.JH,
        //            Point = new DfPoint(x.X, x.Y),
        //            StageNo = x.XHID,
        //        });

        //        var lst_coord = lst_coords.GroupBy(x => new { x.JH, x.XHID }).Select(x => new { x.Key.JH, x.Key.XHID });
        //        //循环 压力段坐标分组井号和段序
        //        Parallel.ForEach(lst_coord, (coord) =>
        //           {
        //               var stageData = new StagePointParameterData()
        //               {
        //                   JH = coord.JH,
        //                   StageNo = coord.XHID,
        //               };
        //               var coords = lst_coords.Where(x => x.JH == coord.JH && x.XHID == coord.XHID).Select(x => new DfPoint() { X = x.X, Y = x.Y }).ToList();
        //               //需要判断2个以上
        //               stageData.StagePointRange = coords;
        //               //匹配压力段参数
        //               List<HoriWellFracturParameter> lstResult = list.Where(x => x.JH == coord.JH && x.XHID == coord.XHID).ToList();
        //               foreach (var pairs in lstResult)
        //               {
        //                   //行
        //                   ConcurrentDictionary<string, double> dicts = new ConcurrentDictionary<string, double>();
        //                   Parallel.ForEach(pairs.ColumnValues, (prop) =>
        //                    {
        //                        string dictName = prop.Key;
        //                        if (!notColumns.Contains(dictName))
        //                        {
        //                            if (columnNames.Any(x => x.En == prop.Key))
        //                            {
        //                                dictName = columnNames.FirstOrDefault(x => x.En == prop.Key).CH;
        //                            }
        //                            double d = 0;
        //                            string v = prop.Value.ToString();
        //                            if (v.Contains("-"))
        //                            {
        //                                string[] ary = v.Split('-');
        //                                double total = 0;
        //                                int count = 0;
        //                                foreach (var a in ary)
        //                                {
        //                                    if (string.IsNullOrWhiteSpace(a))
        //                                    {
        //                                        continue;
        //                                    }
        //                                    else if (double.TryParse(a, out double d1))
        //                                    {
        //                                        count++;
        //                                        total += d1;
        //                                    }
        //                                }
        //                                d = total / count;
        //                                dicts.TryAdd(dictName, d);
        //                            }
        //                            else if (v.Contains("~"))
        //                            {
        //                                string[] ary = v.Split('~');
        //                                double total = 0;
        //                                int count = 0;
        //                                foreach (var a in ary)
        //                                {
        //                                    if (string.IsNullOrWhiteSpace(a))
        //                                    {
        //                                        continue;
        //                                    }
        //                                    else if (double.TryParse(a, out double d1))
        //                                    {
        //                                        count++;
        //                                        total += d1;
        //                                    }
        //                                }
        //                                d = total / count;
        //                                dicts.TryAdd(dictName, d);
        //                            }
        //                            else if (double.TryParse(v, out d))
        //                            {
        //                                dicts.TryAdd(dictName, d);
        //                            }
        //                        }
        //                    });
        //                   stageData.ParamData = dicts.ToDictionary(x => x.Key, x => x.Value);
        //                   stageParamters.Add(stageData);
        //               }
        //           });
        //        var lst_jh = list.Where(x => !lst_coords.Any(c => c.JH == x.JH)).ToList();
        //        stageParamtersResult = stageParamters.ToList();
        //        if (lst_jh != null)
        //        {
        //            stageParamtersResult.AddRange(lst_jh.Select(x => new StagePointParameterData() { JH = x.JH, StageNo = "0", ParamData = new Dictionary<string, double>(), StagePointRange = new List<DfPoint>() }));
        //        }
        //    }
        //    catch
        //    {
        //    }
        //    return stageParamtersResult;
        //}

        /// <summary>
        /// 获取水平井的井支轨迹
        /// </summary>
        //private static void CalcHoriALLWellBranchTracksAsync(Action<List<WellStageTrack>> callback)
        //{
        //    Task.Run(() =>
        //    {
        //        List<WellStageTrack> wellStageTracks = new List<WellStageTrack>();
        //        var wellDeflections = DBHelp.NewDb.Queryable<WellDeflection>().Select(x => new { x.JH, x.X, x.Y }).ToList();
        //        foreach (var item in wellDeflections.GroupBy(x => new { x.JH }).Select(x => new { x.Key.JH }))
        //        {
        //            var stageTrack = new WellStageTrack { JH = item.JH };
        //            var coords = wellDeflections.Where(x => x.JH == item.JH && x.X.HasValue && x.Y.HasValue).Select(x => new DfPoint() { X = x.X.Value, Y = x.Y.Value }).ToList();
        //            stageTrack.Points = coords;
        //            wellStageTracks.Add(stageTrack);
        //        }
        //        callback(wellStageTracks);
        //    });
        //}

        /// <summary>
        /// 获取井斜
        /// </summary>
        /// <param name="wells">井号数据</param>
        /// <returns>获取井斜LIST</returns>
        public static List<WellDeflection> GetWellDeflections(List<string> wells)
        {
            List<WellDeflection> wellDeflections = new List<WellDeflection>();
            object obj = new object();
            wells = wells.Distinct().ToList();
            List<Task> tasks = new List<Task>();
            foreach (var jh in wells)
            {
                bool isSearch = false;
                lock (obj)
                {
                    if (!dictWellDeflection.ContainsKey(jh))
                    {
                        isSearch = true;
                    }
                }
                if (isSearch)
                {
                    tasks.Add(Task.Run(() =>
                    {
                        // 多线程访问db，使用新实例
                        using (var db = DBHelp.NewDb)
                        {
                            var lstDeflection = db.Queryable<WellDeflection>()
                                .Where(it => it.JH == jh && it.JS.HasValue)
                                .Select(x => new WellDeflection() { X = x.X, Y = x.Y, JS = x.JS, JH = x.JH }).ToList();
                            lock (obj)
                            {
                                dictWellDeflection.TryAdd(jh, lstDeflection);
                                wellDeflections.AddRange(lstDeflection);
                            }
                        }
                    }));
                }
                else
                {
                    lock (obj)
                    {
                        var lst = new List<WellDeflection>();
                        dictWellDeflection.TryGetValue(jh, out lst);
                        wellDeflections.AddRange(lst);
                    }
                }
            }
            Task.WaitAll(tasks.ToArray());
            Console.WriteLine(string.Join(string.Empty, wells) + "OK");
            return wellDeflections.ToList();
        }

        /// <summary>
        /// 获取井斜
        /// </summary>
        /// <param name="wells">井号数据</param>
        /// <returns>获取井斜LIST</returns>
        public static List<WellDeflection> GetWellDeflectionsAll(List<string> wells)
        {
            List<WellDeflection> wellDeflections = new List<WellDeflection>();
            object obj = new object();
            wells = wells.Distinct().ToList();
            List<Task> tasks = new List<Task>();
            foreach (var jh in wells)
            {
                bool isSearch = false;
                lock (obj)
                {
                    if (!dictWellDeflection.ContainsKey(jh))
                    {
                        isSearch = true;
                    }
                }
                if (isSearch)
                {
                    tasks.Add(Task.Run(() =>
                    {
                        // 多线程访问db，使用新实例
                        using (var db = DBHelp.NewDb)
                        {
                            var lstDeflection = db.Queryable<WellDeflection>()
                                .Where(it => it.JH == jh && it.JS.HasValue).ToList();
                            lock (obj)
                            {
                                dictWellDeflection.TryAdd(jh, lstDeflection);
                                wellDeflections.AddRange(lstDeflection);
                            }
                        }
                    }));
                }
                else
                {
                    lock (obj)
                    {
                        var lst = new List<WellDeflection>();
                        dictWellDeflection.TryGetValue(jh, out lst);
                        wellDeflections.AddRange(lst);
                    }
                }
            }
            Task.WaitAll(tasks.ToArray());
            Console.WriteLine(string.Join(string.Empty, wells) + "OK");
            return wellDeflections.ToList();
        }

        /// <summary>
        /// 获取所有井井斜数据
        /// </summary>
        /// <returns>井斜LIST</returns>
        public static List<WellDeflection> GetWellDeflectionsAllWell()
        {
            List<WellDeflection> wellDeflections = new List<WellDeflection>();
            // 多线程访问db，使用新实例
            using (var db = DBHelp.NewDb)
            {
                var lstDeflection = db.Queryable<WellDeflection>()
                    .Where(it => it.JS.HasValue).ToList();
                wellDeflections.AddRange(lstDeflection);
            }
            return wellDeflections.ToList();
        }

        /// <summary>
        /// 获取井分层数据
        /// </summary>
        /// <param name="wells">井号数据</param>
        /// <returns>分层井数据LIST</returns>
        public static List<InterpretDrillWellLayered> GetWellLayers(List<string> wells)
        {
            List<InterpretDrillWellLayered> wellLayereds = new List<InterpretDrillWellLayered>();
            using (var db1 = DBHelp.NewDb)
            {
                object obj = new object();
                wells = wells.Distinct().ToList();
                List<Task> tasks = new List<Task>();
                foreach (var jh in wells)
                {
                    bool isSearch = false;
                    lock (obj)
                    {
                        if (!dictWellLayer.ContainsKey(jh))
                        {
                            isSearch = true;
                        }
                    }
                    if (isSearch)
                    {
                        tasks.Add(Task.Run(() =>
                        {
                            var lstDeflection = db1.Queryable<InterpretDrillWellLayered>().Where(it => it.JH == jh && it.SD.HasValue).ToList();
                            lock (obj)
                            {
                                dictWellLayer.TryAdd(jh, lstDeflection);
                                wellLayereds.AddRange(lstDeflection);
                            }
                        }));
                    }
                    else
                    {
                        lock (obj)
                        {
                            var lst = new List<InterpretDrillWellLayered>();
                            dictWellLayer.TryGetValue(jh, out lst);
                            wellLayereds.AddRange(lst);
                        }
                    }
                }
                Task.WaitAll(tasks.ToArray());
            }
            return wellLayereds.ToList();
        }

        /// <summary>
        /// 获取所有层位
        /// </summary>
        /// <returns>层位数据LIST</returns>
        public static List<string> GetDistinctCWStrings()
        {
            using (var db = DBHelp.NewDb)
            {
                return db.Queryable<InterpretDrillWellLayered>()
                         .Where(it => it.CW != null)
                         .Select(it => it.CW)
                         .Distinct()
                         .ToList();
            }
        }



        /// <summary>
        /// 获取井分层数据
        /// </summary>
        /// <param name="wells">井号数据</param>
        /// <returns>分层井数据LIST</returns>
        public static List<InterpretDrillWellLayered> GetWellLayersNew(List<string> wells)
        {
            List<InterpretDrillWellLayered> wellLayereds = new List<InterpretDrillWellLayered>();

            object obj = new object();
            wells = wells.Distinct().ToList();
            List<Task> tasks = new List<Task>();
            foreach (var jh in wells)
            {
                bool isSearch = false;
                lock (obj)
                {
                    if (!dictWellLayer.ContainsKey(jh))
                    {
                        isSearch = true;
                    }
                }
                if (isSearch)
                {
                    tasks.Add(Task.Run(() =>
                    {
                        using (var db1 = DBHelp.NewDb)
                        {
                            var lstDeflection = db1.Queryable<InterpretDrillWellLayered>().Where(it => it.JH == jh && it.SD.HasValue).ToList();
                            lock (obj)
                            {
                                dictWellLayer.TryAdd(jh, lstDeflection);
                                wellLayereds.AddRange(lstDeflection);
                            }
                        }
                    }));
                }
                else
                {
                    lock (obj)
                    {
                        var lst = new List<InterpretDrillWellLayered>();
                        dictWellLayer.TryGetValue(jh, out lst);
                        wellLayereds.AddRange(lst);
                    }
                }
            }
            Task.WaitAll(tasks.ToArray());

            return wellLayereds.ToList();
        }

        public class WellCurveData
        {
            /// <summary>
            /// 井号
            /// </summary>
            public string JH { get; set; }

            /// <summary>
            /// 曲线列表
            /// </summary>
            public List<CurveData> CurveList { get; set; }
        }

        /// <summary>
        /// 曲线数据
        /// </summary>
        public class CurveData
        {
            /// <summary>
            /// 曲线名称
            /// </summary>
            public string CurveName { get; set; }

            /// <summary>
            /// 深度
            /// </summary>
            public double Depth { get; set; }

            /// <summary>
            /// 曲线浮度点
            /// </summary>
            public double Point { get; set; }
        }
        /// <summary>
        /// 获取测井曲线数据
        /// </summary>
        /// <returns>List<StagePointParameterData></returns>
        /// 
        public static List<WellCurveData> GetWellCurveDatas()
        {
            string tableName = DBHelp.GetTableName<WellCurve>();
            List<WellCurveData> wellCurveDatas = new List<WellCurveData>();
            List<TableInfo> lstColNames = DBHelp.NewDb.Queryable<TableInfo>().Where(x => x.TableName == tableName).ToList();
            List<WellCurve> list = GetCustomTable<WellCurve>();
            var lst_jh = list.GroupBy(x => x.JH).Select(x => x.Key).ToList();
            Parallel.ForEach(lst_jh, (jh) =>
            {
                var tableDatas = list.Where(x => x.JH == jh).ToList();
                WellCurveData wellCurveData = new WellCurveData() { JH = jh, CurveList = new List<CurveData>() };
                foreach (var row in tableDatas)
                {
                    var rowData = row.ColumnValue;
                    if (row.DEPTH < 0)
                    {
                        continue;
                    }
                    Dictionary<string, string> dict = JsonConvert.DeserializeObject<Dictionary<string, string>>(rowData);
                    foreach (var data in dict)
                    {
                        if (double.TryParse(data.Value.ToString(), out double point))
                        {
                            string colName = data.Key;
                            if (lstColNames.Any(x => x.ColumnName == colName))
                            {
                                colName = lstColNames.FirstOrDefault(x => x.ColumnName == colName).ChineseName;
                            }
                            wellCurveData.CurveList.Add(new CurveData() { Depth = row.DEPTH, CurveName = colName, Point = point });
                        }
                    }
                }
                wellCurveDatas.Add(wellCurveData);
            });
            return wellCurveDatas;
        }

        /// <summary>
        /// 从曲线文件表里获取测井曲线数据
        /// </summary>
        /// <returns>List<StagePointParameterData></returns>
        public static List<WellCurveData> GetWellCurveDatasFromFile()
        {
            List<WellCurveData> wellCurveDatas = new List<WellCurveData>();
            //拿到每一口井的路径
            List<WellCurveFile> wellCurveFiles = DBHelp.NewDb.Queryable<WellCurveFile>().ToList();
            //拿到路径后读文件 得到datatable
            foreach (var file in wellCurveFiles)
            {
                WellCurveData wellCurveData = new WellCurveData
                {
                    JH = file.JH,        // 井号
                    CurveList = new List<CurveData>()
                };

                List<CurveData> curveDatas = new List<CurveData>();
                wellCurveData.JH = file.JH;

                string filename = FileHelp.Convert2AbsolutePath(file.FilePath);
                DataTable dataTable = new DataTable();
                LasHelper.LasFileToDataTable(ref dataTable, filename, EncodingType.GetType(filename)?.BodyName, 0);

                if (dataTable.Rows.Count > 0 && dataTable.Columns.Count > 1)
                {
                    for (int i = 0; i < dataTable.Rows.Count; i++)
                    {
                        // 拿到这一行的 DEPTH 值（即第 0 列）
                        double depthVal = Convert.ToDouble(dataTable.Rows[i][0]);

                        // 从第 1 列开始，后续每一列的列名都是一个 CurveName
                        for (int j = 1; j < dataTable.Columns.Count; j++)
                        {
                            string curveName = dataTable.Columns[j].ColumnName;
                            // 当前行、当前列对应的数值
                            double pointVal = Convert.ToDouble(dataTable.Rows[i][j]);

                            // 构建 CurveData 并添加到列表
                            var curveData = new CurveData
                            {
                                CurveName = curveName,
                                Depth = depthVal,
                                Point = pointVal
                            };
                            wellCurveData.CurveList.Add(curveData);
                        }
                    }
                }
                wellCurveDatas.Add(wellCurveData);
            }

            return wellCurveDatas;
        }

        /// <summary>
        /// 通过井号获取 WellCurve 数据
        /// </summary>
        /// <param name="jh">井号</param>
        /// <returns>WellCurveData</returns>
        public static List<WellCurve> GetWellCurvesByJH(string jh)
        {
            if (string.IsNullOrWhiteSpace(jh))
            {
                return new List<WellCurve>();
            }

            try
            {
                // 获取井对应的文件信息
                var wellCurveFile = DBHelp.NewDb.Queryable<WellCurveFile>().First(item => item.JH == jh);
                if (wellCurveFile == null)
                {
                    return new List<WellCurve>();
                }

                // 获取文件路径
                string filename = FileHelp.Convert2AbsolutePath(wellCurveFile.FilePath);
                if (!File.Exists(filename))
                {
                    return new List<WellCurve>();
                }

                // 读取 LAS 文件并转换为 DataTable
                DataTable dataTable = new DataTable();
                LasHelper.LasFileToDataTable(ref dataTable, filename, EncodingType.GetType(filename)?.BodyName, 0);
                if (dataTable.Rows.Count == 0 || dataTable.Columns.Count <= 1)
                {
                    return new List<WellCurve>();
                }

                // 解析 DataTable 数据
                return dataTable.AsEnumerable()
                    .Select(row => new WellCurve
                    {
                        JH = jh,
                        DEPTH = Convert.ToDouble(row[0]),
                        ColumnValues = dataTable.Columns.Cast<DataColumn>()
                            .Skip(1)
                            .ToDictionary(col => col.ColumnName, col => row[col].ToString()),
                    })
                    .ToList();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"读取井曲线数据出错: {ex.Message}");
                return new List<WellCurve>();
            }
        }

        /// <summary>
        /// 列表转DataTable,用于自定义表
        /// </summary>
        /// <param name="list">The list.</param>
        /// <returns>A DataTable.</returns>
        public static DataTable ResTableByList<T>(List<T> list)
        {
            List<IDictionary<string, object>> lst_pairs = new List<IDictionary<string, object>>();
            //转换
            if (typeof(T) == typeof(HoriWellFracturParameter))
            {
                List<HoriWellFracturParameter> specificResults = list.Cast<HoriWellFracturParameter>().ToList();
                foreach (var item in specificResults)
                {
                    item.ColumnValues = JsonConvert.DeserializeObject<Dictionary<string, string>>(item.ColumnValue);
                    var dic = item.ColumnValues;
                    Dictionary<string, object> dynamicDictionary = new Dictionary<string, object>
                    {
                        { "JH", item.JH },
                        { "XHID", item.XHID },
                        { "SYWZ1", item.SYWZ1 },
                        { "SYWZ2", item.SYWZ2 },
                        { "RowID",item.RowID },
                    };
                    foreach (var k in dic)
                    {
                        if (!dynamicDictionary.ContainsKey(k.Key))
                        {
                            dynamicDictionary.Add(k.Key, k.Value);
                        }
                        else
                        {
                            dynamicDictionary[k.Key] = k.Value;
                            //这里存在错误,理论不应该出现此情况
                        }
                    }
                    lst_pairs.Add(dynamicDictionary);
                }
            }
            else if (typeof(T) == typeof(WellCurve))
            {
                List<WellCurve> specificResults = list.Cast<WellCurve>().ToList();
                foreach (var item in specificResults)
                {
                    item.ColumnValues = JsonConvert.DeserializeObject<Dictionary<string, string>>(item.ColumnValue);
                    var dic = item.ColumnValues;
                    Dictionary<string, object> dynamicDictionary = new Dictionary<string, object>
                    {
                        { "JH", item.JH },
                        { "DEPTH", item.DEPTH },
                        { "RowID",item.RowID },
                    };

                    foreach (var k in dic)
                    {
                        dynamicDictionary.Add(k.Key, k.Value);
                    }
                    lst_pairs.Add(dynamicDictionary);
                }
            }
            else
            {

            }
            // 创建一个包含所有可能键的 HashSet（用于去重）
            HashSet<string> allKeys = new HashSet<string>();
            // 遍历每个字典来收集所有可能的键
            foreach (var dict in lst_pairs)
            {
                foreach (var key in dict.Keys)
                {
                    allKeys.Add(key);
                }
            }

            // 创建一个新的 DataTable
            DataTable dataTable = new DataTable();

            // 添加所有可能的列
            foreach (var key in allKeys)
            {
                dataTable.Columns.Add(key, typeof(string));
            }

            // 将字典中的每个键值对添加到表中
            foreach (var dict in lst_pairs)
            {
                DataRow row = dataTable.NewRow();

                foreach (var kvp in dict)
                {
                    row[kvp.Key] = kvp.Value;
                }
                dataTable.Rows.Add(row);
            }
            return dataTable;
        }

        /// <summary>
        /// 通过井号获取 WellCurve 数据
        /// </summary>
        /// <param name="jh">井号</param>
        /// <returns>WellCurveData</returns>
        public static List<WellCurve> GetWellCurvesStream(string jh)
        {
            if (string.IsNullOrWhiteSpace(jh))
            {
                return new List<WellCurve>();
            }

            // 获取井对应的文件信息
            var wellCurveFile = DBHelp.NewDb.Queryable<WellCurveFile>().First(item => item.JH == jh);
            if (wellCurveFile == null)
            {
                return new List<WellCurve>();
            }

            // 获取文件路径
            string filename = FileHelp.Convert2AbsolutePath(wellCurveFile.FilePath);
            if (!File.Exists(filename))
            {
                return new List<WellCurve>();
            }

            return LasHelper.LasFileToList(jh, filename, EncodingType.GetType(filename)?.BodyName).ToList();
        }

        public static Dictionary<string, DataTable> SplitDataTableByColumn(DataTable originalTable, string columnName)
        {
            Dictionary<string, DataTable> groupedTables = new Dictionary<string, DataTable>();

            foreach (DataRow row in originalTable.Rows)
            {
                string columnValue = row[columnName].ToString();

                if (!groupedTables.ContainsKey(columnValue))
                {
                    DataTable newTable = originalTable.Clone();
                    groupedTables[columnValue] = newTable;
                }

                groupedTables[columnValue].ImportRow(row);
            }

            return groupedTables;
        }

        /// <summary>
        /// 同步储层数据 （有效厚度发生变化）
        /// </summary>
        public static void SyncReservoirData<T>(string v_jh, ProgressCallbackThree progressCallback = null)
        {
            try
            {
                List<string> arys = new List<string>();
                if (typeof(T) == typeof(CcsjKxd))
                {
                    arys = new List<string>() { "kxd", "bhd" };
                }
                else if (typeof(T) == typeof(CcsjBhd))
                {
                    arys = new List<string>() { "bhd" };
                }
                else if (typeof(T) == typeof(CcsjStl))
                {
                    arys = new List<string>() { "stl" };
                }
                else
                {
                    arys = new List<string>() { "kxd", "bhd", "stl" };
                }

                //获取有效厚度
                List<CcsjYxhd> yxhds = DBHelp.NewDb.Queryable<CcsjYxhd>().WhereIF(!string.IsNullOrWhiteSpace(v_jh), x => x.JH == v_jh).ToList();

                Dictionary<string, List<CcsjYxhd>> dict_yxhds = yxhds.GroupBy(x => x.JH).ToDictionary(x => x.Key, x => x.ToList());

                List<CcsjKxd> kxds = DBHelp.NewDb.Queryable<CcsjKxd>().WhereIF(!string.IsNullOrWhiteSpace(v_jh), x => x.JH == v_jh).ToList();
                if (arys.Contains("kxd"))
                {
                    int processedCount = 0;
                    int totalCount = kxds.Count;
                    Parallel.ForEach(kxds, kxd =>
                    {
                        if (dict_yxhds.TryGetValue(kxd.JH, out List<CcsjYxhd> hds))
                        {
                            var hd = hds.Where(x => x.CW == kxd.CW);
                            if (kxd.DJSD1.HasValue)
                            {
                                hd = hd.Where(x => x.DJSD1 == kxd.DJSD1);
                            }
                            else
                            {
                                hd = hd.Where(x => x.YXCS_T == kxd.YXCS_T);
                            }
                            if (hd.Count() > 0)
                            {
                                if (kxd.YXHD == null)
                                {
                                    kxd.YXHD = hd.Average(x => x.YXHD);
                                }

                                if (kxd.YXHD_CS == null)
                                {
                                    kxd.YXHD_CS = hd.Average(x => x.YXCS_HD);
                                }
                            }
                        }
                        Interlocked.Increment(ref processedCount);
                        progressCallback?.Invoke("同步有效到孔隙度", processedCount, totalCount);
                    });
                    DBHelp.NewDb.Fastest<CcsjKxd>().BulkUpdateAsync(kxds, new string[] { "JH", "CW", "ID" }, new string[] { "YXHD", "YXHD_CS" });
                }
                List<CcsjBhd> bhds = new List<CcsjBhd>();
                if (arys.Contains("bhd"))
                {
                    bhds = DBHelp.NewDb.Queryable<CcsjBhd>().WhereIF(!string.IsNullOrWhiteSpace(v_jh), x => x.JH == v_jh).ToList();
                    int processedCount = 0;
                    int totalCount = bhds.Count;
                    Parallel.ForEach(bhds, bhd =>
                    {
                        if (dict_yxhds.TryGetValue(bhd.JH, out List<CcsjYxhd> hds))
                        {
                            var hd = hds.Where(x => x.CW == bhd.CW);
                            if (bhd.DJSD1.HasValue)
                            {
                                hd = hd.Where(x => x.DJSD1 == bhd.DJSD1);
                            }
                            else
                            {
                                hd = hd.Where(x => x.YXCS_T == bhd.YXCS_T);
                            }
                            if (hd.Count() > 0)
                            {
                                if (bhd.YXHD == null)
                                {
                                    bhd.YXHD = hd.Average(x => x.YXHD);
                                }

                                if (bhd.YXHD_CS == null)
                                {
                                    bhd.YXHD_CS = hd.Average(x => x.YXCS_HD);
                                }

                                var kx = kxds.Where(x => x.JH == bhd.JH && x.CW == bhd.CW);
                                if (bhd.DJSD1.HasValue)
                                {
                                    kx = kx.Where(x => x.DJSD1 == bhd.DJSD1);
                                }
                                else
                                {
                                    kx = kx.Where(x => x.YXCS_T == bhd.YXCS_T);
                                }
                                if (kx.Count() > 0)
                                {
                                    bhd.KXD = kx.Average(x => x.KXD);
                                }
                            }
                        }
                        Interlocked.Increment(ref processedCount);
                        progressCallback?.Invoke("同步有效和孔隙度到饱和度", processedCount, totalCount);
                    });
                    DBHelp.NewDb.Fastest<CcsjBhd>().BulkUpdateAsync(bhds, new string[] { "JH", "CW", "ID" }, new string[] { "YXHD", "YXHD_CS", "KXD" });
                }
                List<CcsjStl> stls = new List<CcsjStl>();
                if (arys.Contains("stl"))
                {
                    stls = DBHelp.NewDb.Queryable<CcsjStl>().WhereIF(!string.IsNullOrWhiteSpace(v_jh), x => x.JH == v_jh).ToList();
                    int processedCount = 0;
                    int totalCount = stls.Count;
                    Parallel.ForEach(stls, stl =>
                    {
                        if (dict_yxhds.TryGetValue(stl.JH, out List<CcsjYxhd> hds))
                        {
                            var hd = hds.Where(x => x.CW == stl.CW);
                            if (stl.DJSD1.HasValue)
                            {
                                hd = hd.Where(x => x.DJSD1 == stl.DJSD1);
                            }
                            else
                            {
                                hd = hd.Where(x => x.YXCS_T == stl.YXCS_T);
                            }
                            if (hd.Count() > 0)
                            {
                                if (stl.YXHD == null)
                                {
                                    stl.YXHD = hd.Average(x => x.YXHD);
                                }

                                if (stl.YXHD_CS == null)
                                {
                                    stl.YXHD_CS = hd.Average(x => x.YXCS_HD);
                                }
                            }
                        }
                        Interlocked.Increment(ref processedCount);
                        progressCallback?.Invoke("同步有效到渗透率", processedCount, totalCount);
                    });
                    DBHelp.NewDb.Fastest<CcsjStl>().BulkUpdateAsync(stls, new string[] { "JH", "CW", "ID" }, new string[] { "YXHD", "YXHD_CS" });
                }
            }
            catch (Exception)
            {
                // ignore Exception
            }
        }
    }
}