using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using OliviaAddInPro.Model;
using ArcGIS.Core.Data;
using ArcGIS.Core.Geometry;
using OliviaAddInPro.Helper;
using ArcGIS.Core.Internal.Data;
using ArcGIS.Desktop.Framework.Threading.Tasks;
using System.Windows;
using System.IO;

namespace OliviaAddInPro.Services
{
        public enum ModosEjec
        {
            Sectoriza,
            Planifica,
            SoloPlanifica

    }
    //Clase que realiza las funciones de la ejecución
    public class EjecServ
    {
        //Cadenas de nombres internos para la exportación/importación de los archivos
        public string PREF_NAME_EXPORT = "data_";
        public string EXT_SHP = ".shp";
        public string PREF_NAME_EXPORT_NW = "nw_";
        public string NAME_CSV = "_L";
        public string EXT_CSV = ".csv";
        public string NAME_RUTA2 = "_R2";
        public string NAME_RUTA2_OUT = "_Viajes";
        public string NAME_AUX = "_aux";
        public string NAME_SECT = "_Sector";
        public string NAME_CONTROL_OUT = "_Control";
        public string NAME_CONTROL = "_C";
        public string NAME_RUTA_OUT = "_Ruta";
        public string NAME_RUTA = "_R";
        public string NAME_RUTA_AUX = "_Raux";
        public string NAME_INSTAL = "_I";
        public string NAME_INSTAL_OUT = "_Instalacion";

        public string ErrStr = "";
        SpatialQueryFilter filtroEspacial = null;
        SpatialReference spatRef = null;
        SpatialReference spatRefData = null;

        public TratamientoComun com;
        /**
         * Acciones para comenzar ejecución
         * Modo 0, sectorizar
         * Modo 1, planificar
         */
        public bool ExportaEjec(ModosEjec modo, out string ErrStr)
        {
            
            ErrStr = string.Empty;
            OliviaGlob.Paths.PathData = string.Empty;
            OliviaGlob.Paths.PathNW = string.Empty;
            if (com.ProgrSrc._ProgrSrc.Getcancelled())
            {
                ErrStr = Resource1.String_cancel_progreso;
                return false;
            }
            try
            {              
                com.ProgrSrc.Init("Exportando datos");
                //Comprueba que tiene las columnas necesarias para planificar
                if ((modo == ModosEjec.Planifica) && !CompruebaPlanif())
                {
                    ErrStr = "En la capa de ámbitos seleccionada no se encuentran columnas de SECTOR y/o SECUENCIA, necesarias para planificar";
                    return false;
                }
                if (com.ProgrSrc._ProgrSrc.Getcancelled())
                {
                    ErrStr = Resource1.String_cancel_progreso;
                    return false;
                }

                //////////////////////////////////////////////
                ///Se guarda el nombre de los campos originales
                ///
                com.GuardaCamposOrig(com.CapaElems);

                //Cuenta las filas que cumplen la consulta
                var nelems = HelperGdb.GetNumElemsSync(com.CapaElems, com.ConsultaAmbs);
                if (nelems <= 0)
                {
                    ErrStr = "No existen ámbitos que cumplan las condiciones introducidas para la exportación " + com.ConsultaAmbs;
                    return false;
                }
                if (com.ProgrSrc._ProgrSrc.Getcancelled())
                {
                    ErrStr = Resource1.String_cancel_progreso;
                    return false;
                }
                com.ProgrSrc.IncMessage(0, "Exportando geometria");

                //////////////////////////////////////////////////////////////
                Coordinate2D[] coords = { com.CoordsInstal, com.CoordsPlanta };
                //Reproyecta las geometrías si es necesario
                SpatialReference spatref = HelperGdb.GetSpatRefSync(com.CapaElems);
                if (spatref != null)
                {
                    if (com.GeomNiv != null)
                        com.GeomNiv = HelperGdb.ReproyectaGeom(com.GeomNiv, spatref);
                    if (com.GeomZon != null)
                        com.GeomZon = HelperGdb.ReproyectaGeom(com.GeomZon, spatref);
                    if (com.GeomRestr != null)
                        com.GeomRestr = HelperGdb.ReproyectaGeom(com.GeomRestr, spatref);
                    //ahora las coordenadas
                    for (int i = 0; i < coords.Length; i++)
                    {
                        if (com.ProgrSrc._ProgrSrc.Getcancelled())
                        {
                            ErrStr = Resource1.String_cancel_progreso;
                            return false;
                        }
                        if (!coords[i].IsEmpty && (coords[i].X != 0))
                        {

                            MapPoint mp = MapPointBuilderEx.CreateMapPoint(coords[i].X, coords[i].Y, spatref);
                            coords[i].X = mp.X;
                            coords[i].Y = mp.Y;
                        }
                    }                    
                }
                //////////////////////////////////////////////////////////////
                //Obtiene la geometría que envuelve a los ámbitos
                Geometry geom_export = null;
                geom_export = GetGeomAmbitsExport();
                if (geom_export == null || geom_export.IsEmpty)
                {
                    ErrStr = "No se ha podido generar geometría de los ámbitos" + com.ConsultaAmbs + ErrStr;
                    return false;
                }
                if (com.ProgrSrc._ProgrSrc.Getcancelled())
                {
                    ErrStr = Resource1.String_cancel_progreso;
                    return false;
                }
                //mira spatialreference de los datos de entrada
                spatRefData = geom_export.SpatialReference;                

                //crea el filtro de exportación 
                filtroEspacial = HelperGdb.CreateFiler(com.ConsultaAmbs, geom_export);
                if (filtroEspacial == null)
                {
                    ErrStr = "Error al crear el filtro de exportacion de los ámbitos";
                    return false;
                }
                if (com.ProgrSrc._ProgrSrc.Getcancelled())
                {
                    ErrStr = Resource1.String_cancel_progreso;
                    return false;
                }
                //Termina de preparar nombre
                //Prepara nombre
                string fechaHora = string.Empty;
                //se consigue el tiempo en este instante para añadirlo a los nombres de los archivos de salida (shapefiles)
                fechaHora = DateTime.Now.ToString("yyyyMMdd_Hmmss");
                //Pone nombre al shape en función de los ámbitos, el tratamiento, y los polígonos + timestamp
                com.NombreShpExport = PREF_NAME_EXPORT + com.NombreShpExp_PrefTto + "_" + fechaHora + EXT_SHP;

                com.ProgrSrc.IncMessage(10, "Exportando ámbitos de trabajo");//10%
                
                //Guarda el nombre
                OliviaGlob.Paths.PathData = OliviaGlob.Paths.DirData + com.NombreShpExport;
                //exporta los datos de entrada
                if (!HelperGdb.ExportShp2(com.CapaElems, filtroEspacial, com.NombreShpExport, OliviaGlob.Paths.DirData, com.ProgrSrc._ProgrSrc, null, 50))
                {
                    ErrStr = "Error al exportar los ámbitos: " + HelperGdb.OutStr;
                    return false;
                }
                
                if (com.ProgrSrc._ProgrSrc.Getcancelled())
                {
                    ErrStr = Resource1.String_cancel_progreso;
                    return false;
                }

                /////////////////////////////////////////////////////////////////////
                ///Comprueba si está la columna de ObjectId y si no, la crea
                if(!ComprCreaColOid(OliviaGlob.Paths.PathData, com.CapaElems, filtroEspacial))
                {
                    ErrStr = "Error al exportar columna " + ComunDef.CamposCom.camp_oid;
                    return false;
                }

                ///////////////////////////////////////////////////////////////////////
                //ahora si está en modo planificación, ya ha hecho una ejec antes y la capa no tiene esa columna pero la tiene guardada de la ejec anterior, exporta la sectorización
                if (modo==ModosEjec.Planifica && !string.IsNullOrEmpty(com.CapaPlanif) && OliviaGlob.IsConfig2())
                {
                    string capa_principal = System.IO.Path.GetFileNameWithoutExtension(OliviaGlob.Paths.PathData);
                    HelperGdb.CloseLayer(capa_principal);
                    if (!ActualizaSecto(OliviaGlob.Paths.PathData, com.CapaPlanif))
                    {
                        ErrStr = "Error al exportar campos de SECTOR y/o SECUENCIA de la capa " + com.CapaPlanif;
                        return false;
                    }
                }
                if (com.ProgrSrc._ProgrSrc.Getcancelled())
                {
                    ErrStr = Resource1.String_cancel_progreso;
                    return false;
                }
                ///////////////////////////////////////////////////////////////////////
                ///
                com.ProgrSrc.IncMessage(40, "Preparando exportación de red navegable");//50%

                //hace intersecciones espaciales en caso de ámbitos lineales para quitar los que tienen más parte fuera de la zona que dentro
                //REVISAR
                /*if (((com.GeomNiv != null) || (com.GeomZon != null)) &&
                    (OliviaGlob.IsReco() || (OliviaGlob.IsLimp() && (com.TipoTto < (int)LimpiezaDef.TiposTto.TtoPapeVaci))))
                {
                    if (!HelperGdb.RemoveRowsGeom(OliviaGlob.Paths.PathData, geom_export, 0.4))
                    {
                        ErrStr = "Error al quitar los ámbitos que sobresalen: " + HelperGdb.OutStr;
                        return false;
                    }
                }*/

                ///////////////////////////////////////////////////////////////////////////            
                //comprueba, si hay restricciones de circulación y hay instalación, que la instalación no está en ellas            
                if (!com.CoordsInstal.IsEmpty && (com.CoordsInstal.X != 0) && (com.GeomRestr != null))
                {
                    Respuesta<bool> resp = HelperGdb.IsPtoInGeom(com.CoordsInstal, com.GeomRestr);
                    if (!resp.Value && resp.HasError)
                    {
                        ErrStr = "Error al comprobar si la instalación está contenida en el polígono de restricciones: " + resp.Error.ElementAt(0);
                        return false;
                    }
                    else if (resp.Value) //sí está contenido en las restricciones
                    {
                        ErrStr = "Error, la instalación está en la zona restringida a la circulación ";
                        return false;
                    }

                }
                if (com.ProgrSrc._ProgrSrc.Getcancelled())
                {
                    ErrStr = Resource1.String_cancel_progreso;
                    return false;
                }
                ///////////////////////////////////////////////////////////////////////////     
                //exporta la red navegable (buffer, le quita las restr...)
                //se obtiene la geometría a intersecar con la red, que será la que contiene
                //a todos los ámbitos y la instalación, ampliada un buffer, mayor si hay
                //restricciones de circulación
                geom_export = HelperGdb.BufferGeom(geom_export, com.BuffExport).Value;
                if (geom_export == null)
                {
                    ErrStr = "Error al añadir buffer a la geometría";
                    return false;
                }                
                //////////////////////////////////////////////////////////////
                //comprueba si la geometría de exportación contiene a la instalación y a la planta de descarga                
                for (int i = 0; i < coords.Length; i++)
                {
                    if (com.ProgrSrc._ProgrSrc.Getcancelled())
                    {
                        ErrStr = Resource1.String_cancel_progreso;
                        return false;
                    }
                    if (!coords[i].IsEmpty && (coords[i].X != 0))
                    {
                        Respuesta<bool> resp = HelperGdb.IsPtoInGeom(coords[i], geom_export);
                        if (!resp.Value) //si no lo contiene
                        {
                            //ha ido mal
                            if (resp.HasError)
                            {
                                ErrStr = "Error al comprobar si la instalación está contenida en el polígono de exportación: " + resp.Error.ElementAt(0);
                                return false;
                            }
                            else
                            {
                                //amplía la geom
                                Respuesta<ArcGIS.Core.Geometry.Geometry> respGeom = HelperGdb.AddPtoInGeom(coords[i], geom_export, com.BuffExport);
                                if (respGeom.Value == null)
                                {
                                    //ha ido mal
                                    if (resp.HasError)
                                        ErrStr = resp.Error.ElementAt(0);
                                    else
                                        ErrStr = "Error al incluir punto de instalación en polígono de exportación.";
                                    return false;
                                }                                
                                //actualiza la geometría
                                geom_export = respGeom.Value;
                            }
                        }
                    }
                }
                //quita las restricciones de circ
                if (com.GeomRestr != null)
                {
                    geom_export = HelperGdb.QuitaGeom(geom_export, com.GeomRestr);
                    if (geom_export == null)
                    {
                        ErrStr = "Error al intersecar con las restricciones.";
                        return false;
                    }
                }
                if (com.ProgrSrc._ProgrSrc.Getcancelled())
                {
                    ErrStr = Resource1.String_cancel_progreso;
                    return false;
                }

                //mira spatialreference del nw
                /*FeatureClass fc = HelperGdb.GetFtClass(OliviaGlob.Paths.PathGdbNw);                
                if (fc != null)
                {
                    spatRef = fc.GetDefinition().GetSpatialReference();
                    //AQUÍ COMPARAR SI ES IGUAL QUE SPATREFDEF Y SI NO, REPROYECTAR
                    if (spatRef.Wkid != spatRefData.Wkid)
                    {
                        var sp_ref = SpatialReferenceBuilder.CreateSpatialReference(102629); // NAD83 SP AL E FIPS 0101 Feet

                        var envi = Geoprocessing.MakeEnvironmentArray(outputCoordinateSystem: sp_ref);
                        //https://pro.arcgis.com/es/pro-app/2.8/tool-reference/environment-settings/output-coordinate-system.htm
                        //ProjectionTransformation transf_forTarget = ProjectionTransformation.Create(spatRef, spatRefData);

                        //geom_export=GeometryEngine.Instance.ProjectEx(geom_export, transf_forTarget);
                        //transf_forTarget.Transformation
                        /*
                         * FALTA HACER
                         * /
                    }
                }*/
                //////////////////////////////////////
                //guarda la mima de la geometría de la red navegable a exportar
                com.MimaNw = geom_export.Extent;
                //////////////////////////////////////
                ///
                //Hace el filtro con la geometría final
                filtroEspacial = HelperGdb.CreateFiler(String.Empty, geom_export);
                if (filtroEspacial == null)
                {
                    ErrStr = "Error al crear el filtro de exportacion de la red navegable";
                    return false;

                }
                if (com.ProgrSrc._ProgrSrc.Getcancelled())
                {
                    ErrStr = Resource1.String_cancel_progreso;
                    return false;
                }
                com.ProgrSrc.IncMessage(10, "Exportando red navegable");//60%

                //Prepara nombre de exportación
                com.NombreShpExportNw = PREF_NAME_EXPORT_NW + fechaHora + EXT_SHP;
                //guarda los nombres del shape
                OliviaGlob.Paths.PathNW = OliviaGlob.Paths.DirData + com.NombreShpExportNw;
                //exporta los datos de entrada
                if (!HelperGdb.ExportShp2(OliviaGlob.Paths.PathGdbNw, filtroEspacial, com.NombreShpExportNw, OliviaGlob.Paths.DirData, com.ProgrSrc._ProgrSrc, spatRefData,100))
                {
                    ErrStr = "Error al exportar la red navegable: " + HelperGdb.OutStr;
                    return false;
                }                                
                if (com.ProgrSrc._ProgrSrc.Getcancelled())
                {
                    ErrStr = Resource1.String_cancel_progreso;
                    return false;
                }
                //prepara campos estandar
                if(!EstandarizaCamposNW(OliviaGlob.Paths.DirData+com.NombreShpExportNw))
                {
                    ErrStr = "Error al estandarizar campos red navegable: " + HelperGdb.OutStr;
                    return false;
                }
                com.ProgrSrc.IncMessage(40, "Finalizada Exportación. Conectando con Olivia Tasks.");//100%
            }
            catch (Exception ex)
            {
                ErrStr = "Errores al exportar para comenzar la ejecución: " + ex.Message;
                return false;
            }
            return true;
        }
        bool EstandarizaCamposNW(string pathNW)
        {
            HelperGdb.FieldToAdd[] fields = new HelperGdb.FieldToAdd[6];
            //campo SECTOR
            int i = 0;
            fields[i].Name = ComunDef.CamposNW.cons_kph;
            fields[i].Alias = ComunDef.CamposNW.cons_kph;
            fields[i].Tipo = "FLOAT";
            fields[i].Length = 0;

            i++;
            
            fields[i].Name = ComunDef.CamposNW.cons_fow;
            fields[i].Alias = ComunDef.CamposNW.cons_fow;
            fields[i].Tipo = "LONG";
            fields[i].Length = 0;
            i++;
            fields[i].Name = ComunDef.CamposNW.cons_onewFT;
            fields[i].Alias = ComunDef.CamposNW.cons_onewFT;
            fields[i].Tipo = "LONG";
            fields[i].Length = 0;

            i++;
            fields[i].Name = ComunDef.CamposNW.cons_onewTF;
            fields[i].Alias = ComunDef.CamposNW.cons_onewTF;
            fields[i].Tipo = "LONG";
            fields[i].Length = 0;

            i++;
            fields[i].Name = ComunDef.CamposNW.cons_evit;
            fields[i].Alias = ComunDef.CamposNW.cons_evit;
            fields[i].Tipo = "LONG";
            fields[i].Length = 0;
            i++;
           
            fields[i].Name = ComunDef.CamposNW.cons_name;
            fields[i].Alias = ComunDef.CamposNW.cons_name;
            fields[i].Tipo = "TEXT";
            fields[i].Length = 128;

           

            if (!HelperGdb.AddFieldsSync(pathNW, fields))
                return false;
            if (!HelperGdb.CalculateFieldsSync(pathNW, ComunDef.CamposNW.cons_kph, ComunDef.CamposNW.config.campo_velocidad))
                return false;
            
            if (!HelperGdb.CalculateFieldsSync(pathNW, ComunDef.CamposNW.cons_name, ComunDef.CamposNW.config.campo_nombre))
                return false;
            if (!HelperGdb.CalculateFieldsSync(pathNW, ComunDef.CamposNW.cons_fow, ComunDef.CamposNW.config.campo_peatonal))
                return false;
            if (!HelperGdb.CalculateFieldsSync(pathNW, ComunDef.CamposNW.cons_onewTF, ComunDef.CamposNW.config.campo_sentidoTf))
                return false;
            if (!HelperGdb.CalculateFieldsSync(pathNW, ComunDef.CamposNW.cons_onewFT, ComunDef.CamposNW.config.campo_sentidoFT))
                return false;
            if (!HelperGdb.CalculateFieldsSync(pathNW, ComunDef.CamposNW.cons_evit, "0"))
                return false;
            return true;
        }
        /**
         * Actualiza la capa dada añadiendo una columna de sector y una de secuencia
         */
         public bool ActualizaSecto(string path_shp, string path_secto)
        {
            //Añade al shp exportado la columna de sector y secuencia
            HelperGdb.FieldToAdd[] fields = new HelperGdb.FieldToAdd[2];
            //campo SECTOR
            fields[0].Name = ComunDef.CamposCom.consulta_sector;            
            fields[0].Alias = ComunDef.CamposCom.consulta_sector;
            fields[0].Tipo = "LONG";
            fields[0].Length = 0;
            //campo SECUENCIA
            fields[1].Name = ComunDef.CamposCom.consulta_secuen;
            fields[1].Alias = ComunDef.CamposCom.consulta_secuen;
            fields[1].Tipo = "LONG";
            fields[1].Length = 0;

            if (!HelperGdb.AddFieldsSync(path_shp, fields))
                return false;
            //vuelve a cerrar la capa
            string capa_principal = System.IO.Path.GetFileNameWithoutExtension(path_shp);
            HelperGdb.CloseLayer(capa_principal);
            /////////////////////////////////////////////////////       
                        
            //ahora rellena las columnas
            using (FeatureClass fc_secto = HelperGdb.GetFtClassSync(path_secto))
            {
                using (FeatureClass fc_shp = HelperGdb.GetFtClassSync(path_shp))
                {
                    if (fc_secto == null || fc_shp == null)
                        return false;

                    try
                    {
                        using (RowCursor rc_shp = fc_shp.Search())
                        {
                            using (RowCursor rc_secto = fc_secto.Search())
                            {
                                if (rc_shp == null || rc_secto == null)
                                    return false;

                                var modifyOp = new ArcGIS.Desktop.Editing.EditOperation();
                                modifyOp.Name = "Actualiza SECTOR y SECUENCIA";
                                bool ex = false;
                                //modifyOp.Callback((context) =>
                                //{
                                    while (rc_shp.MoveNext() && rc_secto.MoveNext())
                                    {
                                        using (Row rowsecto = rc_secto.Current)
                                        {
                                            using (Row rowshp = rc_shp.Current)
                                            {
                                                //context.Invalidate(rowshp);
                                                // modify and execute
                                                modifyOp.Modify(rowshp, ComunDef.CamposCom.consulta_sector, rowsecto[ComunDef.CamposCom.consulta_sector]);
                                                modifyOp.Modify(rowshp, ComunDef.CamposCom.consulta_secuen, rowsecto[ComunDef.CamposCom.consulta_secuen]);
                                                rowshp.Store();
                                                //context.Invalidate(rowshp);
                                            }
                                        }
                                    }
                                //}, fc_shp);
                                ex = modifyOp.Execute();
                                ArcGIS.Desktop.Core.Project.Current.SaveEditsAsync();
                                if (ex && modifyOp.IsDone)
                                    return true;
                                else
                                    return false;
                            }
                        }
                    }
                    catch
                    {
                        return false;
                    }

                }
            }
                    
                
                /*
                var modifyOp = new ArcGIS.Desktop.Editing.EditOperation();
                modifyOp.Name = "Actualiza SECTOR y SECUENCIA";
                bool ex=false;
                modifyOp.Callback((context) =>
                { 
                using (RowCursor rc_shp = fc_shp.Search())
                {
                    using (RowCursor rc_secto = fc_secto.Search())
                    {

                        if (rc_shp != null && rc_secto != null)
                        {
                            while (rc_shp.MoveNext() && rc_secto.MoveNext())
                            {
                                using (Row rowsecto = rc_secto.Current)
                                {
                                    using (Row rowshp = rc_shp.Current)
                                    {
                                        context.Invalidate(rowshp);
                                        // modify and execute
                                        modifyOp.Modify(rowshp, LimpiezaDef.Campos.consulta_sector, rowsecto[LimpiezaDef.Campos.consulta_sector]);
                                        modifyOp.Modify(rowshp, LimpiezaDef.Campos.consulta_secuen, rowsecto[LimpiezaDef.Campos.consulta_secuen]);
                                        rowshp.Store();
                                        context.Invalidate(rowshp);
                                     }
                                }
                            }
                            bien = true;
                            rc_secto.Dispose();
                            rc_shp.Dispose();                          
                        }
                    }
                }
                }, fc_shp);
                ex = modifyOp.Execute();
                if (bien && ex && modifyOp.IsDone)
                    return true;
                else
                    return false;
            }
            catch
            {

            }
            finally
            {
                fc_secto.Dispose();
                fc_shp.Dispose();
                HelperGdb.Free(fc_secto);
                HelperGdb.Free(fc_shp);

            }
            return false;*/
        }

        /**
         * Comrpueba si existe la columna de oid y si no, la crea y la rellena
         */
        public bool ComprCreaColOid(string pathCapa, string pathCapaOrig, SpatialQueryFilter filter)
        {
            //comprueba si está el campo
            bool compCamp = HelperGdb.CheckField(pathCapa, ComunDef.CamposCom.camp_oid);
            ErrStr = HelperGdb.OutStr;
            if (compCamp)
                return true; //tiene el campo

            //no lo tiene, lo crea
            //Añade al shp exportado la columna de sector y secuencia
            HelperGdb.FieldToAdd[] fields = new HelperGdb.FieldToAdd[1];
            //campo
            fields[0].Name = ComunDef.CamposCom.camp_oid;
            fields[0].Alias = ComunDef.CamposCom.camp_oid;
            fields[0].Tipo = "LONG";
            fields[0].Length = 0;            

            if (!HelperGdb.AddFieldsSync(pathCapa, fields))
                return false;
            //vuelve a cerrar la capa
            string capa_principal = System.IO.Path.GetFileNameWithoutExtension(pathCapa);
            HelperGdb.CloseLayer(capa_principal);

            /////////////////////////////////////////////////////  
            //Coge los ids de la capa de la que ha exportado
            using (FeatureClass fc_orig = HelperGdb.GetFtClassSync(pathCapaOrig))
            {
                if (fc_orig == null)
                    return false;
                List<long> ids = new List<long>();
                //Añade a la lista los ids que cumplen el filtro espacial
                try
                {
                    ids = fc_orig.Select(filter, SelectionType.ObjectID, SelectionOption.Normal).GetObjectIDs().ToList();
                }
                catch
                {
                    ids = new List<long>();
                }
                //Comprueba que hay tantos ids como elementos en el shp
                using (FeatureClass fc_shp = HelperGdb.GetFtClassSync(pathCapa))
                {
                    if (fc_shp == null)
                        return false;
                    long nelem_shp = HelperGdb.GetNumElemsSync(fc_shp);
                    if (nelem_shp != ids.Count)
                        return false;

                    /////////////////////////////////////////////////////
                    //ahora rellena las columnas            
                    try
                    {
                        using (RowCursor rc_shp = fc_shp.Search())
                        {
                            if (rc_shp == null)
                                return false;

                            var modifyOp = new ArcGIS.Desktop.Editing.EditOperation();
                            modifyOp.Name = "Actualiza OID";
                            bool ex = false;
                            //modifyOp.Callback((context) =>
                            //{
                            int i = 0;
                            while (rc_shp.MoveNext() && i < ids.Count)
                            {
                                using (Row rowshp = rc_shp.Current)
                                {
                                    //context.Invalidate(rowshp);
                                    // modify and execute
                                    modifyOp.Modify(rowshp, ComunDef.CamposCom.camp_oid, ids[i++]);
                                    rowshp.Store();
                                    //context.Invalidate(rowshp);
                                }
                            }
                            //}, fc_shp);
                            ex = modifyOp.Execute();
                            ArcGIS.Desktop.Core.Project.Current.SaveEditsAsync();
                            if (ex && modifyOp.IsDone)
                                return true;
                            else
                                return false;
                        }
                    }
                    catch
                    {
                        return false;
                    }
                    return true;
                }
            }
        }

        /**
            * Prepara la geometría para exportar los ámbitos
            */
        public Geometry GetGeomAmbitsExport()
        {
            Geometry geomAux = null;
            Geometry geomAmbits = null;

            ErrStr = string.Empty;
            FeatureClass fc = HelperGdb.GetFtClassSync(com.CapaElems);            
            if (fc == null)
            {
                ErrStr = "No se ha podido abrir la clase " + com.CapaElems;
                return null;
            }           

            //Hace la intersección de zonas y niveles
            geomAux = null;
            if (com.GeomNiv != null || com.GeomZon != null)
            {
                geomAux = HelperGdb.IntersectGeom(com.GeomNiv, com.GeomZon);
                if (geomAux == null)
                {
                    ErrStr = "Error al intersecar zonas y/o niveles.";
                    HelperGdb.Free(fc);
                    return null;
                }
                if (geomAux.IsEmpty)
                {
                    ErrStr = "No existen ámbitos en la intersección entre zonas y/o niveles.";
                    HelperGdb.Free(fc);
                    return null;
                }
            }
            //comprueba que, en el caso de ejes de vía, hayan metido polígono de exportación
            if ((geomAux == null) && (com.CapaElems == OliviaGlob.Paths.PathGdbNw))
            {
                ErrStr = "Al emplear ejes de calle como ámbitos es necesario indicar polígono de exportación";
                HelperGdb.Free(fc);
                return null;
            }

            //prepara el filtro con consulta y espacial
            SpatialQueryFilter filtro = HelperGdb.CreateFiler(com.ConsultaAmbs, geomAux);                        
            //if (geomAux == null)
            {
                //Ahora hace la geometría de los ámbitos que cumplen la consulta
                geomAmbits = HelperGdb.GetGeomUnique(fc, filtro);
                if (geomAmbits == null || geomAmbits.IsEmpty)
                {
                    ErrStr = "No se ha podido generar geometría de los ámbitos" + com.ConsultaAmbs + HelperGdb.OutStr;
                    HelperGdb.Free(fc);
                    return null;
                }
                if (geomAux == null)
                    geomAux = geomAmbits;
                else
                {
                    geomAux = HelperGdb.IntersectGeom(geomAux, geomAmbits);
                    //geomAux = GeometryEngine.Instance.ConvexHull(geomAux);
                }
            }
            //le quita las restricciones
            if (com.GeomRestr != null)
            {
                geomAux = HelperGdb.QuitaGeom(geomAux, com.GeomRestr);
                if (geomAux == null)
                {
                    ErrStr = "Error al intersecar con las restricciones.";
                    HelperGdb.Free(fc);
                    return null;
                }
            }
            HelperGdb.Free(fc);
            return geomAux;
        }

        /**
         * Devuelve el string a concatenar en el nombre del path dependiendo de los polígonos seleccionados (zonas, turnos... etc)
         */
        public string DameStrPoligs()
        {
            string str = "";

            if (com.TextGeomNiv != "" && com.GeomNiv != null)
                str += "_N" + com.TextGeomNiv;
            if (com.TextGeomZon != "" && com.GeomZon != null)
                str += "_Z" + com.TextGeomZon;
            if (com.TextGeomRestr != "" && com.GeomRestr != null)
                str += "_R" + com.TextGeomRestr;

            return str;
        }                

        public bool ComprCamposPlanif(string pathCapa)
        {
            int NCAMPS = 2;
            string[] camps;
            camps = new string[NCAMPS];
            camps[0] = ComunDef.CamposCom.consulta_sector;
            camps[1] = ComunDef.CamposCom.consulta_secuen;
            return HelperGdb.CheckFiledsSync(pathCapa, camps) == 0;
        }

        /**
         * Comprueba lo necesario para ver si hay campos para la planificación
         */
        public bool CompruebaPlanif()
        {
            //si ha importado seguro que las tiene
            if (OliviaGlob.IsConfig2() && !string.IsNullOrEmpty(com.CapaPlanif))
                return true;

            //comprueba capa
            if (ComprCamposPlanif(com.CapaElems))
            {
                com.CapaPlanif = string.Empty;//reinicia para que coja la secto de la capa original
                return true;
            }        

            return false;
        }

        /**
         * Realiza las funciones de importación de la sectorización
         */
        public Respuesta<string> ImportSecto(string GdbFileName, string FtClssName)
        {
            com.ProgrSrc.IncMessage(10,"Importando capas");
            var res = Import(GdbFileName, 0, FtClssName);
            if (res.HasError || string.IsNullOrEmpty(res.Value))
            {
                return res;
            }
            //////////////////////////////////////////////////
            com.ProgrSrc.IncMessage(50, "Pintando capas con valores únicos");
            //abre las capas, pintando los sectores
            bool mal = false;
            string path_import = res.Value;
            //abre con valor único
            string path_lyr = path_import;
            var resb = HelperGdb.OpenLayerUniqueValue(path_lyr, ComunDef.CamposCom.consulta_sector);
            if (!resb.Value)
            {
                res.Error.Add("Error al abrir capa "+ path_lyr + " con Valor único. " + resb.Error.FirstOrDefault());
                res.Value = string.Empty;
                mal = true;
            }
            if(!mal)
                res.Value = path_import;
            return res;
        }
        /**
         * Realiza las funciones de importación de la planificación
         */
        public Respuesta<string> ImportPlanif(string GdbFileName, string FtClssName)
        {
            com.ProgrSrc.IncMessage(10, "Importando capas");
            var res = Import(GdbFileName, 1, FtClssName);
            if (res.HasError || string.IsNullOrEmpty(res.Value))
            {
                res.Value = string.Empty;
                return res;
            }
            //////////////////////////////////////////////////
            com.ProgrSrc.IncMessage(30, "Pintando capas con valores únicos");
            //abre las capas, pintando los sectores
            string path_import = res.Value;            
            int NOPEN = 6;
            int nopen_ = 4;
            string[] path_lyr_arr = new string[NOPEN];
            //se añade la capa de ambitos original con la secto, y se pinta por sectores - shape
            path_lyr_arr[0] = path_import;
            //la primera capa que se añade es la de ruta, se le quita la visualización porque lo que interesa 
            //de esa capa es poder acceder si fuera necesario a la tabla de atributos. shape + name_ruta_out
            path_lyr_arr[1]= path_import + NAME_RUTA_OUT;
            //se añade la capa de ruta_aux y se pinta por sectores - shape + name_ruta_out + name_aux
            path_lyr_arr[2] = path_import + NAME_RUTA_OUT + NAME_AUX;
            //se abre la capa de puntos de control y se pintan por el sector al que pertenecen - shape + name_control_out
            path_lyr_arr[3] = path_import + NAME_CONTROL_OUT;

            //la siguiente es la de ruta2, se le quita la visualización porque lo que interesa 
            //de esa capa es poder acceder si fuera necesario a la tabla de atributos. shape + name_ruta2_out
            if (System.IO.File.Exists(path_import + NAME_RUTA2_OUT))
                path_lyr_arr[nopen_++] = path_import + NAME_RUTA2_OUT;
            //se añade la capa de la ruta a las instalaciones, comprueba si hay configurada coordenadas de la instalación - shape + name_inst_out
            if (System.IO.File.Exists(path_import + NAME_INSTAL_OUT))
                path_lyr_arr[nopen_++] = path_import + NAME_INSTAL_OUT;

            NOPEN = nopen_;
            bool[] visible_arr = {true,false,true,false,false,false };
            int i;
            var resb = new Respuesta<bool>();
            for(i =0;i<NOPEN;i++)
            {
                com.ProgrSrc.IncMessage((uint)(60 / NOPEN));
                resb = HelperGdb.OpenLayerUniqueValue(path_lyr_arr[i], ComunDef.CamposCom.consulta_sector, visible_arr[i]);
                if (!resb.Value)
                    break;
            }
            if(i<NOPEN)
            {
                res.Value = string.Empty;
                res.Error.Add("Error al abrir capa " + path_lyr_arr[i] + " con Valor único. "+resb.Error.FirstOrDefault() );
            }
            else
            {
                res.Value = path_import;
            }
            return res;
        }
        /**
         * Realiza las funciones de importación, modo 0 secto, modo 1 planif
         */
        public Respuesta<string> Import(string GdbFileName, int modo, string FtClssName="")
        {
            var res = new Respuesta<string> { Value = string.Empty };

            /////////////////////////////////////////
            string path_shape = OliviaGlob.Paths.PathData;
            string dir_shp = System.IO.Path.GetDirectoryName(path_shape);
            string shapefile = System.IO.Path.GetFileNameWithoutExtension(path_shape);
            int ind = shapefile.IndexOf("_", 0);
            string prefijo = shapefile.Substring(ind + 1, 1);
            //////////////////////////////////////////////////////////////////////////////////
            //decodifica el nombre del shapefile para asignarle el correspondiente nombre en la GDB a la que se importa el shape
            string tratamiento = string.Empty;
            string ambitos = string.Empty;
            com.decode_gdb(shapefile, out tratamiento, out ambitos); //supsuestamente distingue si es limpieza o recogida
            
            if(string.IsNullOrEmpty(tratamiento) || string.IsNullOrEmpty(ambitos))
            {
                res.Error.Add(string.Format("Nombre del archivo a importar erróneo. No se reconoce el prefijo introducido: {0}", prefijo));
                return res;
            }

            bool reco_o_limp_con_instala = (prefijo == "F") ||
                ((prefijo == "T") && !com.CoordsInstal.Equals(new Coordinate2D(0, 0)));
            bool reco_tramos = System.IO.File.Exists(System.IO.Path.Combine(dir_shp, shapefile + NAME_RUTA2 + EXT_SHP));


            /////////////////////////////////////////
            /////mira a ver si tiene configurado Dataset
            string msg_avisa = string.Empty;
            string amb_aux = string.Empty;
            bool sobreescribe = false;
            if (!string.IsNullOrEmpty(OliviaGlob.Paths.PathDatasetImport))
            {
                var datname = new System.IO.DirectoryInfo(OliviaGlob.Paths.PathDatasetImport).Name;
                var task1 = HelperGdb.CheckDataset(OliviaGlob.Paths.PathDatasetImport);
                task1.Wait();
                if (task1.Result)
                {
                    tratamiento = datname;
                }
                else
                {
                    msg_avisa = "No se encuentra el Dataset " + datname + ". ";
                }
            }
            else
            {
                /////////////////////////////////////////
                //no tiene un dataset configurado, saca ventana para elegir uno
                //saca ventana para elegir Dataset, si se cancela, se guarda en el nombre por defecto en función del tratamiento y los ámbitos
                //HelperGlobal.ponMsg("A continuación, introduzca nombre de Feature Class y ubicación (Dataset) para importación. Si cancela el proceso, se establecerán el nombre y Dataset por defecto en función de los ámbitos y el tratamiento");
                string path_aux = FtClssName;
                    //HelperGdb.SaveFileDlg("Introduzca nombre de Feature Class a importar", GdbFileName, null, ArcGIS.Desktop.Catalog.ItemFilters.featureClasses_all);
                if (!string.IsNullOrEmpty(path_aux))
                {
                    tratamiento = new DirectoryInfo(System.IO.Path.GetDirectoryName(path_aux)).Name;
                    //tratamiento = System.IO.Path.GetFileName(System.IO.Path.GetDirectoryName(path_aux));
                    amb_aux = System.IO.Path.GetFileNameWithoutExtension(path_aux);
                    //comprueba si ya existe ese ft class
                    FeatureClass ft = HelperGdb.GetFtClassSync(path_aux);
                    if (ft != null)
                        sobreescribe = true;
                    HelperGdb.Free(ft);
                }
            }
            //crea el dataset o comprueba si existe
            string datasetNameOut = string.Empty;
            var resp = HelperGdb.CreateDataset(GdbFileName, tratamiento, spatRefData, out datasetNameOut);            
            
            if(resp.Value==0)
            {
                //avisa
                msg_avisa += "Se importan los archivos en " + GdbFileName + "\\" + datasetNameOut;
                //HelperGlobal.ponMsg("Se importan los archivos en "+ GdbFileName+"\\"+ datasetNameOut);
                tratamiento = datasetNameOut;
            }
            else if (resp.Value == 1)
            {
                res.Error.Add("Error al crear el Dataset para importar " + tratamiento);
                return res;
            }
            else //2 o 4 if (resp.Value == 2)
            {
                //avisa
                string err_spatref = string.Empty;
                if (resp.Value==2)
                    err_spatref = "Atención, no coincide la proyección de las FeatureClass del Dataset ya creado con la del FeatureClass a importar. ";
                msg_avisa = err_spatref + "Se ha creado un nuevo dataset " + datasetNameOut;
                //HelperGlobal.ponMsg(err_spatref +", se ha creado un nuevo dataset "+ datasetNameOut );
                tratamiento = datasetNameOut;
            }
            //avisa ahora para dar tiempo?
            if (!string.IsNullOrEmpty(msg_avisa))
            {
                if(!HelperGlobal.ponMsg(msg_avisa, MessageBoxImage.Question, "OLIVIA", MessageBoxButton.OKCancel))
                {
                    res.Error.Add("Proceso de importación Cancelado por el usuario");
                    return res;
                }
            }

            string dataset = tratamiento;
            /////////////////////////////////////////
            if (!string.IsNullOrEmpty(amb_aux))
                ambitos = amb_aux;
            /////////////////////////////////////////
            //todo ok, se pone a importar
            string err_st =string.Empty;
            string path_import = GdbFileName + "\\" + dataset + "\\" + ambitos;
            int NIMPORT;
            string[] noms_shp = null;
            string[] noms_gdb = null;
            int i;
            int ii = 0;
            NIMPORT = 0;
            if (modo == 0) //sectoriza
            {
                NIMPORT = 1;
                noms_shp = new string[NIMPORT];
                noms_gdb = new string[NIMPORT];
                noms_shp[0] = shapefile;
                noms_gdb[0] = ambitos;
                /*noms_shp[1] = shapefile + NAME_AUX;
                noms_gdb[1] = ambitos + NAME_SECT;*/
            }
            else if (modo == 1) //planifica
            {
                if (reco_o_limp_con_instala)
                    NIMPORT = 5;
                else
                    NIMPORT = 4;
                if (reco_tramos)
                    NIMPORT++;
                noms_shp = new string[NIMPORT];
                noms_gdb = new string[NIMPORT];
                noms_shp[0] = shapefile;
                noms_gdb[0] = ambitos;
                /*noms_shp[1] = shapefile + NAME_AUX;
                noms_gdb[1] = ambitos + NAME_SECT;*/
                noms_shp[1] = shapefile + NAME_CONTROL;
                noms_gdb[1] = ambitos + NAME_CONTROL_OUT;
                noms_shp[2] = shapefile + NAME_RUTA;
                noms_gdb[2] = ambitos + NAME_RUTA_OUT;
                noms_shp[3] = shapefile + NAME_RUTA_AUX;
                noms_gdb[3] = ambitos + NAME_RUTA_OUT + NAME_AUX;
                ii = 4;
                if (reco_o_limp_con_instala)
                {
                    noms_shp[4] = shapefile + NAME_INSTAL;
                    noms_gdb[4] = ambitos + NAME_INSTAL_OUT;
                    ii++;
                }
                if (reco_tramos)
                {
                    noms_shp[ii] = shapefile + NAME_RUTA2;
                    noms_gdb[ii] = ambitos + NAME_RUTA2_OUT;
                }
            }
            if (noms_gdb == null || noms_shp==null)
            {
                res.Error.Add("Errores al crear los nombres de las Feature Class");
                return res;
            }
            Respuesta<bool> resp2;
            try
            {
                /////////////////////////////////////////
                //se embucla para hacer todas las importaciones necesarias
                for (i = 0; i < NIMPORT; i++)
                {
                    //mira a ver si hay que borrar para reemplazar
                    if (sobreescribe)
                    {
                        resp = HelperGdb.DeleteFeatureClassSync(GdbFileName + "\\" + dataset, noms_gdb[i]);
                        if (resp.Value!=-2 && resp.Value!=1) //-2 porque puede ser que no pueda abrir la capa porque no existe
                        {
                            err_st = "Error al sobreescribir la capa " + noms_gdb[i];
                            break;
                        }
                    }

                    resp2 = HelperGdb.ImportShp(dir_shp + "\\" + noms_shp[i] + HelperGdb.SHP_EXT, GdbFileName + "\\" + dataset, noms_gdb[i]);
                    if (!resp2.Value)
                    {
                        err_st = "Error al importar la capa " + noms_gdb[i];
                        if (resp2.HasError)
                            err_st += " " + resp2.Error.First();
                        break;
                    }
                }
                if (i < NIMPORT)
                {
                    res.Error.Add("Errores en la importación: "+err_st);
                    return res;
                }

                //cambia el nombre de los campos que había truncado a 10 caracteres al exportar a shp
                //solo para la capa original
                resp2 = com.RestauraNomCampos(GdbFileName + "\\" + dataset + "\\" + noms_gdb[0]);
                if (!resp2.Value)
                {
                    err_st = "Error al renombrar campos " + noms_gdb[0];
                    if (resp2.HasError)
                        err_st += " " + resp2.Error.First();
                    res.Error.Add("Errores en la importación: " + err_st);
                    return res;
                }
            }
            catch
            {
                res.Error.Add("Errores en la importación");
                return res;
            }
            finally
            {

            }
            res.Value = path_import;
            return res;
        }    
        /**
         * Cierra del mapa las capas de trabajo después de la exportación
         */
         public void CierraCapas()
        {
            if (!string.IsNullOrEmpty(OliviaGlob.Paths.PathData))
            {
                string capa_principal = System.IO.Path.GetFileNameWithoutExtension(OliviaGlob.Paths.PathData);
                HelperGdb.CloseLayer(capa_principal);
            }
            if (!string.IsNullOrEmpty(OliviaGlob.Paths.PathNW))
            {
                string capa_principal_nw = System.IO.Path.GetFileNameWithoutExtension(OliviaGlob.Paths.PathNW);
                HelperGdb.CloseLayer(capa_principal_nw);
            }
        }
    }
}
