// <copyright file="WellDistribute.cs" company="jindongfang">
// Copyright (c) jindongfang. All rights reserved.
// </copyright>

//using DfdIO;
//using DfdIO.DrawModel;
//using DQ.Construction.NewLook;
//using DQ.Construction.NewLook.Chart;
//using DQ.Construction.Util;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Text;
using WorkData;
using WorkData.Entity;
//using static DQ.Construction.NewLook.CtChart;

namespace WellWorkDataUI
{
    /// <summary>
    /// 井位分布.
    /// </summary>
    public class WellDistribute
    {
        private static readonly object BalanceLock = new object();
        /// <summary>
        /// 处理进度
        /// </summary>
        /// <param name="layerName">图层名称</param>
        public delegate void ProgressLayer(string layerName, bool isOk);

        // private string layerName;
        ///// <summary>
        ///// 地层
        ///// </summary>
        // public string LayerName
        // {
        //    get
        //    {
        //        return this.layerName;
        //    }
        //    set
        //    {
        //        this.layerName = value;
        //    }
        // }
        /// <summary>
        /// Initializes a new instance of the <see cref="WellDistribute"/> class.
        /// </summary>
        /// <param name="layerName">层位</param>
        public WellDistribute()
        {
            // this.layerName = layerName;
        }
        /// <summary>
        /// 根据测深计算井位坐标。TODO:是否与补芯有关
        /// </summary>
        /// <param name="wellName">井号</param>
        /// <param name="detection">测深</param>
        /// <param name="x">坐标X</param>
        /// <param name="y">坐标Y</param>
        /// <param name="vertical">垂深</param>
        /// <returns>是否计算成功</returns>
        public static bool ComputedXY(string wellName, double detection, ref double x, ref double y, ref double vertical)
        {
            // 井基础数据
            WellBase well = DBHelp.NewDb.Queryable<WellBase>()
                .Where(it => it.JH == wellName && it.X > 0 && it.Y > 0)
                .Select(it => new WellBase() { JH = it.JH, X = it.X, Y = it.Y }).First();

            int nCount = DBHelp.NewDb.Queryable<WellDeflection>()
                .Where(it => it.JH == wellName)
                .Select(it => it.JH).Count();
            if (nCount > 0)
            {
                var deflectionNext = DBHelp.NewDb.Queryable<WellDeflection>()
                    .Select(it => new { it.JH, it.BZB, it.DZB, it.JS, it.CS })
                    .Where(it => it.JH.Equals(wellName))
                    .Where(it => it.JS >= detection)
                    .OrderBy(it => it.JS, OrderByType.Asc)
                    .First();

                var deflectionBefore = DBHelp.NewDb.Queryable<WellDeflection>()
                    .Select(it => new { it.JH, it.BZB, it.DZB, it.JS, it.CS })
                    .Where(it => it.JH.Equals(wellName))
                    .Where(it => it.JS < detection)
                    .OrderBy(it => it.JS, OrderByType.Desc)
                    .First();

                if (deflectionNext != null && deflectionBefore != null)
                {
                    // 斜井，计算层位坐标
                    double dBefore = deflectionBefore.JS.Value;
                    double dNext = deflectionNext.JS.Value;
                    double dFactor = (detection - dBefore) / (dNext - dBefore);
                    // 东坐标
                    double dOffsetX = (dFactor * (deflectionNext.DZB - deflectionBefore.DZB).Value)
                                              + deflectionBefore.DZB.Value;
                    // 北坐标
                    double dOffsetY = (dFactor * (deflectionNext.BZB - deflectionBefore.BZB).Value)
                                      + deflectionBefore.BZB.Value;
                    // 坐标X
                    x = well.X.Value + dOffsetX;
                    // 坐标Y
                    y = well.Y.Value + dOffsetY;
                    // 垂深
                    double dLastCS = deflectionBefore.CS.Value;
                    double dNextCS = deflectionNext.CS.Value;
                    vertical = (dFactor * (dNextCS - dLastCS)) + dLastCS;

                    return true;
                }
                else if (deflectionNext == null && deflectionBefore != null)
                { // 仅有上层数据时
                    // 坐标X
                    x = well.X.Value + deflectionBefore.DZB.Value;
                    // 坐标Y
                    y = well.Y.Value + deflectionBefore.BZB.Value;
                    // 垂深
                    double dLastCS = deflectionBefore.CS.Value;
                    vertical = dLastCS + (detection - deflectionBefore.JS.Value);
                    return true;
                }
                else if (deflectionNext != null && deflectionBefore == null)
                { // 仅有下层数据时
                    double dBefore = 0;
                    double dNext = deflectionNext.JS.Value;
                    double dFactor = (detection - dBefore) / (dNext - dBefore);
                    // 东坐标
                    double dOffsetX = dFactor * deflectionNext.DZB.Value;
                    // 北坐标
                    double dOffsetY = dFactor * deflectionNext.BZB.Value;
                    // 坐标X
                    x = well.X.Value + dOffsetX;
                    // 坐标Y
                    y = well.Y.Value + dOffsetY;
                    // 垂深
                    double dLastCS = 0;
                    double dNextCS = deflectionNext.CS.Value;
                    vertical = (dFactor * (dNextCS - dLastCS)) + dLastCS;
                    return true;
                }
            }
            else
            {
                if (well != null)
                {
                    x = well.X.Value;
                    y = well.Y.Value;
                    vertical = detection;
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 创建井位分布图
        /// </summary>
        /// <param name="layers">层位数据字典</param>
        /// <param name="action">处理的层位</param>
        /// <returns>是否成功</returns>
        //public bool CreateWellDistributes(Dictionary<string, LeafNodeData> layers, ProgressLayer action)
        //{
        //    foreach (var layer in layers.Keys)
        //    {
        //        this.CreateWellDistribute(layer, layers[layer], action);
        //    }
        //    return true;
        //}

        /// <summary>
        /// 创建工区井位分布图
        /// </summary>
        /// <param name="filePath">保存路径</param>
        /// <param name="action"></param>
        /// <param name="tag"></param>
        /// <returns></returns>
        //public bool CreateWorkspaceDistribute(string filePath, ProgressLayer action, LeafNodeData tag)
        //{
        //    Action<string> writeWells = (drawFile) =>
        //        {
        //            var template = tag.Param.OtherData;
        //            var workWells = this.GetWorkspaceWells(template);

        //            List<string> wells = workWells.Select(w => $@"{w.JB},{w.JH}").ToList();
        //            tag.Param.OtherData.Wells = wells;
        //            tag.Param.WriteData(); // 设置默认选中井

        //            using (StreamWriter sw = new StreamWriter(drawFile, true, Encoding.Default))
        //            {
        //                foreach (var well in workWells)
        //                {
        //                    sw.WriteLine($"Layer M {well.JB}");
        //                    // 3dPoint X,Y,Z,0,井号
        //                    sw.WriteLine($"3dPoint {well.X},{well.Y},{0} 0 {well.JH}");
        //                }
        //            }
        //        };

        //    var wResult = this.WriteWellDistributeFile(filePath, writeWells, action);
        //    return wResult;
        //}

        //private bool WriteWellDistributeFile(string drawFile, Action<string> writeWells, ProgressLayer action)
        //{
        //    // 写文件头
        //    DfdWriter dfdWriter = new DfdWriter(drawFile);
        //    dfdWriter.WriteHead(false);

        //    // 写符号
        //    string strSymbolFile = FileHelp.GetDefaultSymbolFile();
        //    if (!string.IsNullOrEmpty(strSymbolFile))
        //    {
        //        string strSymbolData = string.Empty;
        //        using (StreamReader sr = new StreamReader(strSymbolFile, Encoding.Default))
        //        {
        //            strSymbolData = sr.ReadToEnd();
        //        }

        //        using (StreamWriter sw = new StreamWriter(drawFile, true, Encoding.Default))
        //        {
        //            sw.WriteLine(strSymbolData);
        //        }
        //    }
        //    // 写井
        //    writeWells.Invoke(drawFile);

        //    // 回调事件
        //    if (action != null)
        //    {
        //        action(drawFile, true);
        //    }
        //    return true;
        //}

        /// <summary>
        /// 创建井位分布图
        /// </summary>
        /// <param name="layerName">层位</param>
        /// <param name="nodeData">层位数据</param>
        /// <param name="action">完成后的事件</param>
        /// <returns>是否成功</returns>
        //public bool CreateWellDistribute(string layerName, LeafNodeData nodeData, ProgressLayer action)
        //{
        //    bool isOk = false;

        //    string drawFile = FileHelp.GetWellDeployFile(layerName);
        //    if (nodeData.TreeType == TreeTypeClass.WellDeploy && File.Exists(drawFile))
        //    {
        //        // 图件已存在不需要写井
        //        isOk = true;
        //    }

        //    var template = nodeData.Param.OtherData;
        //    var lstWells = this.GetWellsFromDB(layerName, template);

        //    if (lstWells.Count > 0)
        //    {
        //        drawFile = FileHelp.GetWellDistributeFile(layerName);
        //        if (nodeData.TreeType == TreeTypeClass.WellDeploy)
        //        {
        //            drawFile = FileHelp.GetWellDeployFile(layerName);
        //        }

        //        // 写文件头
        //        DfdWriter dfdWriter = new DfdWriter(drawFile);
        //        dfdWriter.WriteHead(false);

        //        // 写符号
        //        string strSymbolFile = FileHelp.GetDefaultSymbolFile();
        //        if (!string.IsNullOrEmpty(strSymbolFile))
        //        {
        //            CsharpFileUtility.DecodeOverrideFile(strSymbolFile);
        //            string strSymbolData = string.Empty;
        //            using (StreamReader sr = new StreamReader(strSymbolFile, Encoding.Default))
        //            {
        //                strSymbolData = sr.ReadToEnd();
        //            }

        //            using (StreamWriter sw = new StreamWriter(drawFile, true, Encoding.Default))
        //            {
        //                sw.WriteLine(strSymbolData);
        //            }
        //        }

        //        template.Wells = lstWells.Select(w => $@"{w.JB},{w.JH}").ToList();

        //        // 写井
        //        using (StreamWriter sw = new StreamWriter(drawFile, true, Encoding.Default))
        //        {
        //            foreach (var well in lstWells)
        //            {
        //                // 井号 井别 X Y 垂深 测深
        //                sw.WriteLine($"Layer M {well.JB}");
        //                sw.WriteLine($"3dPoint {well.X},{well.Y},{well.SD} 0 {well.JH}");
        //            }
        //        }

        //        isOk = true;
        //    }

        //    // 回调事件
        //    action?.Invoke(layerName, isOk);
        //    return isOk;
        //}

        /// <summary>
        /// 从数据库获得井的坐标和深度
        /// </summary>
        /// <returns>井数据： 井号 井别 X Y 垂深 测深</returns>
        //private List<(string JH, string JB, double X, double Y, double CS, double SD)> GetWellsFromDB(string layerName, MergeTemplate template)
        //{
        //    var wells = new List<(string, string, double, double, double, double)>();
        //    var lstWells = DBHelp.NewDb.Queryable<InterpretDrillWellLayered, WellBase>(
        //            (layer, well) => new JoinQueryInfos(JoinType.Left, layer.JH == well.JH))
        //            .Where((layer, well) => layer.CW.ToUpper().Equals(SqlFunc.ToUpper(layerName)))
        //            .Where((layer, well) => layer.SD != null)
        //            .Where((layer, well) => layer.X != null)
        //            .Select((layer, well) => new { well.CXB, well.JB, well.MQJB, layer.JH, layer.SD, layer.X, layer.Y, well.BXHB })
        //            .ToList();

        //    Dictionary<string, string> dictJBs = new Dictionary<string, string>();

        //    // 获取井别数据
        //    DataTable tbWell = DBHelp.Db.Queryable<WellBase>().ToDataTable();
        //    foreach (DataRow dr in tbWell.Rows)
        //    {
        //        string strLayer = BatchChartHelper.ParseWellLayerStrByMergeGroup(template.WellGroups, dr);
        //        dictJBs.Add(dr["JH"] + string.Empty, strLayer);

        //        if (!template.LegendLayers.Contains(strLayer))
        //        {
        //            template.LegendLayers.Add(strLayer);
        //        }
        //    }

        //    foreach (var well in lstWells)
        //    {
        //        var strJB = dictJBs.ContainsKey(well.JH) ? dictJBs[well.JH] : well.MQJB;
        //        var sd = well.BXHB ?? 0;
        //        var addCxb = template.WellGroups.Contains(nameof(well.CXB)) && !string.IsNullOrEmpty(well.CXB);
        //        wells.Add((well.JH,
        //                addCxb ? well.CXB + "\\" + strJB : strJB,
        //                well.X.Value,
        //                well.Y.Value,
        //                0D,                                             // 垂深
        //                (well.SD.Value - sd) * -1));                       // 测深
        //    }
        //    return wells;
        //}

        ///// <summary>
        ///// 获取工区井位数据
        ///// </summary>
        ///// <param name="layerName"></param>
        ///// <returns>井数据： 井号 井别 X Y</returns>
        //private List<(string JH, string JB, double X, double Y)> GetWorkspaceWells(MergeTemplate template)
        //{
        //    var wells = new List<(string, string, double, double)>();
        //    var wellGroup = DBHelp.NewDb.Queryable<WellBase>().Select(well => new { well.JH, well.JB, well.MQJB, well.X, well.Y, well.BXHB })
        //        .ToList();

        //    Dictionary<string, string> dictJBs = new Dictionary<string, string>();

        //    // 获取井别数据
        //    DataTable tbWell = DBHelp.Db.Queryable<WellBase>().ToDataTable();
        //    foreach (DataRow dr in tbWell.Rows)
        //    {
        //        string strLayer = BatchChartHelper.ParseWellLayerStrByMergeGroup(template.WellGroups, dr);
        //        dictJBs.Add(dr["JH"] + string.Empty, strLayer);

        //        if (!template.LegendLayers.Contains(strLayer))
        //        {
        //            template.LegendLayers.Add(strLayer);
        //        }
        //    }

        //    foreach (var well in wellGroup)
        //    {
        //        var strJB = dictJBs.ContainsKey(well.JH) ? dictJBs[well.JH] : well.MQJB;
        //        wells.Add((well.JH, strJB, well.X.Value, well.Y.Value));
        //    }
        //    //var wells = new List<(string, string, double, double, double)>();
        //    //var wellGroup = DBHelp.NewDb.Queryable<WellBase>().LeftJoin<InterpretDrillWellLayered>((well, l) => well.JH == l.JH)
        //    //    .Select((well, l) => new { well.JH, well.JB, well.MQJB, well.X, well.Y, l.SD, well.BXHB })
        //    //    .ToList();
        //    //foreach (var well in wellGroup)
        //    //{
        //    //    string strJB = BatchChartHelper.GetJBNameByID(well.JB ?? well.MQJB);
        //    //    double z = 0f;
        //    //    if (well.SD.HasValue && well.SD.Value > 0 && well.BXHB.HasValue)
        //    //    {
        //    //        z = (well.SD.Value - well.BXHB.Value) * -1;
        //    //    }
        //    //    wells.Add((well.JH, strJB, well.X.Value, well.Y.Value, z));
        //    //}
        //    return wells;
        //}

        /// <summary>
        /// 生成层位井分布数据
        /// </summary>
        /// <param name="layerName">层位名</param>
        /// <param name="borderFile">边界文件</param>
        /// <param name="useInclined">使用斜井</param>
        /// <returns>是否成功</returns>
        //public static bool CreateLayerWells(string layerName, string borderFile = null, bool useInclined = false)
        //{
        //    NtsGeometryServices.Instance = new NtsGeometryServices(
        //            CoordinateArraySequenceFactory.Instance,
        //            new PrecisionModel(1d),
        //            4326);
        //    GeometryFactory gf = NtsGeometryServices.Instance.CreateGeometryFactory();

        //    // 读取计算配置
        //    GlobalSetting globalSetting = GlobalSetting.ReadFromFile();
        //    // 排除的井
        //    List<string> lstWellsExclude = new List<string>();
        //    string strFileAdjustExclude = FileHelp.GetAdjustFileExclude(TreeTypeClass.Deep.Type, layerName);
        //    if (File.Exists(strFileAdjustExclude))
        //    {
        //        using (StreamReader sw = new StreamReader(
        //        File.Open(strFileAdjustExclude, FileMode.Open, FileAccess.Read),
        //        Encoding.Default))
        //        {
        //            string strLine;
        //            while ((strLine = sw.ReadLine()) != null)
        //            {
        //                if (!string.IsNullOrWhiteSpace(strLine))
        //                {
        //                    lstWellsExclude.Add(strLine);
        //                }
        //            }
        //        }
        //    }
        //    List<Geometry> lstBorder = new List<Geometry>();
        //    if (File.Exists(borderFile))
        //    {
        //        List<LineString> lstLine = new List<LineString>();
        //        Xy reader = new Xy();
        //        bool bEncode = CsharpFileUtility.DecodeOverrideFile(borderFile);
        //        reader.DfdRead(borderFile);
        //        if (bEncode)
        //        {
        //            CsharpFileUtility.EncodeFile(borderFile);
        //        }
        //        foreach (DrawerElementBase element in reader.Elements)
        //        {
        //            if (element is DrawerLine drawerLine)
        //            {
        //                List<Coordinate> coordinates = new List<Coordinate>();
        //                foreach (DrawerLineNode node in drawerLine.Nodes)
        //                {
        //                    coordinates.Add(new Coordinate(node.X, node.Y));
        //                }
        //                if (coordinates.Count > 0)
        //                {
        //                    if (coordinates[0] != coordinates[coordinates.Count - 1])
        //                    {
        //                        coordinates.Add(new Coordinate(coordinates[0].X, coordinates[0].Y));
        //                    }
        //                    Polygon polygon = gf.CreatePolygon(coordinates.ToArray());
        //                    //lstBorder.Add(polygon.Buffer(1));
        //                    lstBorder.Add(polygon);
        //                }
        //            }
        //        }
        //    }

        //    List<Tuple<string, double, double, double>> wellData = new List<Tuple<string, double, double, double>>();
        //    //if (!useInclined)
        //    //{
        //    //.Where((layer, wellBase) => SqlFunc.Subqueryable<WellDeflection>().Where(s => s.JH == layer.JH).NotAny())
        //    var straightWells = DBHelp.NewDb.Queryable<InterpretDrillWellLayered, WellBase>(
        //            (layer, wellBase) => new JoinQueryInfos(JoinType.Inner, layer.JH == wellBase.JH))
        //            .Where((layer, wellBase) => SqlFunc.ToUpper(layer.CW) == SqlFunc.ToUpper(layerName))
        //            .Where((layer, wellBase) => layer.SD > 0)
        //            .Where((layer, wellBase) => wellBase.X != null)
        //            .Select((layer, wellBase) => new { layer.JH, layer.CW, layer.SD, wellBase.BXHB, wellBase.X, layerX = layer.X, layerY = layer.Y, wellBase.Y, layer.CS_T })
        //            .ToList();
        //    // int nIndex = 0;

        //    foreach (var well in straightWells)
        //    {
        //        // nIndex++;
        //        // Trace.WriteLine($"{nIndex}: {well.JH}, {well.X}, {well.Y}, {well.SD}, {well.BXHB}");
        //        if (lstWellsExclude.Contains(well.JH))
        //        {
        //            continue;
        //        }
        //        if (well.X == null || well.Y == null || well.X.Value * well.Y.Value == 0)
        //        {
        //            continue;
        //        }
        //        // 排除边界外的井
        //        if (lstBorder.Count > 0)
        //        {
        //            bool isOut = false;
        //            foreach (Geometry border in lstBorder)
        //            {
        //                Point pt = gf.CreatePoint(new Coordinate(well.X.Value, well.Y.Value));
        //                if (!border.Contains(pt))
        //                {
        //                    isOut = true;
        //                    break;
        //                }
        //            }
        //            if (isOut == true)
        //            {
        //                continue;
        //            }
        //        }
        //        bool bWithKellyBushing = WorkspaceConfig.Instance.FindConfigValue<bool>("LayerAdjust", "UseKellyBushing", true);
        //        double sd = well.SD ?? 0;
        //        bool is_awry = DBHelp.Db.Queryable<WellDeflection>().Any(d => d.JH == well.JH);
        //        double x = well.X.Value;
        //        double y = well.Y.Value;
        //        if (is_awry)
        //        {
        //            sd = well.CS_T ?? 0;
        //            x = well.layerX.Value;
        //            y = well.layerY.Value;
        //        }
        //        if (bWithKellyBushing)
        //        {
        //            // 已考虑了补心海拔
        //            wellData.Add(Tuple.Create(
        //                  well.JH,
        //                  x,
        //                  y,
        //                  sd - (well.BXHB ?? 0)));
        //        }
        //        else
        //        {
        //            wellData.Add(Tuple.Create(
        //                  well.JH,
        //                  x,
        //                  y,
        //                  sd));
        //        }
        //    }

        //    if (false)
        //    {
        //        //}
        //        // 如果考虑斜井
        //        // 获得所有斜井井号
        //        //List<Tuple<string, double>> lstDefWell = new List<Tuple<string, double>>();
        //        //var lstDef = DBHelp.NewDb.Queryable<WellDeflection, WellBase>(
        //        //    (def, well) => new JoinQueryInfos(JoinType.Left, def.JH == well.JH))
        //        //    .Select((def, well) => new { JH = def.JH, well.BXHB })
        //        //    .GroupBy(def => def.JH).ToList();

        //        //lstDef = DBHelp.NewDb.Queryable<WellDeflection, WellBase>(
        //        //    (def, well) => new JoinQueryInfos(JoinType.Left, def.JH == well.JH))
        //        //    .Select((def, well) => new { JH = def.JH, well.BXHB })
        //        //    .MergeTable()
        //        //    .GroupBy(it => it.JH).ToList();
        //        DataTable dtLayerWellsDef = DBHelp.NewDb.Queryable<InterpretDrillWellLayered, WellBase>(
        //                   (layer, wellBase) => new JoinQueryInfos(JoinType.Inner, layer.JH == wellBase.JH))
        //                   // .Where((layer, wellBase) => layer.JH.Equals(wellName))
        //                   .Where((layer, wellBase) => SqlFunc.ToUpper(layer.CW) == SqlFunc.ToUpper(layerName))
        //                   .Where((layer, wellBase) => layer.SD > 0)
        //                   .Where((layer, wellBase) => wellBase.X != null)
        //                   .Where((layer, wellBase) => SqlFunc.Subqueryable<WellDeflection>().Where(s => s.JH == layer.JH).Any())
        //                   .Select((layer, wellBase) => new { layer.JH, layer.SD, wellBase.BXHB, wellBase.X, wellBase.Y })
        //                   //.OrderBy(it=>it.JH)
        //                   //.OrderBy(it=>it.SD)
        //                   .ToDataTable();
        //        // var lstDefWell = DBHelp.NewDb.Queryable<WellDeflection>().Select(it => it.JH).Distinct().ToList();
        //        DataTable dtDrill = DBHelp.NewDb.Queryable<WellDeflection>()
        //            .Select(it => new { it.JH, it.BZB, it.DZB, it.JS, it.CS })
        //            //.Where(it => it.BZB != null && it.DZB != null)
        //            .OrderBy(it => it.JH)
        //            .OrderBy(it => it.CS)
        //            .ToDataTable();

        //        // int n = lstDefWell.Count;
        //        DataRowCollection drs = dtLayerWellsDef.Rows;
        //        string wellName = string.Empty;
        //        // 获得层位上的井,包括层位、测深
        //        foreach (DataRow drWell in drs)
        //        {
        //            wellName = drWell[0].ToString();                    // JH-井号
        //            if (lstWellsExclude.Contains(wellName))
        //            {
        //                continue;
        //            }
        //            // 排除边界外的井
        //            bool isOut = false;
        //            foreach (Geometry border in lstBorder)
        //            {
        //                if (!border.Contains(new Point(Convert.ToDouble(drWell["X"])
        //                        , Convert.ToDouble(drWell["Y"]))))
        //                {
        //                    isOut = true;
        //                    break;
        //                }
        //            }
        //            if (isOut == true)
        //            {
        //                continue;
        //            }
        //            // Trace.WriteLine(wellName);
        //            // 目的层深度
        //            double dLayerDeepth = Convert.ToDouble(drWell[1]);  // 垂深 AND CS>{dLayerDeepth}",JS ASC"
        //            DataRow[] drsdeflection = dtDrill.Select(
        //                $"JH='{wellName}'", "JS ASC");

        //            // 前后深度
        //            double dCSNext = double.MinValue;
        //            double dCSBefore = double.MinValue;
        //            double dDzbNext = 0;        // DZB -
        //            double dBzbNext = 0;        // BZB
        //            double dDzbBefore = 0;      // DZB -
        //            double dBzbBefore = 0;      // BZB
        //            for (int i = 0; i < drsdeflection.Length; i++)
        //            {
        //                //dCSNext = Convert.ToDouble(drsdeflection[i][4]);
        //                if (double.TryParse($"{drsdeflection[i][4]}", out dCSNext) == false)
        //                {
        //                    dCSNext = 0;
        //                }
        //                if (dCSNext >= dLayerDeepth)
        //                {
        //                    if (double.TryParse($"{drsdeflection[i][2]}", out dDzbNext) == false)
        //                    {
        //                        dDzbNext = 0;
        //                    }
        //                    if (double.TryParse($"{drsdeflection[i][1]}", out dBzbNext) == false)
        //                    {
        //                        dBzbNext = 0;
        //                    }
        //                    //dDzbNext = Convert.ToDouble(drsdeflection[i][2]);       // DZB -
        //                    //dBzbNext = Convert.ToDouble(drsdeflection[i][1]);       // BZB
        //                    if (i == 0)
        //                    {
        //                        i++;
        //                    }
        //                    if (double.TryParse($"{drsdeflection[i - 1][4]}", out dCSBefore) == false)
        //                    {
        //                        dCSBefore = 0;
        //                    }
        //                    if (double.TryParse($"{drsdeflection[i - 1][2]}", out dDzbBefore) == false)
        //                    {
        //                        dDzbBefore = 0;
        //                    }
        //                    if (double.TryParse($"{drsdeflection[i - 1][1]}", out dBzbBefore) == false)
        //                    {
        //                        dBzbBefore = 0;
        //                    }
        //                    //dCSBefore = Convert.ToDouble(drsdeflection[i - 1][4]);
        //                    //dDzbBefore = Convert.ToDouble(drsdeflection[i - 1][2]);
        //                    //dBzbBefore = Convert.ToDouble(drsdeflection[i - 1][1]);
        //                    break;
        //                } // 未考虑补心海拔
        //            }
        //            if (dCSNext == double.MinValue || dCSBefore == double.MinValue)
        //            {
        //                continue;
        //            }

        //            // 斜井，计算层位坐标
        //            double dFactor = (dLayerDeepth - dCSBefore) / (dCSNext - dCSBefore);
        //            double dOffsetX = (dFactor * (dDzbNext - dDzbBefore)) + dDzbBefore;
        //            double dOffsetY = (dFactor * (dBzbNext - dBzbBefore)) + dBzbBefore;

        //            // double dLastCS = deflectionBefore.CS.Value;
        //            // double dNextCS = deflectionNext.CS.Value;
        //            // double dCS = (dFactor * (dNextCS - dLastCS)) + dLastCS; // 垂深
        //            // 补心海拔
        //            bool bWithKellyBushing = WorkspaceConfig.Instance.FindConfigValue<bool>("LayerAdjust", "UseKellyBushing", true);
        //            if (bWithKellyBushing)
        //            {
        //                object objBxhb = drWell["BXHB"];
        //                if (objBxhb != DBNull.Value && objBxhb != null)
        //                {
        //                    dLayerDeepth -= Convert.ToDouble(objBxhb);
        //                }
        //            }
        //            wellData.Add(Tuple.Create(
        //                wellName,
        //                Convert.ToDouble(drWell["X"]) + dOffsetX,
        //                Convert.ToDouble(drWell["Y"]) + dOffsetY,
        //                dLayerDeepth));
        //        }
        //    }
        //    int nWellCount = wellData.Count;
        //    if (nWellCount == 0)
        //    {
        //        return false;
        //    }
        //    // 写入文件
        //    string wellFile = FileHelp.GetWellLayerDeepthAdjustFile(layerName);
        //    StringBuilder strbContent = new StringBuilder();
        //    for (int i = 0; i < wellData.Count; i++)
        //    {
        //        strbContent.AppendLine($"{wellData[i].Item2},{wellData[i].Item3},{-wellData[i].Item4},{wellData[i].Item1}");
        //    }
        //    File.WriteAllText(wellFile, strbContent.ToString(), Encoding.Default);
        //    return true;
        //}
        /// <summary>
        /// 创建井位分布图
        /// </summary>
        /// <param name="wells">井列表</param>
        /// <param name="layerName">层位</param>
        /// <param name="useInclined">是否考虑斜井</param>
        /// <returns>是否成功</returns>
        public static bool CreateLayerWells(List<string> wells, string layerName, bool useInclined = false)
        {
            List<Tuple<string, double, double, double>> wellData = new List<Tuple<string, double, double, double>>();
            // 获得层位上的井,包括层位、测深
            foreach (string wellName in wells)
            {
                if (!useInclined)
                {
                    // 仅考虑直井
                    int nCount = DBHelp.NewDb.Queryable<WellDeflection>()
                        .Select(it => new { it.JH })
                        .Where(it => it.JH.Equals(wellName))
                        .Count();
                    if (nCount > 0)
                    {
                        continue;
                    }
                    var straightWell = DBHelp.NewDb.Queryable<InterpretDrillWellLayered, WellBase>(
                        (layer, wellBase) => new JoinQueryInfos(JoinType.Inner, layer.JH == wellBase.JH))
                        .Where((layer, wellBase) => layer.JH.Equals(wellName))
                        .Where((layer, wellBase) => SqlFunc.ToUpper(layer.CW) == SqlFunc.ToUpper(layerName))
                        .Where((layer, wellBase) => layer.SD > 0)
                        .Where((layer, wellBase) => wellBase.X != null)
                        .Select((layer, wellBase) => new { layer.JH, layer.CW, layer.SD, wellBase.BXHB, wellBase.X, wellBase.Y })
                        .First();
                    if (straightWell == null)
                    {
                        continue;
                    }
                    wellData.Add(Tuple.Create(
                        wellName,
                        straightWell.X.Value,
                        straightWell.Y.Value,
                        (straightWell.SD - straightWell.BXHB).Value));
                    continue;
                }

                var layerWell = DBHelp.NewDb.Queryable<InterpretDrillWellLayered, WellBase>(
                    (layer, wellBase) => new JoinQueryInfos(JoinType.Inner, layer.JH == wellBase.JH))
                    .Where((layer, wellBase) => layer.JH.Equals(wellName))
                    .Where((layer, wellBase) => SqlFunc.ToUpper(layer.CW) == SqlFunc.ToUpper(layerName))
                    .Where((layer, wellBase) => layer.SD > 0)
                    .Where((layer, wellBase) => wellBase.X != null)
                    .Select((layer, wellBase) => new { layer.JH, layer.CW, layer.SD, wellBase.BXHB, wellBase.X, wellBase.Y })
                    .First();
                if (layerWell == null)
                {
                    continue;
                }

                // 目的层深度
                double dLayerDeepth = layerWell.SD.Value;
                // TODO：考虑补心海拔
                var deflectionNext = DBHelp.NewDb.Queryable<WellDeflection>()
                    .Select(it => new { it.JH, it.BZB, it.DZB, it.JS, it.CS })
                    .Where(it => it.JH.Equals(wellName))
                    .Where(it => it.JS >= dLayerDeepth)
                    .OrderBy(it => it.JS, OrderByType.Asc)
                    .First();
                var deflectionBefore = DBHelp.NewDb.Queryable<WellDeflection>()
                    .Select(it => new { it.JH, it.BZB, it.DZB, it.JS, it.CS })
                    .Where(it => it.JH.Equals(wellName))
                    .Where(it => it.JS < dLayerDeepth)
                    .OrderBy(it => it.JS, OrderByType.Desc)
                    .First();

                if (deflectionNext == null || deflectionBefore == null)
                {
                    // 直井
                    wellData.Add(Tuple.Create(wellName, layerWell.X.Value, layerWell.Y.Value, (layerWell.SD - layerWell.BXHB).Value));
                    continue;
                }
                // 斜井，计算层位坐标
                double dBefore = deflectionBefore.JS.Value;
                double dNext = deflectionNext.JS.Value;
                double dFactor = (dLayerDeepth - dBefore) / (dNext - dBefore);
                double dOffsetX = (dFactor * (deflectionNext.DZB - deflectionBefore.DZB).Value)
                                          + deflectionBefore.DZB.Value;
                double dOffsetY = (dFactor * (deflectionNext.BZB - deflectionBefore.BZB).Value)
                                  + deflectionBefore.BZB.Value;

                double dLastCS = deflectionBefore.CS.Value;
                double dNextCS = deflectionNext.CS.Value;
                double dCS = (dFactor * (dNextCS - dLastCS)) + dLastCS; // 垂深

                wellData.Add(Tuple.Create(wellName, layerWell.X.Value + dOffsetX, layerWell.Y.Value + dOffsetY, dCS));
            }

            int nWellCount = wellData.Count;
            if (nWellCount == 0)
            {
                return false;
            }
            // 写入文件
            string wellFile = FileHelp.GetWellLayerDeepthAdjustFile(layerName);
            StringBuilder strbContent = new StringBuilder();

            for (int i = 0; i < wellData.Count; i++)
            {
                strbContent.AppendLine($"{wellData[i].Item2},{wellData[i].Item3},{-wellData[i].Item4},{wellData[i].Item1}");
            }
            File.WriteAllText(wellFile, strbContent.ToString(), Encoding.Default);
            return true;
        }

        /// <summary>
        /// 创建储层数据
        /// </summary>
        /// <param name="dataType">数据类型</param>
        /// <param name="layerName">层位名称</param> 
        /// <param name="subType">子类型</param>
        /// <returns>是否成功</returns>
        //public static bool CreateReservoir(TreeTypeClass dataType, string layerName, int subType)
        //{
        //    List<ReservoirEntity> lstLayerData = CreateReservoirData(dataType, layerName, subType);
        //    if (lstLayerData.Count > 0)
        //    {
        //        string inputXYZFile = FileHelp.GetTuneFileByReservoirData(dataType.GetDir(subType), layerName);
        //        FileHelp.DeleteFile(inputXYZFile);
        //        List<string> noExcludeWells = new List<string>();
        //        //剔除井数据获取
        //        var ccsjWells = DBHelp.Db.Queryable<CcsjWellSetting>().Where(x => x.SJLX == dataType.Text && x.CW == layerName).Select(x => x.JH).ToList();
        //        if (ccsjWells != null)
        //        {
        //            noExcludeWells.AddRange(ccsjWells);
        //        }

        //        using (StreamWriter sw = new StreamWriter(inputXYZFile, false, Encoding.Default))
        //        {
        //            foreach (ReservoirEntity dr in lstLayerData)
        //            {
        //                if (dr == null)
        //                {
        //                    continue;
        //                }

        //                if (!noExcludeWells.Contains(dr.JH))
        //                {
        //                    sw.WriteLine($"{dr.X},{dr.Y},{dr.DATA},{dr.JH}");
        //                }
        //            }
        //        }
        //        return true;
        //    }
        //    return false;
        //}

        /// <summary>
        /// 创建分层数据
        /// </summary>
        /// <param name="dataType">数据类型</param>
        /// <param name="layerName">层位名称</param>
        /// <param name="depthType">深度类型</param>
        /// <returns>是否成功</returns>
        //public static bool CreateDrillWellLayer(string dataType, string layerName, GeoLayerDepthType depthType)
        //{
        //    List<InterpretDrillWellLayered> lstLayerData = CreateDrillWellLayerData(layerName, depthType);
        //    if (lstLayerData.Count > 0)
        //    {
        //        string inputXYZFile = FileHelp.GetMiddleFile(dataType, layerName, ".xyz");
        //        FileHelp.DeleteFile(inputXYZFile);
        //        using (StreamWriter sw = new StreamWriter(inputXYZFile, false, Encoding.Default))
        //        {
        //            foreach (InterpretDrillWellLayered dr in lstLayerData)
        //            {
        //                if (dr == null)
        //                {
        //                    continue;
        //                }
        //                sw.WriteLine($"{dr.X},{dr.Y},{dr.SD},{dr.JH}");
        //            }
        //        }
        //        return true;
        //    }
        //    return false;
        //}

        /// <summary>
        /// Creates the adjust reservoir.
        /// </summary>
        /// <param name="dataType">The data type.</param>
        /// <param name="layerName">The layer name.</param>
        /// <param name="inputXYZFile">The inputXYZFile name.</param>
        /// <returns>A bool.</returns>
        //public static bool CreateAdjustReservoir(TreeTypeClass dataType, string layerName, string inputXYZFile, int subType)
        //{
        //    if (string.IsNullOrWhiteSpace(inputXYZFile))
        //    {
        //        inputXYZFile = FileHelp.GetAdjustFileByReservoirData(dataType.GetDir(subType), layerName);
        //    }
        //    var wellFile = FileHelp.GetReservoirAdjustFileByReservoirData(dataType.GetDir(subType), layerName);
        //    List<ReservoirEntity> lstLayerData = CreateReservoirData(dataType, layerName, subType);
        //    if (lstLayerData.Count > 0)
        //    {
        //        var strLayerAdjustFileXyzContent = new StringBuilder();
        //        var strLayerAdjustFileCsvContent = new StringBuilder();

        //        foreach (ReservoirEntity dr in lstLayerData)
        //        {
        //            if (dr == null)
        //            {
        //                continue;
        //            }
        //            strLayerAdjustFileXyzContent.AppendLine($"{dr.X},{dr.Y},{dr.DATA}");
        //            strLayerAdjustFileCsvContent.AppendLine($"{dr.X},{dr.Y},{dr.DATA},{dr.JH}");
        //        }

        //        File.WriteAllText(inputXYZFile, strLayerAdjustFileXyzContent.ToString(), Encoding.Default);
        //        File.WriteAllText(wellFile, strLayerAdjustFileCsvContent.ToString(), Encoding.Default);
        //        return true;
        //    }
        //    return false;
        //}

        /// <summary>
        /// 通过层级获取储层分层下级所有层
        /// </summary>
        /// <param name="layerLevel">层级</param>
        /// <param name="includeChild">是否包含子层</param>
        /// <returns>储层数据</returns>
        //public static List<string> GetReservoirChildLayers(int layerLevel, bool includeChild = false)
        //{
        //    if (!includeChild)
        //    {
        //        return DBHelp.NewDb.Queryable<GeologicalStratification>().Where(it => it.Level == layerLevel).Select(x => x.Code).ToList();
        //    }
        //    List<string> lstLayerName = new List<string>();
        //    int nNodeID = DBHelp.NewDb.Queryable<GeologicalStratification>()
        //            .Where(it => it.Level == layerLevel).Select(it => it.ID).First();

        //    List<GeologicalStratification> lstLayer = DBHelp.NewDb.Queryable<GeologicalStratification>()
        //          .ToChildList(it => it.ParentID, nNodeID);
        //    foreach (GeologicalStratification layer in lstLayer)
        //    {
        //        string strChildName = layer.Code.ToUpper();
        //        if (!lstLayerName.Contains(strChildName))
        //        {
        //            lstLayerName.Add(strChildName);
        //        }
        //    }
        //    lstLayerName = lstLayerName.Select(s => s.ToUpper()).ToList();
        //    return lstLayerName;
        //}
        /// <summary>
        /// 通过层名获取储层分层下级所有层
        /// </summary>
        /// <param name="layerName">层位名称</param>
        /// <returns>储层数据</returns>
        public static List<string> GetReservoirChildLayers(string layerName)
        {
            layerName = layerName.ToUpper();
            int nNodeID = DBHelp.NewDb.Queryable<GeologicalStratification>().Where(it => SqlFunc.ToUpper(it.Code) == layerName).Select(it => it.ID).First();
            List<GeologicalStratification> lstLayer = DBHelp.NewDb.Queryable<GeologicalStratification>().ToChildList(it => it.ParentID, nNodeID);
            List<string> lstLayerName = new List<string>
            {
                layerName,
            };
            foreach (GeologicalStratification layer in lstLayer)
            {
                string strChildName = layer.Code;
                if (!lstLayerName.Any(x => x.Equals(strChildName, StringComparison.CurrentCultureIgnoreCase)))
                {
                    lstLayerName.Add(strChildName);
                }
            }
            lstLayerName = lstLayerName.Select(s => s.ToUpper()).ToList();
            return lstLayerName;
        }

        /// <summary>
        /// 创建储层数据
        /// </summary>
        /// <param name="dataType">数据类型</param>
        /// <param name="layerName">层位名称</param>
        /// <returns>储层数据</returns>
        //public static List<ReservoirEntity> CreateReservoirData(TreeTypeClass dataType, string layerName, int subType)
        //{
        //    List<string> lstLayerName = GetReservoirChildLayers(layerName);
        //    return CreateReservoirData(dataType, layerName, lstLayerName, subType);
        //}

        ///// <summary>
        ///// 创建储层数据
        ///// </summary>
        ///// <param name="dataType">数据类型</param>
        ///// <param name="layerName">层位名称</param>
        ///// <param name="lstLayerName">下级层位名称</param>
        ///// <returns>储层数据</returns>
        //public static List<ReservoirEntity> CreateReservoirData(TreeTypeClass dataType, string layerName, List<string> lstLayerName, int subType)
        //{
        //    GeoLayerDepthType depthType = (GeoLayerDepthType)subType;
        //    bool isAvg = WorkspaceConfig.Instance.FindConfigValue("ReservoirSet", "KsbCalcModel", 0) == 0 ? true : false;
        //    List<ReservoirEntity> lstLayerData = null;
        //    if (dataType == TreeTypeClass.Porosity || dataType == TreeTypeClass.InterpretPorosity)
        //    {
        //        // 孔隙度
        //        var result = DBHelp.NewDb.Queryable<CcsjKxd, WellBase>((layer, well) =>
        //                                    new JoinQueryInfos(JoinType.Left, layer.JH == well.JH))
        //                                  .Where((layer, well) => lstLayerName.Contains(SqlFunc.ToUpper(layer.CW)))
        //                                  .Where((layer, well) => layer.KXD != null && layer.KXD.HasValue)
        //                                  .Where((layer, well) => layer.X > 0)
        //                                  .Where((layer, well) => layer.Y > 0)
        //                                  .Where((layer, well) => (layer.DJSD1 != null && layer.DJSD1.Value > 0))
        //                                  .OrderBy((layer, well) => new { layer.JH, layer.CW })
        //                                  .Select((layer, well) => new
        //                                  {
        //                                      well.CXB,
        //                                      well.MQJB,
        //                                      layer.JH,
        //                                      layer.DJSD1,
        //                                      layer.X,
        //                                      layer.Y,
        //                                      layer.CW,
        //                                      layer.KXD,
        //                                      layer.YXHD,
        //                                      layer.YXHD_CS,
        //                                  }).ToList();
        //        List<ReservoirEntity> lstReservoir = result.OrderBy(x => x.JH).Select(x => new ReservoirEntity()
        //        {
        //            CXB = x.CXB,
        //            MQJB = x.MQJB,
        //            JH = x.JH,
        //            SD = x.DJSD1.Value,
        //            X = x.X.Value,
        //            Y = x.Y.Value,
        //            Layer = x.CW,
        //            DATA = x.KXD.Value,
        //            KXD = x.KXD.Value,
        //            YXHD = depthType == GeoLayerDepthType.测深厚度 ? x.YXHD.GetValueOrDefault(0) : x.YXHD_CS.GetValueOrDefault(0),
        //        }).ToList();

        //        if (isAvg)
        //        {
        //            lstLayerData = AverageRows(lstReservoir);
        //        }
        //        else
        //        {
        //            lstLayerData = PorosityAverageRows(lstReservoir);
        //        }
        //        lstLayerData = lstLayerData.Where(x => !double.IsNaN(x.DATA)).ToList();
        //    }
        //    else if (dataType == TreeTypeClass.Permeability || dataType == TreeTypeClass.InterpretPenetration)
        //    {
        //        // 渗透率
        //        var result = DBHelp.NewDb.Queryable<CcsjStl, WellBase>((layer, well) =>
        //                new JoinQueryInfos(JoinType.Left, layer.JH == well.JH))
        //              .Where((layer, well) => lstLayerName.Contains(SqlFunc.ToUpper(layer.CW)))
        //              .Where((layer, well) => layer.STL != null && layer.STL.HasValue)
        //              .Where((layer, well) => layer.X > 0)
        //              .Where((layer, well) => layer.Y > 0)
        //              .Where((layer, well) => (layer.DJSD1 != null && layer.DJSD1.Value > 0))
        //              .Select((layer, well) => new
        //              {
        //                  well.CXB,
        //                  well.MQJB,
        //                  layer.JH,
        //                  layer.DJSD1,
        //                  layer.X,
        //                  layer.Y,
        //                  layer.CW,
        //                  layer.STL,
        //                  layer.YXHD,
        //                  layer.YXHD_CS,
        //              }).ToList();

        //        List<ReservoirEntity> lstReservoir = result.OrderBy(x => x.JH).Select(x => new ReservoirEntity()
        //        {
        //            CXB = x.CXB,
        //            MQJB = x.MQJB,
        //            JH = x.JH,
        //            SD = x.DJSD1.Value,
        //            X = x.X.Value,
        //            Y = x.Y.Value,
        //            Layer = x.CW,
        //            DATA = x.STL.Value,
        //            STL = x.STL.Value,
        //            YXHD = depthType == GeoLayerDepthType.测深厚度 ? x.YXHD.GetValueOrDefault(0) : x.YXHD_CS.GetValueOrDefault(0),
        //        }).ToList();

        //        if (isAvg)
        //        {
        //            lstLayerData = AverageRows(lstReservoir);
        //        }
        //        else
        //        {
        //            lstLayerData = PorosityAverageRows(lstReservoir);
        //        }
        //        lstLayerData = lstLayerData.Where(x => !double.IsNaN(x.DATA)).ToList();
        //    }
        //    else if (dataType == TreeTypeClass.CcsjSyhd || dataType == TreeTypeClass.InterpretSandThickness)
        //    {
        //        // 砂岩厚度
        //        var result = DBHelp.NewDb.Queryable<CcsjSyhd, WellBase>((layer, well) =>
        //                 new JoinQueryInfos(JoinType.Left, layer.JH == well.JH))
        //               .Where((layer, well) => lstLayerName.Contains(SqlFunc.ToUpper(layer.CW)))
        //               .Where((layer, well) => layer.SYHD != null)
        //               .Where((layer, well) => layer.X > 0)
        //               .Where((layer, well) => layer.Y > 0)
        //               .OrderBy((layer, well) => new { layer.JH, layer.SYSD_T })
        //               .Select((layer, well) => new
        //               {
        //                   well.CXB,
        //                   well.MQJB,
        //                   layer.JH,
        //                   layer.SYSD_T,
        //                   layer.X,
        //                   layer.Y,
        //                   layer.CW,
        //                   layer.SYHD,
        //                   layer.SYCS_HD,
        //               })
        //               .ToList();

        //        List<ReservoirEntity> lstReservoir = result.OrderBy(x => x.JH).Select(x => new ReservoirEntity()
        //        {
        //            CXB = x.CXB,
        //            MQJB = x.MQJB,
        //            JH = x.JH,
        //            SD = x.SYSD_T,
        //            X = x.X.Value,
        //            Y = x.Y.Value,
        //            Layer = x.CW,
        //            DATA = depthType == GeoLayerDepthType.测深厚度 ? x.SYHD.GetValueOrDefault(double.NaN) : x.SYCS_HD.GetValueOrDefault(double.NaN),
        //            SYHD = depthType == GeoLayerDepthType.测深厚度 ? x.SYHD.GetValueOrDefault(double.NaN) : x.SYCS_HD.GetValueOrDefault(double.NaN),
        //        }).ToList();
        //        lstLayerData = SumRows(lstReservoir, layerName);
        //    }
        //    else if (dataType == TreeTypeClass.CcsjYxhd || dataType == TreeTypeClass.InterpretVaildThickness)
        //    {
        //        // 有效厚度
        //        var result = DBHelp.NewDb.Queryable<CcsjYxhd, WellBase>((layer, well) =>
        //                 new JoinQueryInfos(JoinType.Left, layer.JH == well.JH))
        //                 .Where((layer, well) => lstLayerName.Contains(SqlFunc.ToUpper(layer.CW)))
        //                 .Where((layer, well) => layer.YXHD != null)
        //                 .Where((layer, well) => layer.X > 0)
        //                 .Where((layer, well) => layer.Y > 0)
        //                 .OrderBy((layer, well) => new { layer.JH, layer.DJSD1 })
        //                .Select((layer, well) => new
        //                {
        //                    well.CXB,
        //                    well.MQJB,
        //                    layer.JH,
        //                    layer.DJSD1,
        //                    layer.X,
        //                    layer.Y,
        //                    layer.YXHD,
        //                    layer.YXCS_HD,
        //                    layer.CW,
        //                }).ToList();
        //        List<ReservoirEntity> lstReservoir = result.OrderBy(x => x.JH).Select(x => new ReservoirEntity()
        //        {
        //            CXB = x.CXB,
        //            MQJB = x.MQJB,
        //            JH = x.JH,
        //            SD = x.DJSD1,
        //            X = x.X.Value,
        //            Y = x.Y.Value,
        //            DATA = depthType == GeoLayerDepthType.测深厚度 ? x.YXHD.GetValueOrDefault(double.NaN) : x.YXCS_HD.GetValueOrDefault(double.NaN),
        //            YXHD = depthType == GeoLayerDepthType.测深厚度 ? x.YXHD.GetValueOrDefault(double.NaN) : x.YXCS_HD.GetValueOrDefault(double.NaN),
        //            Layer = x.CW,
        //        }).ToList();
        //        lstLayerData = SumRows(lstReservoir, layerName);
        //    }
        //    else if (dataType == TreeTypeClass.WaterSaturation || dataType == TreeTypeClass.InterpretSaturation)
        //    {
        //        // 含水饱和度
        //        var q = DBHelp.NewDb.Queryable<CcsjBhd, WellBase>((layer, well) => new JoinQueryInfos(JoinType.Left, layer.JH == well.JH))
        //               .Where((layer, well) => lstLayerName.Contains(SqlFunc.ToUpper(layer.CW)))
        //               .Where((layer, well) => layer.HSBHD != null && layer.HSBHD.HasValue)
        //               .Where((layer, well) => layer.X > 0)
        //               .Where((layer, well) => layer.Y > 0)
        //               .Where((layer, well) => (layer.DJSD1 != null && layer.DJSD1.Value > 0));

        //        if (!isAvg)
        //        {
        //            q = q.Where((layer, well) => layer.KXD != null && layer.YXHD != null && layer.KXD.HasValue && layer.YXHD.HasValue);
        //        }
        //        var result = q.Select((layer, well) => new
        //        {
        //            well.CXB,
        //            well.MQJB,
        //            layer.JH,
        //            layer.DJSD1,
        //            layer.X,
        //            layer.Y,
        //            layer.CW,
        //            layer.HSBHD,
        //            layer.YXHD,
        //            layer.YXHD_CS,
        //            layer.KXD,
        //        }).ToList();

        //        List<ReservoirEntity> lstReservoir = result.OrderBy(x => x.JH).Select(x => new ReservoirEntity()
        //        {
        //            CXB = x.CXB,
        //            MQJB = x.MQJB,
        //            JH = x.JH,
        //            SD = x.DJSD1.Value,
        //            X = x.X.Value,
        //            Y = x.Y.Value,
        //            Layer = x.CW,
        //            DATA = x.HSBHD.Value,
        //            BHD = x.HSBHD.Value,
        //            YXHD = depthType == GeoLayerDepthType.测深厚度 ? x.YXHD.GetValueOrDefault(0) : x.YXHD_CS.GetValueOrDefault(0),
        //            KXD = x.KXD.GetValueOrDefault(0),
        //        }).ToList();

        //        if (isAvg)
        //        {
        //            lstLayerData = AverageRows(lstReservoir);
        //        }
        //        else
        //        {
        //            lstLayerData = SaturationAverageRows(lstReservoir);
        //        }
        //        lstLayerData = lstLayerData.Where(x => !double.IsNaN(x.DATA)).ToList();
        //    }
        //    else if (dataType == TreeTypeClass.BeamWaterSaturation)
        //    {
        //        // 束水饱和度
        //        var result = DBHelp.NewDb.Queryable<CcsjBhd, WellBase>((layer, well) => new JoinQueryInfos(JoinType.Left, layer.JH == well.JH))
        //                .Where((layer, well) => lstLayerName.Contains(SqlFunc.ToUpper(layer.CW)))
        //                .Where((layer, well) => layer.HSBHD != null)
        //                .Where((layer, well) => layer.X > 0)
        //                .Where((layer, well) => layer.Y > 0)
        //                .Where((layer, well) => (layer.DJSD1 != null && layer.DJSD1.Value > 0))
        //                .Select((layer, well) => new
        //                {
        //                    well.CXB,
        //                    well.MQJB,
        //                    layer.JH,
        //                    layer.DJSD1,
        //                    layer.X,
        //                    layer.Y,
        //                    layer.CW,
        //                    layer.HSBHD,
        //                    layer.YXHD,
        //                    layer.YXHD_CS,
        //                    layer.KXD,
        //                }).ToList();

        //        List<ReservoirEntity> lstReservoir = result.OrderBy(x => x.JH).Select(x => new ReservoirEntity()
        //        {
        //            CXB = x.CXB,
        //            MQJB = x.MQJB,
        //            JH = x.JH,
        //            SD = x.DJSD1.Value,
        //            X = x.X.Value,
        //            Y = x.Y.Value,
        //            Layer = x.CW,
        //            DATA = x.HSBHD.Value,
        //            BHD = x.HSBHD.Value,
        //            YXHD = depthType == GeoLayerDepthType.测深厚度 ? x.YXHD.GetValueOrDefault(0) : x.YXHD_CS.GetValueOrDefault(0),
        //            KXD = x.KXD.Value,
        //        }).ToList();

        //        if (isAvg)
        //        {
        //            lstLayerData = AverageRows(lstReservoir);
        //        }
        //        else
        //        {
        //            lstLayerData = SaturationAverageRows(lstReservoir);
        //        }
        //        lstLayerData = lstLayerData.Where(x => !double.IsNaN(x.DATA)).ToList();
        //    }

        //    return lstLayerData;
        //}
        ///// <summary>
        ///// 创建井分层数据
        ///// </summary>
        ///// <param name="layerName">层位名称</param>
        ///// <param name="depthType">类型名称</param>
        ///// <returns>List<InterpretDrillWellLayered></returns>
        //public static List<InterpretDrillWellLayered> CreateDrillWellLayerData(string layerName, GeoLayerDepthType depthType = GeoLayerDepthType.测深厚度)
        //{
        //    // 井分层
        //    // 获取层
        //    List<string> lstLayerName = GetReservoirChildLayers(layerName);
        //    List<InterpretDrillWellLayered> lstLayerData = DBHelp.NewDb.Queryable<InterpretDrillWellLayered>().Where(d => lstLayerName.Contains(SqlFunc.ToUpper(d.CW)) && d.X.HasValue && d.Y.HasValue).Select(d => new InterpretDrillWellLayered
        //    {
        //        CW = d.CW,
        //        X = d.X,
        //        Y = d.Y,
        //        DJSD = depthType == GeoLayerDepthType.测深厚度 ? (d.DJSD ?? 0) : (depthType == GeoLayerDepthType.海拔 ? d.HBSD2 ?? 0 : d.CS_B ?? 0),
        //        SD = depthType == GeoLayerDepthType.测深厚度 ? (d.SD ?? 0) : (depthType == GeoLayerDepthType.海拔 ? d.HBSD1 ?? 0 : d.CS_T ?? 0),
        //        JH = d.JH,
        //    }).ToList();

        //    //按井分组求和
        //    var lstResult = lstLayerData.GroupBy(x => x.JH).Select(x => new InterpretDrillWellLayered()
        //    {
        //        JH = x.Key,
        //        CW = x.First().CW,
        //        X = x.First().X,
        //        Y = x.First().Y,
        //        SD = depthType == GeoLayerDepthType.海拔 ? x.Max(c => c.SD) : x.Min(c => c.SD),
        //    }).ToList();

        //    return lstResult;
        //}

        /// <summary>
        /// 求和算法
        /// </summary>
        /// <param name="lstReservoir">The lst reservoir.</param>
        /// <param name="parentLayer">The parent layer.</param>
        /// <returns>A list of ReservoirEntities.</returns>
        private static List<ReservoirEntity> SumRows(List<ReservoirEntity> lstReservoir, string parentLayer)
        {
            List<string> wells = lstReservoir.Select(e => e.JH).Distinct().ToList();
            List<ReservoirEntity> lstLayerData = new List<ReservoirEntity>();
            foreach (string well in wells)
            {
                List<ReservoirEntity> layerData = lstReservoir.Where(it => it.JH == well && it.Layer == parentLayer).ToList();
                if (layerData.Count > 0)
                {
                    ReservoirEntity entityPush = WorkData.ObjectClone<ReservoirEntity, ReservoirEntity>.CloneFrom(layerData[0]);
                    entityPush.DATA = 0;
                    foreach (ReservoirEntity item in layerData)
                    {
                        entityPush.DATA += item.DATA;
                    }
                    lstLayerData.Add(entityPush);
                    continue;
                }
                // 累加所有子层
                layerData = lstReservoir.Where(it => it.JH == well && it.Layer != parentLayer).ToList();
                if (layerData.Count > 0)
                {
                    ReservoirEntity entityPush = WorkData.ObjectClone<ReservoirEntity, ReservoirEntity>.CloneFrom(layerData[0]);
                    entityPush.DATA = 0;
                    foreach (ReservoirEntity item in layerData)
                    {
                        entityPush.DATA += item.DATA;
                    }
                    lstLayerData.Add(entityPush);
                }
            }
            return lstLayerData;
        }

        /// <summary>
        /// 平均值
        /// </summary>
        /// <param name="lstReservoir">The lst reservoir.</param>
        /// <returns>A list of ReservoirEntities.</returns>
        private static List<ReservoirEntity> AverageRows(List<ReservoirEntity> lstReservoir)
        {
            List<ReservoirEntity> lstLayerData = new List<ReservoirEntity>();
            if (lstReservoir.Count == 0)
            {
                return lstLayerData;
            }
            int nCount = 0;
            double dDataSum = 0;
            ReservoirEntity entityPush = WorkData.ObjectClone<ReservoirEntity, ReservoirEntity>.CloneFrom(lstReservoir.FirstOrDefault());
            foreach (ReservoirEntity item in lstReservoir)
            {
                if (!entityPush.JH.Equals(item.JH))
                {
                    entityPush.DATA = dDataSum / nCount;
                    lstLayerData.Add(entityPush);
                    entityPush = WorkData.ObjectClone<ReservoirEntity, ReservoirEntity>.CloneFrom(item);
                    nCount = 0;
                    dDataSum = 0;
                }
                nCount++;
                dDataSum += item.DATA;
            }
            entityPush.DATA = Math.Round(dDataSum / nCount, 2);
            lstLayerData.Add(entityPush);

            return lstLayerData;
        }

        /// <summary>
        /// 孔隙度/渗透率加权算法值
        /// </summary>
        /// <param name="lstReservoir">The lst reservoir.</param>
        /// <returns>A list of ReservoirEntities.</returns>
        private static List<ReservoirEntity> PorosityAverageRows(List<ReservoirEntity> lstReservoir)
        {
            List<ReservoirEntity> lstLayerData = new List<ReservoirEntity>();
            if (lstReservoir.Count == 0)
            {
                return lstLayerData;
            }
            ReservoirEntity entityPush = WorkData.ObjectClone<ReservoirEntity, ReservoirEntity>.CloneFrom(lstReservoir.FirstOrDefault());
            double kxdSum = 0;
            double yxhdSum = 0;
            entityPush = lstReservoir.FirstOrDefault();
            foreach (ReservoirEntity item in lstReservoir)
            {
                if (!entityPush.JH.Equals(item.JH))
                {
                    // 保存上一条数据
                    entityPush.DATA = kxdSum / yxhdSum;
                    lstLayerData.Add(entityPush);
                    // 生成新的数据
                    entityPush = WorkData.ObjectClone<ReservoirEntity, ReservoirEntity>.CloneFrom(item);
                    kxdSum = 0;
                    yxhdSum = 0;
                }
                kxdSum += item.DATA * item.YXHD;
                yxhdSum += item.YXHD;
            }
            // 保存最一条数据
            entityPush.DATA = Math.Round(kxdSum / yxhdSum, 2);
            lstLayerData.Add(entityPush);
            return lstLayerData;
        }
        /// <summary>
        /// 饱和度加权算法值
        /// </summary>
        /// <param name="lstReservoir">The lst reservoir.</param>
        /// <returns>A list of ReservoirEntities.</returns>
        private static List<ReservoirEntity> SaturationAverageRows(List<ReservoirEntity> lstReservoir)
        {
            List<ReservoirEntity> lstLayerData = new List<ReservoirEntity>();
            if (lstReservoir.Count == 0)
            {
                return lstLayerData;
            }
            double kxdSum = 0;
            double yxhdSum = 0;
            ReservoirEntity entityPush = WorkData.ObjectClone<ReservoirEntity, ReservoirEntity>.CloneFrom(lstReservoir.FirstOrDefault());
            foreach (ReservoirEntity item in lstReservoir)
            {
                if (!entityPush.JH.Equals(item.JH))
                {
                    // 保存上一条数据
                    entityPush.DATA = kxdSum / yxhdSum;
                    lstLayerData.Add(entityPush);
                    // 生成新的数据
                    entityPush = WorkData.ObjectClone<ReservoirEntity, ReservoirEntity>.CloneFrom(item);
                    kxdSum = 0;
                    yxhdSum = 0;
                }
                kxdSum += item.KXD * item.YXHD * item.BHD;
                yxhdSum += item.KXD * item.YXHD;
            }
            entityPush.DATA = Math.Round(kxdSum / yxhdSum, 2);
            lstLayerData.Add(entityPush);
            return lstLayerData;
        }

        /// <summary>
        /// 储层计算临时类
        /// </summary>
        public class ReservoirEntity
        {
            public string CXB { get; set; }
            public string MQJB { get; set; }
            public string JH { get; set; } = string.Empty;
            public double? SD { get; set; }
            public double X { get; set; }
            public double Y { get; set; }
            /// <summary>
            /// 数据
            /// </summary>
            public double DATA { get; set; }
            /// <summary>
            /// 层位
            /// </summary>
            public string Layer { get; set; }
            /// <summary>
            /// 孔隙度
            /// </summary>
            public double KXD { get; set; }
            /// <summary>
            /// 有效厚度
            /// </summary>
            public double YXHD { get; set; }
            /// <summary>
            /// 饱和度
            /// </summary>
            public double BHD { get; set; }
            /// <summary>
            /// 渗透率
            /// </summary>
            public double STL { get; set; }
            /// <summary>
            /// 砂岩厚度
            /// </summary>
            public double SYHD { get; set; }
        }
    }
}