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;

namespace OliviaAddInPro.Services
{
        public enum ModosEjec
        {
            Sectoriza,
            Planifica
        }
    //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 prefNameExport = "data_";
        public string extShp = ".shp";
        public string name_export_nw = "nw_";

        public string ErrStr = "";
        public TratamientoComun com;
        /**
         * Acciones para comenzar ejecución
         * Modo 0, sectorizar
         * Modo 1, planificar
         */
        public bool ComienzaEjec(ModosEjec modo)
        {
            bool fue_mal = false;            
            
            //esconde el pane
            OliviaGlob.ShowHidePane(false);

            //Cuenta las filas que cumplen la consulta
            int nelems = HelperGdb.GetNumElems(com.CapaElems, com.ConsultaAmbs);
            if(nelems<=0)
            {
                ErrStr = "No existen ámbitos que cumplan las condiciones introducidas para la exportación " + com.ConsultaAmbs;
                fue_mal = true;
            }

            //Obtiene la geometría que envuelve a los ámbitos
            Geometry geom_export = null;
            if (!fue_mal)
            {
                geom_export = GetGeomAmbitsExport();
                if (geom_export == null || geom_export.IsEmpty)
                {
                    fue_mal = true;
                }
            }

            //mira spatialreference de los datos de entrada
            GetSpatialRef(geom_export);

            //crea el filtro de exportación
            SpatialQueryFilter filtroEspacial = null;
            if (!fue_mal)
            {
                filtroEspacial = CreaFiltro(com.ConsultaAmbs, geom_export);
                if (filtroEspacial == null)
                {
                    fue_mal = true;
                }
            }            

            if (!fue_mal)
            {
                Ejecuta(modo);
                return true;
            }

            //fue mal
            //muestra pane
            OliviaGlob.ShowHidePane(true);

            return false;            
        }                

        /**
         * Prepara la geometría para exportar los ámbitos
         */
        public Geometry GetGeomAmbitsExport()
        {
            Geometry geomAux = null;
            FeatureClass fc = HelperGdb.GetFtClass(com.CapaElems);
            QueryFilter filtro = new QueryFilter { WhereClause = com.ConsultaAmbs };
            if (fc == null)
            {
                ErrStr = "No se ha podido abrir la clase " + com.CapaElems;
                return null;
            }
            //comprueba que haya elementos que cumplen la consulta
            int nElem = HelperGdb.GetNumElems(fc, com.ConsultaAmbs).Result;
            if (nElem <= 0)
            {
                ErrStr = "No existen ámbitos que cumplan las condiciones dadas " + com.ConsultaAmbs;
                return null;
            }
            //Primero hace la geometría de los ámbitos que cumplen la consulta
            geomAux = HelperGdb.GetGeomConvexHull(fc, filtro);
            if (geomAux == null || geomAux.IsEmpty)
            {
                ErrStr = "No se ha podido generar geometría de los ámbitos" + com.ConsultaAmbs;
                return null;
            }
            //Hace la intersección de dicha geometría con las zonas
            if (com.GeomZon != null)
            {
                geomAux = HelperGdb.IntersectGeom(geomAux, com.GeomZon);
                if (geomAux == null)
                {
                    ErrStr = "Error al intersecar con las zonas.";
                    return null;
                }
                if(geomAux.IsEmpty)
                {
                    ErrStr = "No existen ámbitos en la intersección con las zonas.";
                    return null;
                }
            }

            //Hace la intersección de la geometría con los  niveles
            if (com.GeomNiv != null)
            {
                geomAux = HelperGdb.IntersectGeom(geomAux, com.GeomNiv);
                if (geomAux == null)
                {
                    ErrStr = "Error al intersecar con los niveles.";
                    return null;
                }
                if (geomAux.IsEmpty)
                {
                    ErrStr = "No existen ámbitos en la intersección con los niveles.";
                    return null;
                }
            }

            //le quita las restricciones
            if (com.GeomRestr != null)
            {
                geomAux = HelperGdb.QuitaGeom(geomAux, com.GeomRestr);
                if (geomAux == null)
                {
                    ErrStr = "Error al intersecar con las restricciones.";
                    return null;
                }
            }

            return geomAux;
        }

        public SpatialQueryFilter CreaFiltro(string consulta, Geometry geom)
        {
            SpatialQueryFilter filtSpac = new SpatialQueryFilter
            {
                WhereClause = consulta,
                FilterGeometry = geom,
                SpatialRelationship = SpatialRelationship.Contains,
            };
            return filtSpac;     
        }

        /**
         * 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;
        }

        /**
         * Coge spatial reference de los datos a exportar
         */ 
         public void GetSpatialRef(Geometry geom)
        {
            OliviaGlob.SpatRef = geom.SpatialReference;
        }

        /**
         * Exporta y lanza proceso y ventana de proceso
         */ 
        public void Ejecuta(ModosEjec modo)
        {

        }

        /**
         * Exporta los datos de entrada y el nw
         */
        public void Exporta(ModosEjec modo)
        {

        }

    }
}