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;

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 = "";
        SpatialQueryFilter filtroEspacial = null;
        SpatialReference spatRef = null;
        public TratamientoComun com;
        /**
         * Acciones para comenzar ejecución
         * Modo 0, sectorizar
         * Modo 1, planificar
         */
        public bool ComienzaEjec(ModosEjec modo, CancelableProgressorSource cps, out string ErrStr)
        {
            bool fue_mal = false;
            ErrStr = string.Empty;
           //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;
           }

            cps.Status = "Exportando geometria";

            //Obtiene la geometría que envuelve a los ámbitos
            Geometry geom_export = null;
           if (!fue_mal)
           {
               geom_export = GetGeomAmbitsExport(cps);
               if (geom_export == null || geom_export.IsEmpty)
               {
                   ErrStr = "No se ha podido generar geometría de los ámbitos" + com.ConsultaAmbs + ErrStr;
                   fue_mal = true;
               }
           }
           // cps.Value = 80;
            //crea el filtro de exportación            
            if (!fue_mal)
            {
                //mira spatialreference de los datos de entrada
                spatRef = geom_export.SpatialReference;
                filtroEspacial = CreaFiltro(com.ConsultaAmbs, geom_export);
                fue_mal = filtroEspacial == null;
                if(fue_mal)
                    ErrStr = "error al crear el filtro de exportacion";

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

            cps.Value = 80;

            if (!fue_mal)
                fue_mal = Ejecuta(modo, cps, out ErrStr);
   
            return fue_mal;

        }


        /**
         * Prepara la geometría para exportar los ámbitos
         */
        public Geometry GetGeomAmbitsExport(CancelableProgressorSource cps)
        {
            Geometry geomAux = null;
            ErrStr = string.Empty;
            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;
            }
            //Primero hace la geometría de los ámbitos que cumplen la consulta
            geomAux = HelperGdb.GetGeomConvexHull(fc, filtro, cps).Result;
            if (geomAux == null || geomAux.IsEmpty)
            {
                ErrStr = "No se ha podido generar geometría de los ámbitos" + com.ConsultaAmbs + HelperGdb.OutStr;
                return null;
            }
            cps.Value = 60;
            //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;
                }
            }
            cps.Value = 70;
            //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;
                }
            }
            cps.Value = 75;
            //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;
                }
            }
            HelperGdb.Free(fc);
            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;
        }

        /**
         * Exporta y lanza proceso y ventana de proceso
         */ 
        public bool Ejecuta(ModosEjec modo, CancelableProgressorSource cps, out string msg)
        {
            msg = "";
            //exporta los datos de entrada
            return HelperGdb.ExportShp(com.CapaElems, filtroEspacial, com.NombreShpExport, OliviaGlob.Paths.DirData, cps, out msg);
            

            

        }
        /*
         * Lee la capa que se ha seleccionzdo de recogida y se comprueba que contiene los campos necesarios
         * Devuelve 0 si va todo bien, -1 si da error, y num>0 con los campos que no encuentra
         */
        public int CompruebaCampos(string pathCapa, string[] camps)
        {
            int i;

            if (string.IsNullOrEmpty(pathCapa))
            {
                ErrStr = "No se encuentra la capa";
                return -1;
            }
            ErrStr = "No se encuentran el/los campo/s: ";
            int mal = 0;
            for (i = 0; i < camps.Length; i++)
            {
                if (!HelperGdb.CheckField(pathCapa, camps[i]))
                {
                    ErrStr = ErrStr + camps[i] + " ";
                    mal++;
                }
            }
            if(mal==0)
                ErrStr = "";
            return mal;
        }
    }
}