using DevExpress.Drawing.Internal.Interop;
using DevExpress.Office.Utils;
using DevExpress.XtraRichEdit.Model;
using DevExpress.XtraScheduler.Drawing.Internal;
using DevExpress.XtraTreeList.Data;
using GeoSigma.SigmaDrawerElement;
using GeoSigmaDrawLib;
using InterfaceWorkAreaData;
//using InterfaceWorkAreaData;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using NPOI.SS.Formula.Functions;
using SigmaDrawerElement;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using WorkData;
using WorkData.Entity;
using static ScintillaNET.Style;

namespace GeoSigma.UCDraw.WellAndSection
{
    public class StringIntMapper
    {
        private readonly Dictionary<string, int> _mappings;
        private readonly int _defaultValue;

        public StringIntMapper(int defaultValue = -1)
        {
            _mappings = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
            _defaultValue = defaultValue;
        }

        public void AddMapping(string key, int value = -1) => _mappings[key] = value;

        public void AddMappings(IEnumerable<KeyValuePair<string, int>> mappings)
        {
            foreach (var mapping in mappings)
            {
                _mappings[mapping.Key] = mapping.Value;
            }
        }

        public int this[string key]
        {
            get => _mappings.TryGetValue(key, out int value) ? value : _defaultValue;
            set => _mappings[key] = value;
        }

        public bool TryGetValue(string key, out int value) =>
            _mappings.TryGetValue(key, out value);

        public bool UpdateMapping(string key, int newValue)
        {
            if (_mappings.ContainsKey(key))
            {
                _mappings[key] = newValue;
                return true;
            }
            return false;
        }

        public bool HasKey(string key)
        {
            return _mappings.ContainsKey(key);
        }

        public IEnumerable<string> Keys => _mappings.Keys;
        public IEnumerable<int> Values => _mappings.Values;
    }

    class WellDataConvert
    {
        public static void getWellPerforationsJson(ref string jsonStr, List<cPerforation> listPerforations)
        {
            jsonStr = "";
            if (listPerforations.Count == 0)
                return;

            JObject json = new JObject();
            json["dataType"] = "Shot";

            JArray jCols = new JArray();
            jCols.Add("name");
            jCols.Add("top");
            jCols.Add("bottom");
            jCols.Add("date");  // kep工区表中没有
            jCols.Add("density");  //kep工区表中没有
            jCols.Add("method");
            json["columnName"] = jCols;

            JArray jDatas = new JArray();
            for (int k = 0; k < listPerforations.Count; k++)
            {
                JArray tdata = new JArray();
                tdata.Add(listPerforations[k].layer);
                tdata.Add(listPerforations[k].top.ToString());
                tdata.Add(listPerforations[k].bottom.ToString());
                tdata.Add("");
                tdata.Add("");
                tdata.Add(listPerforations[k].perforationMethod);
                jDatas.Add(tdata);
            }

            json["data"] = jDatas;

            jsonStr = JsonConvert.SerializeObject(json);
        }

        public static void getWellFaultPointsJson(ref string jsonStr, List<cFaultPoint> listFaultPts)
        {
            jsonStr = "";
            if (listFaultPts.Count == 0)
                return;
            JObject json = new JObject();
            json["dataType"] = "FaultPoint";

            JArray jCols = new JArray();
            jCols.Add("depth");
            jCols.Add("name");
            jCols.Add("topLayer");
            jCols.Add("bottomLayer");

            jCols.Add("compareWell");
            jCols.Add("compareWellTop");
            jCols.Add("compareWellBottom");

            json["columnName"] = jCols;
            JArray jDatas = new JArray();
            for (int k = 0; k < listFaultPts.Count; k++)
            {
                JArray tdata = new JArray();
                tdata.Add(listFaultPts[k].depth.ToString());
                tdata.Add(listFaultPts[k].faultName);
                tdata.Add(listFaultPts[k].faultTopLayer);
                tdata.Add(listFaultPts[k].faultBottomLayer);

                tdata.Add("");
                tdata.Add(listFaultPts[k].compareWellTop.ToString());
                tdata.Add(listFaultPts[k].compareWellBottom.ToString());

                jDatas.Add(tdata);
            }
            json["data"] = jDatas;
            jsonStr = JsonConvert.SerializeObject(json);
        }

        public static void getWellTrajectoryJson(ref string jsonStr, List<cWellTrackPoint> listTrackPts)
        {
            jsonStr = "";
            if (listTrackPts.Count == 0)
                return;

            JObject json = new JObject();
            json["dataType"] = "trajectory";

            JArray jCols = new JArray();
            jCols.Add("depth");
            jCols.Add("bevel");
            jCols.Add("azimuth");
            jCols.Add("depthV");
            jCols.Add("x");
            jCols.Add("y");
            json["columnName"] = jCols;

            JArray jDatas = new JArray();
            for (int k = 0; k < listTrackPts.Count; k++)
            {
                JArray tdata = new JArray();
                tdata.Add(listTrackPts[k].depth.ToString());
                tdata.Add(listTrackPts[k].bevel.ToString());
                tdata.Add(listTrackPts[k].azimuth.ToString());
                tdata.Add(listTrackPts[k].depthV.ToString());
                tdata.Add(listTrackPts[k].x.ToString());
                tdata.Add(listTrackPts[k].y.ToString());

                jDatas.Add(tdata);
            }

            json["data"] = jDatas;
            jsonStr = JsonConvert.SerializeObject(json);
        }
        public static void getWellStratificationJson(ref string jsonStr, List<cWellStratification> listWellStrati)
        {
            jsonStr = "";
            if (listWellStrati.Count == 0)
                return;

            JObject json = new JObject();
            json["dataType"] = "wellStratification";

            JArray jCols = new JArray();
            jCols.Add("id");
            jCols.Add("level");
            jCols.Add("name");
            jCols.Add("code");
            jCols.Add("parentId");
            jCols.Add("order");
            json["columnName"] = jCols;

            JArray jDatas = new JArray();
            for (int k = 0; k < listWellStrati.Count; k++)
            {
                JArray tdata = new JArray();
                tdata.Add(listWellStrati[k].id.ToString());
                tdata.Add(listWellStrati[k].level.ToString());
                tdata.Add(listWellStrati[k].name.ToString());
                tdata.Add(listWellStrati[k].code.ToString());
                tdata.Add(listWellStrati[k].parentId.ToString());
                tdata.Add(listWellStrati[k].order.ToString());

                jDatas.Add(tdata);
            }

            json["data"] = jDatas;
            jsonStr = JsonConvert.SerializeObject(json);
        }

        public static void getWellCurveValueForNewWell(DataTable curvesTable, GeoSigmaWellPoleXY wellGeo, UInt64 wellHandle, UInt64 trackHandle, string dataStrRef)
        {
            int depthid = 0; //认为深度是第一列
            for (int j = 0; j < curvesTable.Columns.Count; j++)
            {
                if (curvesTable.Columns[j].ColumnName.ToUpper() == dataStrRef.ToUpper())
                {
                    JObject json = new JObject();
                    json["dataType"] = "Curve";

                    JArray jCols = new JArray();
                    jCols.Add("depth");
                    jCols.Add("value");
                    json["columnName"] = jCols;

                    JArray jDatas = new JArray();
                    for (int k = 0; k < curvesTable.Rows.Count; k++)
                    {
                        JArray tdata = new JArray();
                        tdata.Add(curvesTable.Rows[k][depthid]);
                        tdata.Add(curvesTable.Rows[k][j]);
                        jDatas.Add(tdata);
                    }
                    json["data"] = jDatas;

                    string strJson = JsonConvert.SerializeObject(json);

                    byte[] databytes = Encoding.UTF8.GetBytes(strJson);
                    wellGeo.SetWellTrackDataJson(trackHandle, strJson);
                }
            }
        }

        public static void getWellSandSetsJson(ref string jsonStr, List<cWellSandSet> lstWellSandSets)
        {
            jsonStr = "";
            if (lstWellSandSets.Count == 0)
                return;

            JObject json = new JObject();
            json["dataType"] = "SandSet";

            JArray jCols = new JArray();
            jCols.Add("id");
            jCols.Add("name");
            jCols.Add("top");
            jCols.Add("bottom");
            jCols.Add("result");
            jCols.Add("facies");
            json["columnName"] = jCols;

            JArray jDatas = new JArray();
            for (int k = 0; k < lstWellSandSets.Count; k++)
            {
                JArray tdata = new JArray();
                tdata.Add(lstWellSandSets[k].id.ToString());
                tdata.Add(lstWellSandSets[k].name.ToString());
                tdata.Add(lstWellSandSets[k].top.ToString());
                tdata.Add(lstWellSandSets[k].bottom.ToString());
                tdata.Add(lstWellSandSets[k].result.ToString());
                tdata.Add(lstWellSandSets[k].facies.ToString());

                jDatas.Add(tdata);
            }

            json["data"] = jDatas;
            jsonStr = JsonConvert.SerializeObject(json);
        }

        public static void getStratumDivisionJson(ref string jsonStr, List<cStratumDivision> listStratums)
        {
            jsonStr = "";
            if (listStratums.Count == 0)
                return;

            JObject json = new JObject();
            json["dataType"] = "stratumDivision";
            JArray jCols = new JArray();
            jCols.Add("id");
            jCols.Add("name");
            jCols.Add("code");
            jCols.Add("parentId");
            jCols.Add("classname");
            jCols.Add("orderId");
            json["columnName"] = jCols;

            JArray jDatas = new JArray();
            for (int k = 0; k < listStratums.Count; k++)
            {
                JArray tdata = new JArray();
                tdata.Add(listStratums[k].id.ToString());
                tdata.Add(listStratums[k].name.ToString());
                tdata.Add(listStratums[k].code.ToString());
                tdata.Add(listStratums[k].parentID.ToString());
                tdata.Add(listStratums[k].classname.ToString());
                tdata.Add(listStratums[k].orderId.ToString());
                jDatas.Add(tdata);
            }

            json["data"] = jDatas;
            jsonStr = JsonConvert.SerializeObject(json);
        }

        public static void getReservesLayerJson(ref string jsonStr, List<cWellReservesLayer> lstReservesLayers)
        {
            jsonStr = "";
            if (lstReservesLayers.Count == 0)
                return;

            JObject json = new JObject();
            json["dataType"] = "ReservesLayer";
            JArray jCols = new JArray();
            //  jCols.Add("well");
            jCols.Add("layer");
            jCols.Add("topSecondSandstone");
            jCols.Add("bottomSecondSandstone");
            jCols.Add("topFirstSandstone");
            jCols.Add("bottomFirstSandstone");
            jCols.Add("pureEffectiveTopEstimate");
            jCols.Add("pureEffectiveThicknessEstimate");
            jCols.Add("viewEffectiveTop");
            jCols.Add("viewEffectiveThickness");
            jCols.Add("electricLogInterpretation");
            jCols.Add("facies");
            jCols.Add("subfacies");
            json["columnName"] = jCols;

            JArray jDatas = new JArray();
            for (int k = 0; k < lstReservesLayers.Count; k++)
            {
                JArray tdata = new JArray();
                // tdata.Add(lstReservesLayers[k].well);
                tdata.Add(lstReservesLayers[k].layer);

                tdata.Add(lstReservesLayers[k].topSecondSandstone.ToString());
                tdata.Add(lstReservesLayers[k].bottomSecondSandstone.ToString());
                tdata.Add(lstReservesLayers[k].topFirstSandstone.ToString());
                tdata.Add(lstReservesLayers[k].bottomFirstSandstone.ToString());

                tdata.Add(lstReservesLayers[k].pureEffectiveTopEstimate.ToString());
                tdata.Add(lstReservesLayers[k].pureEffectiveThicknessEstimate.ToString());

                tdata.Add(lstReservesLayers[k].viewEffectiveTop.ToString());
                tdata.Add(lstReservesLayers[k].viewEffectiveThickness.ToString());

                tdata.Add(lstReservesLayers[k].electricLogInterpretation.ToString());

                tdata.Add(lstReservesLayers[k].facies);
                tdata.Add(lstReservesLayers[k].subfacies);

                jDatas.Add(tdata);
            }

            json["data"] = jDatas;
            jsonStr = JsonConvert.SerializeObject(json);
        }

        public static void getInnerLayersJson(ref string jsonStr, List<cWellInnerLayer> lstInnerLayers)
        {
            jsonStr = "";
            if (lstInnerLayers.Count == 0)
                return;

            JObject json = new JObject();
            json["dataType"] = "InnerLayer";
            JArray jCols = new JArray();
            jCols.Add("top");
            jCols.Add("bottom");
            jCols.Add("thickness");
            jCols.Add("type");

            json["columnName"] = jCols;

            JArray jDatas = new JArray();
            for (int k = 0; k < lstInnerLayers.Count; k++)
            {
                JArray tdata = new JArray();
                // tdata.Add(lstReservesLayers[k].well);
                tdata.Add(lstInnerLayers[k].top.ToString());

                tdata.Add(lstInnerLayers[k].bottom.ToString());
                tdata.Add(lstInnerLayers[k].thickness.ToString());
                tdata.Add(lstInnerLayers[k].type);

                jDatas.Add(tdata);
            }
            json["data"] = jDatas;
            jsonStr = JsonConvert.SerializeObject(json);
        }

        public static void getWellLithologysJson(ref string jsonStr, List<cWellLithology> lstLithologys)
        {
            jsonStr = "";
            if (lstLithologys.Count == 0)
                return;

            JObject json = new JObject();
            json["dataType"] = "Lithology";
            JArray jCols = new JArray();
            //  jCols.Add("well");
            jCols.Add("top");
            jCols.Add("bottom");
            jCols.Add("color");
            jCols.Add("oilcontent");
            jCols.Add("inclusions");
            jCols.Add("structure");
            jCols.Add("lithologyprefix");
            jCols.Add("lithology");
            json["columnName"] = jCols;

            JArray jDatas = new JArray();
            for (int k = 0; k < lstLithologys.Count; k++)
            {
                JArray tdata = new JArray();
                // tdata.Add(lstReservesLayers[k].well);
                tdata.Add(lstLithologys[k].top.ToString());
                tdata.Add(lstLithologys[k].bottom.ToString());
                tdata.Add(lstLithologys[k].color);
                tdata.Add(lstLithologys[k].oilcontent);
                tdata.Add(lstLithologys[k].inclusions);
                tdata.Add(lstLithologys[k].structure);
                tdata.Add(lstLithologys[k].lithologyprefix);
                tdata.Add(lstLithologys[k].lithology);
                jDatas.Add(tdata);
            }

            json["data"] = jDatas;
            jsonStr = JsonConvert.SerializeObject(json);
        }

        public static void getWellOilTestJson(ref string jsonStr, List<cWellOilTest> lstOilTests)
        {
            jsonStr = "";
            if (lstOilTests.Count == 0)
                return;

            JObject json = new JObject();
            json["dataType"] = "OilTest";
            JArray jCols = new JArray();

            jCols.Add("top");
            jCols.Add("bottom");
            jCols.Add("conclusion");
            jCols.Add("daily_oil");
            jCols.Add("daily_water");

            jCols.Add("daily_gas");
            jCols.Add("total_oil");
            jCols.Add("total_gas");
            jCols.Add("total_water");
            jCols.Add("method");

            jCols.Add("layer");
            jCols.Add("staticMpa");
            jCols.Add("caseMpa");
            jCols.Add("flowMpa");            
            jCols.Add("density");

            jCols.Add("viscosity");
            jCols.Add("start");
            jCols.Add("end");
            jCols.Add("staticTemperature");
            jCols.Add("thickness");
            jCols.Add("stroke");

            json["columnName"] = jCols;

            JArray jDatas = new JArray();
            for (int k = 0; k < lstOilTests.Count; k++)
            {
                JArray tdata = new JArray();
                tdata.Add(lstOilTests[k].top.ToString());
                tdata.Add(lstOilTests[k].bottom.ToString());
                tdata.Add(lstOilTests[k].verdict);
                tdata.Add(lstOilTests[k].dayOil.ToString());
                tdata.Add(lstOilTests[k].dayWater.ToString());

                tdata.Add(lstOilTests[k].dayGas.ToString());
                tdata.Add(lstOilTests[k].sumOil.ToString());
                tdata.Add(lstOilTests[k].sumWater.ToString());
                tdata.Add(lstOilTests[k].sumGas.ToString());
                tdata.Add(lstOilTests[k].method);

                tdata.Add(lstOilTests[k].layer);
                tdata.Add(lstOilTests[k].staticMpa.ToString());
                tdata.Add(lstOilTests[k].caseMpa.ToString());
                tdata.Add(lstOilTests[k].flowMpa.ToString());
                tdata.Add(lstOilTests[k].density.ToString()); //密度

                tdata.Add(lstOilTests[k].viscosity.ToString());  //粘度
                tdata.Add(lstOilTests[k].startTime);
                tdata.Add(lstOilTests[k].endTime);
                tdata.Add(lstOilTests[k].staticTemperature.ToString());

                tdata.Add(lstOilTests[k].thickness.ToString());
                tdata.Add(lstOilTests[k].stroke.ToString());

                jDatas.Add(tdata);
            }

            json["data"] = jDatas;
            jsonStr = JsonConvert.SerializeObject(json);
        }

        public static void getWellCoringJson(ref string jsonStr,List<cWellCoring>list)
        {
            jsonStr = "";
            if (list.Count == 0)
                return;

            JObject json = new JObject();
            json["dataType"] = "Coring";
            JArray jCols = new JArray();
            //  jCols.Add("well");
            jCols.Add("name");
            jCols.Add("top");
            jCols.Add("bottom");
            jCols.Add("times");
            jCols.Add("length");
            json["columnName"] = jCols;

            JArray jDatas = new JArray();
            for (int k = 0; k < list.Count; k++)
            {
                JArray tdata = new JArray();
                // tdata.Add(lstReservesLayers[k].well);
                tdata.Add(list[k].layer);
                tdata.Add(list[k].top.ToString());
                tdata.Add(list[k].bottom.ToString());
                tdata.Add(list[k].times.ToString());
                tdata.Add(list[k].length.ToString());

                jDatas.Add(tdata);
            }
            json["data"] = jDatas;
            jsonStr = JsonConvert.SerializeObject(json);
        }

        public static void getWellSideWallCoringsJson(ref string jsonStr, List<cWellSideWallCoring> list)
        {
            jsonStr = "";
            if (list.Count == 0)
                return;

            JObject json = new JObject();
            json["dataType"] = "CoreWell";
            JArray jCols = new JArray();
            //  jCols.Add("well");
            jCols.Add("depth");
            jCols.Add("lithology");
            jCols.Add("oil_level");
            jCols.Add("times");
            jCols.Add("color");
            json["columnName"] = jCols;

            JArray jDatas = new JArray();
            for (int k = 0; k < list.Count; k++)
            {
                JArray tdata = new JArray();
                // tdata.Add(lstReservesLayers[k].well);
                tdata.Add(list[k].top.ToString());
                tdata.Add(list[k].lithology);
                tdata.Add(list[k].oilcontent);
                tdata.Add(list[k].number.ToString());
                tdata.Add(list[k].color);

                jDatas.Add(tdata);
            }
            json["data"] = jDatas;
            jsonStr = JsonConvert.SerializeObject(json);
        }
        public static void getWellCyclesJson(ref string jsonStr, List<cWellCycle> lstCycles)
        {
            jsonStr = "";
            if (lstCycles.Count == 0)
                return;


            JObject json = new JObject();
            json["dataType"] = "Cycle";
            JArray jCols = new JArray();
            //  jCols.Add("well");
            jCols.Add("top");
            jCols.Add("bottom");
            jCols.Add("type");
            json["columnName"] = jCols;

            JArray jDatas = new JArray();
            for (int k = 0; k < lstCycles.Count; k++)
            {
                JArray tdata = new JArray();
                // tdata.Add(lstReservesLayers[k].well);
                tdata.Add(lstCycles[k].top.ToString());
                tdata.Add(lstCycles[k].bottom.ToString());
                tdata.Add(lstCycles[k].type);

                jDatas.Add(tdata);
            }
            json["data"] = jDatas;
            jsonStr = JsonConvert.SerializeObject(json);
        }

        public static void getDataJson(string wellName, string sourceId, ref string jsonStr) //通过数据表标识获得数据
        {
            if (sourceId == "Shot")
            {
                List<cPerforation> listPerforations = workAreaDb.Instance.workData.getWellPerforations(wellName);
                getWellPerforationsJson(ref jsonStr, listPerforations);
            }
            if (sourceId == "Lithology")
            {
                List<cWellLithology> lstLiths = workAreaDb.Instance.workData.getWellLithologys(wellName);
                getWellLithologysJson(ref jsonStr, lstLiths);
            }
            else if (sourceId == "OilTest")
            {
                List<cWellOilTest> lstOilTest = workAreaDb.Instance.workData.getWellOilTests(wellName);
                getWellOilTestJson(ref jsonStr, lstOilTest);
            }
            else if (sourceId == "InnerLayer")
            {
                List<cWellInnerLayer> lstInnerLayers = workAreaDb.Instance.workData.getInnerLayers(wellName);
                getInnerLayersJson(ref jsonStr, lstInnerLayers);
            }
        }

        public static bool setWellCycleDataToTrack(GeoSigmaWellPoleXY geoWell, string wellName, UInt64 cycleTrack, string cycleTableType)
        {
            bool b = false;
            int cycleId = 2;
            if (cycleTableType == WellObjectBaseInfo.CycleTableTypes[(int)(WellObjectBaseInfo.eCycleDataType.CycleLongterm)]) //"CycleLongterm")
                cycleId = 1;
            else if (cycleTableType == WellObjectBaseInfo.CycleTableTypes[(int)(WellObjectBaseInfo.eCycleDataType.CycleShortterm)])
                cycleId = 3;

            List<cWellCycle> lstCycles = workAreaDb.Instance.workData.getWellCycles(wellName, cycleId);
            if (lstCycles.Count > 0)
            {
                string jsonStr = "";
                WellDataConvert.getWellCyclesJson(ref jsonStr, lstCycles);
                b = geoWell.SetWellTrackDataJson(cycleTrack, jsonStr);
            }
            return b;
        }

        /// <summary>
        //目前 读取的井数据使用的是InterfaceWorkArea中的结构，
        // 写入井使用WorkData中的实体,注意区别
        /// </summary>
        //enum eLithid {well, top , bottom, thickness, color , oilcontent , inclusions, lithologyprefix, structure,
        //  lithology,firstlayer, secondlayer ,fourthlayer, fifthlayer};

        public static bool getWellLithologyFromJson(string jh, string jsonStr, out List<WellLithology> listWellLith)
        {
            string[] Cols = { "well", "top", "bottom", "thickness", "color", "oilcontent", "inclusions", "lithologyprefix",
            "structure", "lithology", "firstlayer", "secondlayer", "fourthlayer", "fifthlayer" };
            StringIntMapper colMap = new StringIntMapper();
            for (int i = 0; i < Cols.Length; i++)
            {
                colMap.AddMapping(Cols[i]);
            }

            listWellLith = new List<WellLithology>();
            bool b = false;
            try
            {
                JObject json = JObject.Parse(jsonStr);
                bool bType = json.ContainsKey("dataType");
                bool bhaveCols = json.ContainsKey("columnName");
                bool bhaveData = json.ContainsKey("data");
                if (bType && bhaveCols && bhaveData)
                {
                    string typeName = json["dataType"].ToString();
                    if (typeName == "Lithology")
                    {
                        JArray jCols = (JArray)json["columnName"];
                        JArray jDatas = (JArray)json["data"];

                        for (int i = 0; i < jCols.Count; i++)
                        {
                            string col = jCols[i].ToString();
                            if (colMap.HasKey(col))
                                colMap.UpdateMapping(col, i);
                        }
                        int id = DBHelp.Db.Queryable<WellLithology>().Max<int>("id") + 1;
                        for (int i = 0; i < jDatas.Count; i++)
                        {
                            JArray jRec = (JArray)jDatas[i];
                            WellLithology wellLith = new WellLithology();
                            wellLith.ID = id;
                            for (int j = 0; j < jCols.Count; j++)
                            {

                                wellLith.Well = jh;
                                if (colMap["top"] > -1)
                                { wellLith.top = Convert.ToDouble(jRec[colMap["top"]].ToString()); }
                                if (colMap["bottom"] > -1)
                                { wellLith.bottom = Convert.ToDouble(jRec[colMap["bottom"]].ToString()); }

                                wellLith.thickness = wellLith.bottom - wellLith.top;

                                if (colMap["color"] > -1)
                                { wellLith.color = jRec[colMap["color"]].ToString(); }

                                if (colMap["oilcontent"] > -1)
                                { wellLith.oilcontent = jRec[colMap["oilcontent"]].ToString(); }

                                if (colMap["inclusions"] > -1)
                                { wellLith.inclusions = jRec[colMap["inclusions"]].ToString(); }

                                if (colMap["lithologyprefix"] > -1)
                                { wellLith.lithologyprefix = jRec[colMap["lithologyprefix"]].ToString(); }

                                if (colMap["structure"] > -1)
                                { wellLith.structure = jRec[colMap["structure"]].ToString(); }

                                if (colMap["lithology"] > -1)
                                { wellLith.lithology = jRec[colMap["lithology"]].ToString(); }

                                if (colMap["firstlayer"] > -1)
                                { wellLith.firstlayer = jRec[colMap["firstlayer"]].ToString(); }

                                if (colMap["secondlayer"] > -1)
                                { wellLith.secondlayer = jRec[colMap["secondlayer"]].ToString(); }

                                if (colMap["thirdlayer"] > -1)
                                { wellLith.thirdlayer = jRec[colMap["thirdlayer"]].ToString(); }

                                if (colMap["fourthlayer"] > -1)
                                { wellLith.fourthlayer = jRec[colMap["fourthlayer"]].ToString(); }

                                if (colMap["fifthlayer"] > -1)
                                { wellLith.fifthlayer = jRec[colMap["fifthlayer"]].ToString(); }

                                if (colMap["lithologyname"] > -1)
                                { wellLith.lithologyname = jRec[colMap["lithologyname"]].ToString(); }

                                if (colMap["markerlayer"] > -1)
                                { wellLith.markerlayer = jRec[colMap["markerlayer"]].ToString(); }
                            }

                            listWellLith.Add(wellLith);
                            id++;
                        }
                        b = true;
                    }
                }
            }
            catch (Exception ex)
            {
                b = false;
            }

            return b;
        }

        public static bool getWellInnerLayerFromJson(string jh, string jsonStr, out List<WellInnerLayer> listWellInner)
        {
            string[] Cols = { "well", "top", "bottom", "thickness", "type" };
            StringIntMapper colMap = new StringIntMapper();
            for (int i = 0; i < Cols.Length; i++)
            {
                colMap.AddMapping(Cols[i]);
            }

            listWellInner = new List<WellInnerLayer>();
            bool b = false;
            try
            {
                JObject json = JObject.Parse(jsonStr);
                bool bType = json.ContainsKey("dataType");
                bool bhaveCols = json.ContainsKey("columnName");
                bool bhaveData = json.ContainsKey("data");
                if (bType && bhaveCols && bhaveData)
                {
                    string typeName = json["dataType"].ToString();
                    if (typeName == "InnerLayer")
                    {
                        JArray jCols = (JArray)json["columnName"];
                        JArray jDatas = (JArray)json["data"];

                        for (int i = 0; i < jCols.Count; i++)
                        {
                            string col = jCols[i].ToString();
                            if (colMap.HasKey(col))
                                colMap.UpdateMapping(col, i);
                        }
                        int id = DBHelp.Db.Queryable<WellInnerLayer>().Max<int>("id") + 1;
                        for (int i = 0; i < jDatas.Count; i++)
                        {
                            JArray jRec = (JArray)jDatas[i];
                            WellInnerLayer welldata = new WellInnerLayer();
                            welldata.ID = id;
                            for (int j = 0; j < jCols.Count; j++)
                            {
                                welldata.Well = jh;

                                if (colMap["top"] > -1)
                                { welldata.top = Convert.ToDouble(jRec[colMap["top"]].ToString()); }
                                if (colMap["bottom"] > -1)
                                { welldata.bottom = Convert.ToDouble(jRec[colMap["bottom"]].ToString()); }

                                welldata.thickness = welldata.bottom - welldata.top;

                                if (colMap["type"] > -1)
                                { welldata.type = jRec[colMap["type"]].ToString(); }

                            }

                            listWellInner.Add(welldata);
                            id++;
                        }
                        b = true;
                    }
                }
            }
            catch (Exception ex)
            {
                b = false;
            }
            return b;
        }

        public static bool getWellPerforationFromJson(string jh, string jsonStr, out List<WellPerforation> list)
        {
            string[] Cols = { "JH", "DS", "DS2", "CW", "SK" };
            //Dictionary<string, string> colNameMap = new Dictionary<string, string> { { "DS", "" }, };
            StringIntMapper colMap = new StringIntMapper();
            for (int i = 0; i < Cols.Length; i++)
            {
                colMap.AddMapping(Cols[i]);
            }

            list = new List<WellPerforation>();
            bool b = false;
            try
            {
                JObject json = JObject.Parse(jsonStr);
                bool bType = json.ContainsKey("dataType");
                bool bhaveCols = json.ContainsKey("columnName");
                bool bhaveData = json.ContainsKey("data");
                if (bType && bhaveCols && bhaveData)
                {
                    string typeName = json["dataType"].ToString();
                    if (typeName == "Shot")
                    {
                        JArray jCols = (JArray)json["columnName"];
                        JArray jDatas = (JArray)json["data"];

                        for (int i = 0; i < jCols.Count; i++)
                        {
                            string col = jCols[i].ToString();
                            if (col == "name")
                                colMap.UpdateMapping("CW", i);
                            if (col == "top")
                                colMap.UpdateMapping("DS", i);
                            if (col == "bottom")
                                colMap.UpdateMapping("DS2", i);
                            if (col == "method")
                                colMap.UpdateMapping("SK", i);
                        }
                        int id = DBHelp.Db.Queryable<WellPerforation>().Max<int>("id") + 1;
                        int xhid = DBHelp.Db.Queryable<WellPerforation>().Max<int>("xhid") + 1;
                        for (int i = 0; i < jDatas.Count; i++)
                        {
                            JArray jRec = (JArray)jDatas[i];
                            WellPerforation welldata = new WellPerforation();
                            welldata.ID = id;
                            welldata.XHID = xhid;
                            for (int j = 0; j < jCols.Count; j++)
                            {
                                welldata.JH = jh;
                                if (colMap["DS"] > -1)
                                { welldata.DS = Convert.ToDouble(jRec[colMap["DS"]].ToString()); }
                                if (colMap["DS2"] > -1)
                                { welldata.DS2 = Convert.ToDouble(jRec[colMap["DS2"]].ToString()); }
                                if (colMap["CW"] > -1)
                                { welldata.CW = jRec[colMap["CW"]].ToString(); }
                                if (colMap["SK"] > -1)
                                { welldata.SK = jRec[colMap["SK"]].ToString(); }
                            }

                            list.Add(welldata);
                            id++;
                            xhid++;
                        }
                        b = true;
                    }
                }
            }
            catch (Exception ex)
            {
                b = false;
            }
            return b;
        }

        public static void getColNameAndDatasFromJson(string jsonStr, ref string dataType, ref string[] colName, ref string[,] strData)
        { //从json串中获得数据
            JObject json = JObject.Parse(jsonStr);

            dataType = (string)json["dataType"];
            JArray colNames = (JArray)json["columnName"];

            colName = new string[colNames.Count()];

            int ii = 0;
            foreach (string jitem in colNames)
            {
                //JObject j = (JObject)jitem;
                colName[ii] = jitem; // j.ToString();
                ii++;
            }

            ii = 0;
            JArray datas = (JArray)json["data"];
            strData = new string[datas.Count(), colNames.Count()];

            foreach (var jitem in datas)
            {
                JArray jarr = (JArray)jitem;
                int jj = 0;
                foreach (string jstr in jarr)
                {
                    strData[ii, jj] = jstr; // Encoding.Unicode.GetString(unicodebytes); //           Encoding.UTF8.GetString(utf8byts);
                    jj++;
                }
                ii++;
            }
        }

        public static bool getWellFaultsFromJson(string jh, string jsonStr, out List<WellBreakPoint> list)
        {
            string[] Cols = { "JH", "DCBH", "DDSD", "DSDC", "DSDC2", "DBJDS", "DBJDS2" };
            StringIntMapper colMap = new StringIntMapper();
            for (int i = 0; i < Cols.Length; i++)
            {
                colMap.AddMapping(Cols[i]);
            }

            bool b = false;
            list = new List<WellBreakPoint>();

            try
            {
                JObject json = JObject.Parse(jsonStr);
                bool bType = json.ContainsKey("dataType");
                bool bhaveCols = json.ContainsKey("columnName");
                bool bhaveData = json.ContainsKey("data");
                if (bType && bhaveCols && bhaveData)
                {
                    string typeName = json["dataType"].ToString();
                    if (typeName == "FaultPoint")
                    {
                        JArray jCols = (JArray)json["columnName"];
                        JArray jDatas = (JArray)json["data"];

                        for (int i = 0; i < jCols.Count; i++)
                        {
                            string col = jCols[i].ToString();
                            if (col == "name")
                                colMap.UpdateMapping("DCBH", i);
                            if (col == "depth")
                                colMap.UpdateMapping("DDSD", i);
                            if (col == "topLayer")
                                colMap.UpdateMapping("DSDC", i);
                            if (col == "bottomLayer")
                                colMap.UpdateMapping("DSDC2", i);
                            if (col == "compareWellTop")
                                colMap.UpdateMapping("DBJDS", i);
                            if (col == "compareWellBottom")
                                colMap.UpdateMapping("DBJDS2", i);
                        }
                        int id = DBHelp.Db.Queryable<WellBreakPoint>().Max<int>("id") + 1;
                        int xhid = DBHelp.Db.Queryable<WellBreakPoint>().Max<int>("XHID") + 1;
                        for (int i = 0; i < jDatas.Count; i++)
                        {
                            JArray jRec = (JArray)jDatas[i];
                            WellBreakPoint welldata = new WellBreakPoint();
                            welldata.ID = id;
                            welldata.XHID = id;
                            for (int j = 0; j < jCols.Count; j++)
                            {
                                welldata.JH = jh;
                                if (colMap["DCBH"] > -1)
                                { welldata.DCBH = (jRec[colMap["DCBH"]].ToString()); }

                                if (colMap["DDSD"] > -1)
                                { welldata.DDSD = Convert.ToDouble(jRec[colMap["DDSD"]].ToString()); }

                                if (colMap["DSDC"] > -1)
                                { welldata.DSDC = jRec[colMap["DSDC"]].ToString(); }

                                if (colMap["DSDC2"] > -1)
                                { welldata.DSDC2 = jRec[colMap["DSDC2"]].ToString(); }

                                if (colMap["DBJDS"] > -1)
                                { welldata.DBJDS = Convert.ToDouble(jRec[colMap["DBJDS"]].ToString()); }

                                if (colMap["DBJDS2"] > -1)
                                { welldata.DBJDS2 = Convert.ToDouble(jRec[colMap["DBJDS2"]].ToString()); }
                            }

                            list.Add(welldata);
                            id++;
                            xhid++;
                        }
                        b = true;
                    }
                }
            }
            catch (Exception ex)
            {
                b = false;
            }

            return b;
        }

        public static bool getWellInterpretDrillLayerFromJson(string jh, string jsonStr, out List<InterpretDrillWellLayered> list)
        {
            string[] Cols = { "JH", "CW", "SD", "DJSD", "JSJL" };
            //Dictionary<string, string> colNameMap = new Dictionary<string, string> { { "DS", "" }, };
            StringIntMapper colMap = new StringIntMapper();
            for (int i = 0; i < Cols.Length; i++)
            {
                colMap.AddMapping(Cols[i]);
            }

            list = new List<InterpretDrillWellLayered>();
            bool b = false;
            try
            {
                JObject json = JObject.Parse(jsonStr);
                bool bType = json.ContainsKey("dataType");
                bool bhaveCols = json.ContainsKey("columnName");
                bool bhaveData = json.ContainsKey("data");
                if (bType && bhaveCols && bhaveData)
                {
                    string typeName = json["dataType"].ToString();
                    if (typeName == "SandSet")  //砂层组对应 kep井分层
                    {
                        JArray jCols = (JArray)json["columnName"];
                        JArray jDatas = (JArray)json["data"];

                        for (int i = 0; i < jCols.Count; i++)
                        {
                            string col = jCols[i].ToString();
                            if (col == "name")
                                colMap.UpdateMapping("CW", i);
                            if (col == "top")
                                colMap.UpdateMapping("SD", i);
                            if (col == "bottom")
                                colMap.UpdateMapping("DJSD", i);
                            if (col == "result")
                                colMap.UpdateMapping("JSJL", i);
                        }
                        int id = DBHelp.Db.Queryable<InterpretDrillWellLayered>().Max<int>("id") + 1;
                        int xhid = DBHelp.Db.Queryable<InterpretDrillWellLayered>().Max<int>("XHID") + 1;
                        for (int i = 0; i < jDatas.Count; i++)
                        {
                            JArray jRec = (JArray)jDatas[i];
                            InterpretDrillWellLayered welldata = new InterpretDrillWellLayered();
                            welldata.ID = id;
                            welldata.XHID = xhid;
                            for (int j = 0; j < jCols.Count; j++)
                            {
                                welldata.JH = jh;
                                if (colMap["SD"] > -1)
                                { welldata.SD = Convert.ToDouble(jRec[colMap["SD"]].ToString()); }
                                if (colMap["DJSD"] > -1)
                                { welldata.DJSD = Convert.ToDouble(jRec[colMap["DJSD"]].ToString()); }
                                if (colMap["CW"] > -1)
                                { welldata.CW = jRec[colMap["CW"]].ToString(); }
                                if (colMap["JSJL"] > -1)
                                { welldata.JSJL = jRec[colMap["JSJL"]].ToString(); }

                                welldata.HD = welldata.DJSD - welldata.SD;
                            }

                            list.Add(welldata);
                            id++;
                            xhid++;
                        }
                        b = true;
                    }
                }
            }
            catch (Exception ex)
            {
                b = false;
            }
            return b;
        }

        public static bool getWellReserversLayerFromJson(string jh, string jsonStr, out List<WellReservesLayer> list)
        {
            string[] Cols = { "layer", "topSecondSandstone", "bottomSecondSandstone", "topFirstSandstone", "bottomFirstSandstone",
            "pureEffectiveTopEstimate","pureEffectiveThicknessEstimate","electricLogInterpretation","facies","subfacies"};
            StringIntMapper colMap = new StringIntMapper();
            for (int i = 0; i < Cols.Length; i++)
            {
                colMap.AddMapping(Cols[i]);
            }

            list = new List<WellReservesLayer>();
            bool b = false;
            try
            {
                JObject json = JObject.Parse(jsonStr);
                bool bType = json.ContainsKey("dataType");
                bool bhaveCols = json.ContainsKey("columnName");
                bool bhaveData = json.ContainsKey("data");
                if (bType && bhaveCols && bhaveData)
                {
                    string typeName = json["dataType"].ToString();
                    if (typeName == "ReservesLayer")
                    {
                        JArray jCols = (JArray)json["columnName"];
                        JArray jDatas = (JArray)json["data"];

                        for (int i = 0; i < jCols.Count; i++)
                        {
                            string col = jCols[i].ToString();
                            if (colMap.HasKey(col))
                                colMap.UpdateMapping(col, i);
                        }
                        int id = DBHelp.Db.Queryable<WellReservesLayer>().Max<int>("id") + 1;
                        for (int i = 0; i < jDatas.Count; i++)
                        {
                            JArray jRec = (JArray)jDatas[i];
                            WellReservesLayer welldata = new WellReservesLayer();
                            welldata.ID = id;
                            for (int j = 0; j < jCols.Count; j++)
                            {
                                welldata.Well = jh;

                                if (colMap["layer"] > -1)
                                { welldata.Layer = jRec[colMap["layer"]].ToString(); }

                                if (colMap["topSecondSandstone"] > -1)
                                { welldata.TopSecondSandstone = Convert.ToDouble(jRec[colMap["topSecondSandstone"]].ToString()); }

                                if (colMap["bottomSecondSandstone"] > -1)
                                { welldata.BottomSecondSandstone = Convert.ToDouble(jRec[colMap["bottomSecondSandstone"]].ToString()); }

                                if (colMap["topFirstSandstone"] > -1)
                                { welldata.TopFirstSandstone = Convert.ToDouble(jRec[colMap["topFirstSandstone"]].ToString()); }

                                if (colMap["bottomFirstSandstone"] > -1)
                                { welldata.BottomFirstSandstone = Convert.ToDouble(jRec[colMap["bottomFirstSandstone"]].ToString()); }

                                if (colMap["pureEffectiveTopEstimate"] > -1)
                                { welldata.PureEffectiveTopEstimate = Convert.ToDouble(jRec[colMap["pureEffectiveTopEstimate"]].ToString()); }

                                if (colMap["pureEffectiveThicknessEstimate"] > -1)
                                { welldata.PureEffectiveThicknessEstimate = Convert.ToDouble(jRec[colMap["pureEffectiveThicknessEstimate"]].ToString()); }

                                if (colMap["electricLogInterpretation"] > -1)
                                { welldata.ElectricLogInterpretation = jRec[colMap["electricLogInterpretation"]].ToString(); }

                                if (colMap["facies"] > -1)
                                { welldata.Facies = jRec[colMap["facies"]].ToString(); }

                                if (colMap["subfacies"] > -1)
                                { welldata.Subfacies = jRec[colMap["subfacies"]].ToString(); }
                            }

                            list.Add(welldata);
                            id++;
                        }
                        b = true;
                    }
                }
            }
            catch (Exception ex)
            {
                b = false;
            }
            return b;
        }

        public static bool getWellLongCyClesJsonFromJson(string jh, string jsonStr, out List<CycleLongterm> list)
        {
            string[] Cols = { "Well", "top", "bottom", "type" };
            StringIntMapper colMap = new StringIntMapper();
            for (int i = 0; i < Cols.Length; i++)
            {
                colMap.AddMapping(Cols[i]);
            }

            list = new List<CycleLongterm>();
            bool b = false;
            try
            {
                JObject json = JObject.Parse(jsonStr);
                bool bType = json.ContainsKey("dataType");
                bool bhaveCols = json.ContainsKey("columnName");
                bool bhaveData = json.ContainsKey("data");
                if (bType && bhaveCols && bhaveData)
                {
                    string typeName = json["dataType"].ToString();
                    if (typeName == "Cycle")
                    {
                        JArray jCols = (JArray)json["columnName"];
                        JArray jDatas = (JArray)json["data"];

                        for (int i = 0; i < jCols.Count; i++)
                        {
                            string col = jCols[i].ToString();
                            if (colMap.HasKey(col))
                                colMap.UpdateMapping(col, i);
                        }
                        int id = DBHelp.Db.Queryable<CycleLongterm>().Max<int>("id") + 1;
                        for (int i = 0; i < jDatas.Count; i++)
                        {
                            JArray jRec = (JArray)jDatas[i];
                            CycleLongterm welldata = new CycleLongterm();
                            welldata.ID = id;
                            for (int j = 0; j < jCols.Count; j++)
                            {
                                welldata.Well = jh;

                                if (colMap["top"] > -1)
                                { welldata.top = Convert.ToDouble(jRec[colMap["top"]].ToString()); }
                                if (colMap["bottom"] > -1)
                                { welldata.bottom = Convert.ToDouble(jRec[colMap["bottom"]].ToString()); }
                                if (colMap["type"] > -1)
                                { welldata.type = jRec[colMap["type"]].ToString(); }

                            }

                            list.Add(welldata);
                            id++;
                        }
                        b = true;
                    }
                }
            }
            catch (Exception ex)
            {
                b = false;
            }
            return b;
        }

        public static bool getWellMediumCyClesJsonFromJson(string jh, string jsonStr, out List<CycleMediumterm> list)
        {
            string[] Cols = { "Well", "top", "bottom", "type" };
            StringIntMapper colMap = new StringIntMapper();
            for (int i = 0; i < Cols.Length; i++)
            {
                colMap.AddMapping(Cols[i]);
            }

            list = new List<CycleMediumterm>();
            bool b = false;
            try
            {
                JObject json = JObject.Parse(jsonStr);
                bool bType = json.ContainsKey("dataType");
                bool bhaveCols = json.ContainsKey("columnName");
                bool bhaveData = json.ContainsKey("data");
                if (bType && bhaveCols && bhaveData)
                {
                    string typeName = json["dataType"].ToString();
                    if (typeName == "Cycle")
                    {
                        JArray jCols = (JArray)json["columnName"];
                        JArray jDatas = (JArray)json["data"];

                        for (int i = 0; i < jCols.Count; i++)
                        {
                            string col = jCols[i].ToString();
                            if (colMap.HasKey(col))
                                colMap.UpdateMapping(col, i);
                        }
                        int id = DBHelp.Db.Queryable<CycleMediumterm>().Max<int>("id") + 1;
                        for (int i = 0; i < jDatas.Count; i++)
                        {
                            JArray jRec = (JArray)jDatas[i];
                            CycleMediumterm welldata = new CycleMediumterm();
                            welldata.ID = id;
                            for (int j = 0; j < jCols.Count; j++)
                            {
                                welldata.Well = jh;

                                if (colMap["top"] > -1)
                                { welldata.top = Convert.ToDouble(jRec[colMap["top"]].ToString()); }
                                if (colMap["bottom"] > -1)
                                { welldata.bottom = Convert.ToDouble(jRec[colMap["bottom"]].ToString()); }
                                if (colMap["type"] > -1)
                                { welldata.type = jRec[colMap["type"]].ToString(); }
                            }

                            list.Add(welldata);
                            id++;
                        }
                        b = true;
                    }
                }
            }
            catch (Exception ex)
            {
                b = false;
            }
            return b;
        }
        public static bool getWellShortCyClesJsonFromJson(string jh, string jsonStr, out List<CycleShortterm> list)
        {
            string[] Cols = { "Well", "top", "bottom", "type" };
            StringIntMapper colMap = new StringIntMapper();
            for (int i = 0; i < Cols.Length; i++)
            {
                colMap.AddMapping(Cols[i]);
            }

            list = new List<CycleShortterm>();
            bool b = false;
            try
            {
                JObject json = JObject.Parse(jsonStr);
                bool bType = json.ContainsKey("dataType");
                bool bhaveCols = json.ContainsKey("columnName");
                bool bhaveData = json.ContainsKey("data");
                if (bType && bhaveCols && bhaveData)
                {
                    string typeName = json["dataType"].ToString();
                    if (typeName == "Cycle")
                    {
                        JArray jCols = (JArray)json["columnName"];
                        JArray jDatas = (JArray)json["data"];

                        for (int i = 0; i < jCols.Count; i++)
                        {
                            string col = jCols[i].ToString();
                            if (colMap.HasKey(col))
                                colMap.UpdateMapping(col, i);
                        }
                        int id = DBHelp.Db.Queryable<CycleShortterm>().Max<int>("id") + 1;
                        for (int i = 0; i < jDatas.Count; i++)
                        {
                            JArray jRec = (JArray)jDatas[i];
                            CycleShortterm welldata = new CycleShortterm();
                            welldata.ID = id;
                            for (int j = 0; j < jCols.Count; j++)
                            {
                                welldata.Well = jh;

                                if (colMap["top"] > -1)
                                { welldata.top = Convert.ToDouble(jRec[colMap["top"]].ToString()); }
                                if (colMap["bottom"] > -1)
                                { welldata.bottom = Convert.ToDouble(jRec[colMap["bottom"]].ToString()); }
                                if (colMap["type"] > -1)
                                { welldata.type = jRec[colMap["type"]].ToString(); }
                            }

                            list.Add(welldata);
                            id++;
                        }
                        b = true;
                    }
                }
            }
            catch (Exception ex)
            {
                b = false;
            }
            return b;
        }

        public static List<T> GetRowsList<T>( Expression<Func<T, bool>> expression)
        {
            //ISugarQueryable<T> query = DBHelp.NewDb.Queryable<T>();
            //query = query.Where(expression);
            //List<T> list = new List<T>();
            //query.ForEach(x =>
            //{
            //    list.Add(x);
            //});

            //return list;
            return DBHelp.NewDb.Queryable<T>()
                          .Where(expression)
                          .ToList();
        }

        //public  static List<int> getColumnIDInDataset<T>(DataItems dataitems)
        //{
        //    List<int> idList = new List<int>();

        //    List<EntityColumnInfo> colInfos = DBHelp.GetEntityColumnInfo(typeof(T));
        //    for(int i = 0; i < dataitems.DataItem.Count; i++)
        //    {
        //        for (int jj = 0; jj < colInfos.Count; jj++)
        //        {
        //            if (dataitems.DataItem[i].RefColId == colInfos[jj].DbColumnName)
        //            {
        //                idList.Add(jj);
        //                break;
        //            }
        //        }
        //    }

        //    return idList;
        //}

       public static List<Dictionary<string, object>> ExtractToDictionaryList<T>(List<T> source,List<string> columnNames)
        {
            var result = new List<Dictionary<string, object>>();

            foreach (var item in source)
            {
                var dict = new Dictionary<string, object>();

                foreach (var columnName in columnNames)
                {
                    var property = typeof(T).GetProperty(columnName);
                    if (property != null)
                    {
                        var value = property.GetValue(item);
                        dict[columnName] = value ?? DBNull.Value;
                    }
                }

                result.Add(dict);
            }

            return result;
        }

        public static bool setWellTableDataToTrack(GeoSigmaWellPoleXY geoWell, string wellName, UInt64 trackHandle, string tableId,string  colName)
        {
            bool b = false;
            if (tableId == "" || colName=="")
                return b;

            List<string> colNames = new List<string>();
            colNames.Add(colName);
            List<Dictionary<string, object>> dataset = null;
            if (tableId == DBHelp.GetTableName<WellReservesLayer>())
            {
                List<WellReservesLayer> listData = GetRowsList<WellReservesLayer>(o => o.Well == wellName);
                
                colNames.Insert(0, "TopSecondSandstone");
                colNames.Insert(1, "BottomSecondSandstone");

                dataset = ExtractToDictionaryList<WellReservesLayer>(listData, colNames);
            }
            else if (tableId == DBHelp.GetTableName<WellLithology>())
            {
                List<WellLithology> listData = GetRowsList<WellLithology>(o => o.Well == wellName);
                colNames.Insert(0, "top");
                colNames.Insert(1, "bottom");
                dataset = ExtractToDictionaryList<WellLithology>(listData, colNames);
                b = true;
            }
            else if (tableId == DBHelp.GetTableName<WellPerforation>())
            {
                List<WellPerforation> listData = GetRowsList<WellPerforation>(o => o.JH == wellName);
                colNames.Insert(0, "DS");
                colNames.Insert(1, "DS2");
                dataset = ExtractToDictionaryList<WellPerforation>(listData, colNames);
                b = true;
            }
            else if (tableId == DBHelp.GetTableName<InterpretDrillWellLayered>())
            {
                List<InterpretDrillWellLayered> listData = GetRowsList<InterpretDrillWellLayered>(o => o.JH == wellName);
                colNames.Insert(0, "SD");
                colNames.Insert(1, "DJSD");
                dataset = ExtractToDictionaryList<InterpretDrillWellLayered>(listData, colNames);
                b = true;
            }
            else if (tableId == DBHelp.GetTableName<WellInnerLayer>())
            {
                List<WellInnerLayer> listData = GetRowsList<WellInnerLayer>(o => o.Well == wellName);
                colNames.Insert(0, "top");
                colNames.Insert(1, "bottom");
                dataset = ExtractToDictionaryList<WellInnerLayer>(listData, colNames);
                b = true;
            }
            else if (tableId == DBHelp.GetTableName<WellLithologicalAnalysis>())
            {
                List<WellLithologicalAnalysis> listData = GetRowsList<WellLithologicalAnalysis>(o => o.Well == wellName);
                colNames.Insert(0, "top");
                colNames.Insert(1, "bottom");
                dataset = ExtractToDictionaryList<WellLithologicalAnalysis>(listData, colNames);
                b = true;
            }
            else if (tableId == DBHelp.GetTableName<WellSideWallCoring>())
            {
                List<WellSideWallCoring> listData = GetRowsList<WellSideWallCoring>(o => o.Well == wellName);
                colNames.Insert(0, "top");
                colNames.Insert(1, "bottom");
                dataset = ExtractToDictionaryList<WellSideWallCoring>(listData, colNames);
                b = true;
            }
            else if (tableId == DBHelp.GetTableName<WellCoring>())
            {
                List<WellCoring> listData = GetRowsList<WellCoring>(o => o.Well == wellName);
                colNames.Insert(0, "top");
                colNames.Insert(1, "bottom");
                dataset = ExtractToDictionaryList<WellCoring>(listData, colNames);
                b = true;
            }

            if (dataset.Count == 0)
                return b;


            JObject json = new JObject();
            json["dataType"] = "Data";
            JArray jCols = new JArray();
            jCols.Add("top");
            jCols.Add("bottom");
            jCols.Add("name");

            json["columnName"] = jCols;

            JArray jDatas = new JArray();
            for (int k = 0; k < dataset.Count; k++)
            {
                JArray tdata = new JArray();

                for (int h = 0; h < colNames.Count; h++)
                {
                    if (dataset[k].TryGetValue(colNames[h], out object val))
                    {
                        tdata.Add(val.ToString());
                    }
                    else
                        tdata.Add("");
                }
                jDatas.Add(tdata);
            }

            json["data"] = jDatas;
            string jsonStr = "";
            jsonStr = JsonConvert.SerializeObject(json);

            b = geoWell.SetWellTrackDataJson( trackHandle, jsonStr);

            return b;
        }
        public static bool setDataToWellCommonDataTrack(GeoSigmaWellPoleXY geoWell, string wellName, UInt64 commonDataTrack, string refTable, DataItems tdataItems)
        {
            bool b = false;
            if (refTable == "")
                return b;

            List<string> colNames = new List<string>();
            for(int i =0; i < tdataItems.DataItem.Count; i++)
            {
                colNames.Add(tdataItems.DataItem[i].RefColId);
            }

            List<Dictionary<string, object>> dataset = null;
            if (refTable == DBHelp.GetTableName<WellReservesLayer>())
            {
                List<WellReservesLayer> listData = GetRowsList<WellReservesLayer>(o => o.Well == wellName);

                 if (tdataItems.DepthSegmentMode == "SecondTopBottom")
                {
                    colNames.Insert(0, "TopSecondSandstone");
                    colNames.Insert(1, "BottomSecondSandstone");
                }
                else if (tdataItems.DepthSegmentMode == "PureEffectiveTopBottom")
                {
                    colNames.Insert(0, "PureEffectiveTopEstimate");
                    colNames.Insert(1, "PureEffectiveThicknessEstimate");
                }
                else if (tdataItems.DepthSegmentMode == "ViewEffectiveTopBottom")
                {
                    colNames.Insert(0, "ViewEffectiveTop");
                    colNames.Insert(1, "ViewEffectiveThickness");
                }
                else
                {
                    colNames.Insert(0, "TopFirstSandstone");
                    colNames.Insert(1, "BottomFirstSandstone");
                }

                dataset = ExtractToDictionaryList<WellReservesLayer>(listData, colNames);
                if (tdataItems.DepthSegmentMode == "PureEffectiveTopBottom")
                {
                    for(int i =0; i< dataset.Count; i++)
                    {
                        double dtop = 0;
                        double dbottom = 0;
                        if (dataset[i].TryGetValue("PureEffectiveTopEstimate", out object top) && dataset[i].TryGetValue("PureEffectiveThicknessEstimate", out object thick))
                        {
                            if(double.TryParse(top.ToString(), out double top1)&& double.TryParse(thick.ToString(),out double thick1))
                            {
                                dtop = top1;
                                dbottom = top1 + thick1;

                                dataset[i]["PureEffectiveThicknessEstimate"] = dbottom.ToString(); //计算出底深
                            }
                            else
                            {//无效顶底深，就赋值为0
                                dataset[i]["PureEffectiveTopEstimate"] = "0".ToString();
                                dataset[i]["PureEffectiveThicknessEstimate"] = "0".ToString();
                            }
                        }
                        else
                        {
                            dataset[i]["PureEffectiveTopEstimate"] = "0".ToString();
                            dataset[i]["PureEffectiveThicknessEstimate"] = "0".ToString();
                        }
                    }
                }
                else if (tdataItems.DepthSegmentMode == "ViewEffectiveTopBottom")
                {
                    for (int i = 0; i < dataset.Count; i++)
                    {
                        double dtop = 0;
                        double dbottom = 0;
                        if (dataset[i].TryGetValue("ViewEffectiveTop", out object top) && dataset[i].TryGetValue("ViewEffectiveThickness", out object thick))
                        {
                            if (double.TryParse(top.ToString(), out double top1) && double.TryParse(thick.ToString(), out double thick1))
                            {
                                dtop = top1;
                                dbottom = top1 + thick1;

                                dataset[i]["ViewEffectiveThickness"] = dbottom.ToString(); //计算出底深
                            }
                            else
                            {//无效顶底深，就赋值为0
                                dataset[i]["ViewEffectiveTop"] = "0".ToString();
                                dataset[i]["ViewEffectiveThickness"] = "0".ToString();
                            }
                        }
                        else
                        {
                            dataset[i]["ViewEffectiveTop"] = "0".ToString();
                            dataset[i]["ViewEffectiveThickness"] = "0".ToString();
                        }
                    }
                }

                b = true;
            }
            else if (refTable == DBHelp.GetTableName<WellLithology>())
            {
                List<WellLithology> listData = GetRowsList<WellLithology>( o => o.Well == wellName);
                colNames.Insert(0, "top");
                colNames.Insert(1, "bottom");
                dataset = ExtractToDictionaryList<WellLithology>(listData, colNames);
                b = true;
            }
            else if (refTable == DBHelp.GetTableName<WellPerforation>())
            {
                List<WellPerforation> listData = GetRowsList<WellPerforation>(o => o.JH == wellName);
                colNames.Insert(0, "DS");
                colNames.Insert(1, "DS2");
                dataset = ExtractToDictionaryList<WellPerforation>(listData, colNames);
                b = true;
            }
            else if (refTable == DBHelp.GetTableName<InterpretDrillWellLayered>())
            {
                List<InterpretDrillWellLayered> listData = GetRowsList<InterpretDrillWellLayered>(o => o.JH == wellName);
                colNames.Insert(0, "SD");
                colNames.Insert(1, "DJSD");
                dataset = ExtractToDictionaryList<InterpretDrillWellLayered>(listData, colNames);
                b = true;
            }
            else if (refTable == DBHelp.GetTableName<WellInnerLayer>())
            {
                List<WellInnerLayer> listData = GetRowsList<WellInnerLayer>(o => o.Well == wellName);
                colNames.Insert(0, "top");
                colNames.Insert(1, "bottom");
                dataset = ExtractToDictionaryList<WellInnerLayer>(listData, colNames);
                b = true;
            }
            else if (refTable == DBHelp.GetTableName<WellLithologicalAnalysis>())
            {
                List<WellLithologicalAnalysis> listData = GetRowsList<WellLithologicalAnalysis>(o => o.Well == wellName);
                colNames.Insert(0, "top");
                colNames.Insert(1, "bottom");
                dataset = ExtractToDictionaryList<WellLithologicalAnalysis>(listData, colNames);
                b = true;
            }
            else if (refTable == DBHelp.GetTableName<WellSideWallCoring>())
            {
                List<WellSideWallCoring> listData = GetRowsList<WellSideWallCoring>(o => o.Well == wellName);
                colNames.Insert(0, "top");
                colNames.Insert(1, "bottom");
                dataset = ExtractToDictionaryList<WellSideWallCoring>(listData, colNames);
                b = true;
            }
            else if (refTable == DBHelp.GetTableName<WellCoring>())
            {
                List<WellCoring> listData = GetRowsList<WellCoring>(o => o.Well == wellName);
                colNames.Insert(0, "top");
                colNames.Insert(1, "bottom");
                dataset = ExtractToDictionaryList<WellCoring>(listData, colNames);
                b = true;
            }

            if (dataset == null)
                return b;

            string  jsonStr = "";
            if (dataset.Count == 0)
                return b;


            JObject json = new JObject();
            json["dataType"] = "CommonData";
            JArray jCols = new JArray();
            jCols.Add("top");
            jCols.Add("bottom");
            
            for(int i = 0; i < tdataItems.DataItem.Count; i++)
            {
                jCols.Add(tdataItems.DataItem[i].RefColId);
            }
           
            json["columnName"] = jCols;

            JArray jDatas = new JArray();
            for(int k = 0; k< dataset.Count; k++)
            {
                JArray tdata = new JArray();

                for (int h = 0; h < colNames.Count; h++)
                {
                    if (dataset[k].TryGetValue(colNames[h], out object val))
                    {
                        tdata.Add(val.ToString());
                    }
                    else
                        tdata.Add("");
                }
                jDatas.Add(tdata);
            }

            json["data"] = jDatas;
            jsonStr = JsonConvert.SerializeObject(json);

            b = geoWell.SetWellTrackDataJson(commonDataTrack, jsonStr);

            return b;
        }
    }
}