using ESRI.ArcGIS.Carto;
using ESRI.ArcGIS.DataSourcesGDB;
using ESRI.ArcGIS.Geodatabase;
using ESRI.ArcGIS.Geometry;
using KGIS.Framework.AE;
using KGIS.Framework.AE.ExtensionMethod;
using KGIS.Framework.AE.GPHelper;
using KGIS.Framework.DBOperator;
using KGIS.Framework.Maps;
using KGIS.Framework.Utils;
using KGIS.Framework.Utils.ExtensionMethod;
using KGIS.Framework.Utils.Helper;
using Kingo.PluginServiceInterface;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;

namespace Kingo.Plugin.DataCheck.Helper
{
    public class BGTBTopoCheck_Back : DataCheckRule
    {
        private string _RuleName;
        public override string RuleName { get => _RuleName; set => _RuleName = value; }
        private string _RuleDesc;
        public override string RuleDesc { get => _RuleDesc; set => _RuleDesc = value; }
        public BGTBTopoCheck_Back() : base()
        {
            _RuleName = "基础数据与变更图斑边界套合";
            _RuleDesc = "检查变更图斑数据是否存在重叠、与基础数据边界不套合等问题";
        }
        public override void StartCheck(object pParm)
        {
            IWorkspaceFactory pFtWsFct = null;
            IWorkspaceName workspaceName = null;
            //IFeatureLayer tempLayer = null;
            GPParamClass gPParamClass = new GPParamClass();
            IQueryFilter filter = new QueryFilterClass();
            IFeature f = null;
            try
            {
                base.CheckState = EnumCheckState.检查中;
                IFeatureClass m_Fc = MapsManager.Instance.MapService.GetFeatureClassByName("DLTBBG");
                IFeatureLayer m_JCLayer = MapsManager.Instance.MapService.GetFeatureLayerByLayerName("地类图斑");
                string gdbFolder = Directory.GetCurrentDirectory() + "\\Temp\\BGQDataCheck";
                if (!System.IO.Directory.Exists(gdbFolder))
                {
                    System.IO.Directory.CreateDirectory(gdbFolder);
                }
                try
                {
                    DelectDir(gdbFolder);//能删除就删除 删除报错不处理
                }
                catch { }
                pFtWsFct = new FileGDBWorkspaceFactory();
                string gdbFileName = Guid.NewGuid().ToString() + ".gdb";
                string path = System.IO.Path.Combine(gdbFolder, gdbFileName);
                workspaceName = pFtWsFct.Create(gdbFolder, gdbFileName, null, 0);

                #region 设置基础地类图斑选中
                //gPParamClass.Tolerance = "0.0001";
                //gPParamClass.FirstFeatureLayer = m_JCLayer;
                //gPParamClass.SecondFeatureClass = m_Fc;
                //gPParamClass.IsGetOutPutFeature = true;
                //GeoprocessorHelper.SelectLayerByLocationAnalysis(gPParamClass, "INTERSECT", ref tempLayer);
                #endregion

                //选中的基础地类图斑导出至临时gdb
                //gPParamClass = new GPParamClass();
                //gPParamClass.FirstFeatureLayer = m_JCLayer;
                //gPParamClass.OutFeatureClassPath = path;
                //gPParamClass.IsGetOutPutFeature = true;
                //GeoprocessorHelper.FeatureClassToFeatureClass(gPParamClass, "JC_DLTB", ref tempLayer);

                IFeatureLayer CK_DLTBBGLayer = null;
                gPParamClass.FirstFeatureLayer = new FeatureLayerClass() { FeatureClass = m_Fc };
                gPParamClass.SecondFeatureLayer = m_JCLayer;
                gPParamClass.OutFeatureClassPath = path + "\\" + "CK_DLTBBG2";
                gPParamClass.IsGetOutPutFeature = true;
                GeoprocessorHelper.UnionAnalysis(gPParamClass, ref CK_DLTBBGLayer);

                gPParamClass.FirstFeatureLayer = CK_DLTBBGLayer;
                gPParamClass.OutFeatureClassPath = path + "\\" + "CK_DLTBBG";
                gPParamClass.IsGetOutPutFeature = true;
                GeoprocessorHelper.MultipartToSinglePath(gPParamClass, ref CK_DLTBBGLayer);

                filter.WhereClause = "SHAPE_AREA < 0.1";
                IFeatureCursor cursor = CK_DLTBBGLayer.FeatureClass.Search(filter, true);
                int idxArea = CK_DLTBBGLayer.FeatureClass.FindField("SHAPE_AREA");
                int idxBGOID = CK_DLTBBGLayer.FeatureClass.FindField("FID_DLTBBG");
                int idxJCBSM = CK_DLTBBGLayer.FeatureClass.FindField("BSM_1");
                string m_Msg = "与基础地类图斑数据中标识码为【{0}】的要素边界不套合，形成面积为[{1}]的碎片多边形";
                List<string> sqlList = new List<string>();
                string strErrCode = "2001000399990020";
                sqlList.Add($" delete from DataCheckResults where ErrorCategory='Graphic' and ErrorLayer='BGQDataCheck' and ErrorCode='{strErrCode}' ");
                while ((f = cursor.NextFeature()) != null)
                {
                    double area = f.Value[idxArea].ToDouble();
                    int bgoid = f.Value[idxBGOID].ToInt();
                    string jcBSM = f.Value[idxJCBSM].ToTrim();
                    sqlList.Add($"INSERT INTO DataCheckResults (ErrorLayer,OBJECTID,ErrorType,ErrorCode,ErrorDesc,ErrorArea,Synopsis,ErrorCategory) values ('BGQDataCheck','{bgoid}','{EnumErrorType.错误 }','{strErrCode}','{string.Format(m_Msg, jcBSM, area)}','{f.ShapeCopy.ToJson()}','变更图斑数据存在重叠、与基础数据边界不套合等问题','Graphic')");
                }
                ProjectInfo projectInfo = (MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo);
                string dbPath = System.IO.Path.Combine(projectInfo.ProjDir, "DataCheckrResult.db");
                InsertSQLiteData(dbPath, sqlList);
                base.CheckState = EnumCheckState.检查完成;
                StartLoadData(null);
            }
            catch (Exception ex)
            {
                base.CheckState = EnumCheckState.检查失败;
                LogAPI.Debug(string.Format("{0}", _RuleName));
                LogAPI.Debug(ex);
            }
        }
        private void InsertSQLiteData(string dbPath, List<string> sqlList)
        {
            try
            {
                using (System.Data.SQLite.SQLiteConnection conn = new System.Data.SQLite.SQLiteConnection("Data Source=" + dbPath))
                {
                    conn.Open();
                    using (System.Data.SQLite.SQLiteTransaction pTrans = conn.BeginTransaction())
                    {
                        using (System.Data.SQLite.SQLiteCommand cmd = new System.Data.SQLite.SQLiteCommand(conn))
                        {
                            for (int i = 0; i < sqlList.Count(); i++)
                            {
                                cmd.CommandText = sqlList[i];
                                cmd.ExecuteNonQuery();
                            }
                            pTrans.Commit();
                        }
                    }
                    conn.Close();
                }
            }
            catch (Exception ex)
            {
                LogAPI.Debug("批量插入SQLite数据(地址:" + dbPath + ") 执行失败,异常原因: " + ex.Message + " ; ");
                return;
            }
        }
        public override void StartLoadData(object pParm)
        {
            try
            {
                string dbPath = System.IO.Path.Combine((MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo).ProjDir, "DataCheckrResult.db");
                DataTable dtFJ = SQLiteDBOperate.Instance.ExceDataTable(dbPath, "select * from DataCheckResults WHERE ErrorCode ='2001000399990020' and ErrorLayer='BGQDataCheck' order by ErrorType DESC");
                if (dtFJ == null)
                    return;
                for (int i = 0; i < dtFJ.Rows.Count; i++)
                {
                    int id = dtFJ.Rows[i]["ID"].ToInt();
                    int bgoid = dtFJ.Rows[i]["OBJECTID"].ToInt();
                    string jcError = dtFJ.Rows[i]["ErrorDesc"].ToTrim();
                    string jcErrorType = dtFJ.Rows[i]["ErrorType"].ToTrim();
                    string jcErrorCode = dtFJ.Rows[i]["ErrorCode"].ToTrim();
                    string jcErrorArea = dtFJ.Rows[i]["ErrorArea"].ToTrim();
                    EnumErrorType errType = (EnumErrorType)Enum.Parse(typeof(EnumErrorType), jcErrorType);
                    base.CheckResults.Add(new DataCheckResult()
                    {
                        ID = id,
                        ErrorDesc = jcError,
                        ErrorArea = jcErrorArea,
                        ErrorCode = jcErrorCode,
                        ErrorLayer = "DLTBBG",
                        PrimaryKey = "OBJECTID",
                        PrimaryKeyValue = dtFJ.Rows[i]["OBJECTID"].ToTrim(),
                        ErrorType = errType,
                        Icon = string.Format("pack://siteoforigin:,,,/Images/{0}.{1}", errType.ToString(), "png")
                    });
                }
            }
            catch (Exception ex)
            {
                MessageHelper.ShowError("加载检查结果视图数据失败，请查看日志！");
                LogAPI.Debug(ex.Message);
            }
        }

        public override void StartRepair(object pParm)
        {
            DataTable dtED = null;
            IFeature feature = null;
            try
            {
                string dbPath = System.IO.Path.Combine((MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo).ProjDir, "DataCheckrResult.db");
                dtED = SQLiteDBOperate.Instance.ExceDataTable(dbPath, "select * from DataCheckResults where ErrorCategory='Graphic' and  ErrorCode='2001000399990020' ");
                if (dtED != null && dtED.Rows.Count > 0)
                {
                    IFeatureLayer BGLayer = MapsManager.Instance.MapService.GetFeatureLayerByName("DLTBBG");
                    var i_bg_qsdwdm = BGLayer.FeatureClass.FindField("QSDWDM");
                    var i_bg_zldwdm = BGLayer.FeatureClass.FindField("ZLDWDM");
                    IFeatureLayer JCLayer = MapsManager.Instance.MapService.GetFeatureLayerByLayerName("地类图斑");
                    var i_jc_qsdwdm = JCLayer.FeatureClass.FindField("QSDWDM");
                    var i_jc_zldwdm = JCLayer.FeatureClass.FindField("ZLDWDM");
                    var bg_qsdwdm = string.Empty;
                    var bg_zldwdm = string.Empty;
                    var jc_qsdwdm = string.Empty;
                    var jc_zldwdm = string.Empty;
                    foreach (DataRow row in dtED.Rows)
                    {
                        string objid = row["OBJECTID"].ToString();
                        string id = row["ID"].ToString();
                        string _geometry = row["ErrorArea"].ToString().ToTrim();
                        IGeometry geometry = _geometry.ToGeometry();
                        if (geometry == null || geometry.IsEmpty) continue;
                        if (objid == "-1")
                        {
                            List<IFeature> bglist = FeatureAPI.Identify(geometry, BGLayer);
                            foreach (IFeature f in bglist)
                            {
                                #region 权属坐落相同的合并
                                List<IFeature> jc = FeatureAPI.Identify2(geometry, JCLayer);
                                if (jc.Count == 0) continue;
                                jc_qsdwdm = jc[0].Value[i_jc_qsdwdm].ToTrim();
                                jc_zldwdm = jc[0].Value[i_jc_zldwdm].ToTrim();
                                bg_qsdwdm = f.Value[i_bg_qsdwdm].ToTrim();
                                bg_zldwdm = f.Value[i_bg_zldwdm].ToTrim();
                                if (bg_qsdwdm == jc_qsdwdm && bg_zldwdm == jc_zldwdm)
                                {
                                    List<IGeometry> pGeometry = new List<IGeometry>() { geometry, f.Shape };
                                    f.Shape = FeatureAPI.MergeGeometry(pGeometry);
                                    f.Store();
                                    break;
                                }
                                #endregion
                            }
                        }
                        else
                        {
                            #region 擦除
                            try
                            {

                                feature = BGLayer.FeatureClass.GetFeature(objid.ToInt());
                            }
                            catch (Exception ex)
                            {
                                LogAPI.Debug($"图斑修复异常：{ex.Message}");
                                continue;
                            }
                            feature.Shape = FeatureAPI.Difference(feature.Shape, geometry);
                            feature.Store();
                            #endregion
                        }
                        SQLiteDBOperate.Instance.ExecuteNonQuery(dbPath, $" delete from DataCheckResults where ErrorCode='2001000399990020' and ID ={id} ", null);
                    }
                }
            }
            catch (Exception ex)
            {
                LogAPI.Debug(ex.Message);
            }
            StartLoadData(null);

            #region 200200-200100图形修复
            //string dbPath = System.IO.Path.Combine((MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo).ProjDir, "DataCheckrResult.db");
            //DataTable dtED = SQLiteDBOperate.Instance.ExceDataTable(dbPath, "select * from DataCheckResults where ErrorCode='200200' or ErrorCode='200100'");//失效数据集合  
            //if (dtED == null && dtED.Rows.Count == 0) return;
            //IFeatureLayer fix_BGLayer = MapsManager.Instance.MapService.GetFeatureLayerByName("DLTBBG");
            //foreach (DataRow dr_Err in dtED.Rows)
            //{
            //    if (!string.IsNullOrEmpty(dr_Err["ErrorArea"].ToTrim()))
            //    {
            //        IGeometry geo = dr_Err["ErrorArea"].ToTrim().ToGeometry();
            //        if (geo != null && !geo.IsEmpty)
            //        {
            //            List<IFeature> bgFeatures = FeatureAPI.Identify(geo, fix_BGLayer);
            //            //单个图形需要合并/擦除的情况
            //            if (bgFeatures.Count == 1)//当前图斑
            //            {
            //                if (FeatureAPI.IsAdjacent(bgFeatures[0].ShapeCopy, geo) && !FeatureAPI.IsContains(bgFeatures[0].ShapeCopy, geo))
            //                {
            //                    IGeometry geometrys = FeatureAPI.Union(bgFeatures[0].Shape, geo);//合并
            //                    bgFeatures[0].Shape = geometrys;
            //                    bgFeatures[0].Store();
            //                    Marshal.ReleaseComObject(geometrys);
            //                    SQLiteDBOperate.Instance.ExecuteNonQuery(dbPath, string.Format("delete from DataCheckResults WHERE ID = '{0}'", dr_Err["ID"].ToTrim()), null);
            //                }
            //                else if (FeatureAPI.IsContains(bgFeatures[0].ShapeCopy, geo) || dr_Err["PrimaryKeyValue"].ToString() == bgFeatures[0].OID.ToString())//包含情况
            //                {
            //                    IGeometry diffGeo = FeatureAPI.Difference(bgFeatures[0].ShapeCopy, geo);//擦除
            //                    if (diffGeo.IsEmpty) continue;//非-1 OID 边界外
            //                    bgFeatures[0].Shape = diffGeo;
            //                    bgFeatures[0].Store();
            //                    Marshal.ReleaseComObject(diffGeo);
            //                    SQLiteDBOperate.Instance.ExecuteNonQuery(dbPath, string.Format("delete from DataCheckResults WHERE ID = '{0}'", dr_Err["ID"].ToTrim()), null);
            //                }
            //            }
            //        }
            //    }
            //}
            #endregion
        }

        public override void StartSingleRepair(object pParm)
        {

        }
        private void DelectDir(string srcPath)
        {
            try
            {
                DirectoryInfo dir = new DirectoryInfo(srcPath);
                FileSystemInfo[] fileinfo = dir.GetFileSystemInfos();  //返回目录中所有文件和子目录
                foreach (FileSystemInfo i in fileinfo)
                {
                    if (i is DirectoryInfo)            //判断是否文件夹
                    {
                        DirectoryInfo subdir = new DirectoryInfo(i.FullName);
                        subdir.Delete(true);          //删除子目录和文件
                    }
                    else
                    {
                        File.Delete(i.FullName);      //删除指定文件
                    }
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        public override void StartCheckForThread(object pParam)
        {

        }
    }
}