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)
        {
            using (OliviaGlob.progrDialog = new ProgressDialog("Exportando Datos", "Cancelar", 100, true))
            {
                var status = new ProgressorSource(OliviaGlob.progrDialog);
                
                OliviaGlob.progrDialog.Show();
                bool fue_mal = false;
                status.Message = "Exportando Datos";
                status.Value = 0;
                status.Status = "Exportando Datos";
                status.Max = 100;
                //esconde el pane
                OliviaGlob.ShowHidePane(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;
                }

                //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)
                    {
                        ErrStr = "No se ha podido generar geometría de los ámbitos" + com.ConsultaAmbs + ErrStr;
                        fue_mal = true;
                    }

                    if (geom_export == null || geom_export.IsEmpty)
                    {
                        fue_mal = true;
                    }
                }

                //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);
                    if (filtroEspacial == null)
                    {
                        fue_mal = true;
                    }
                }

                if (!fue_mal)
                {
                    Ejecuta(modo, status);
                    OliviaGlob.progrDialog.Hide();
                    return true;
                }

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

                return false;
            }
        }


        /**
         * Prepara la geometría para exportar los ámbitos
         */
        public Geometry GetGeomAmbitsExport()
        {
            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).Result;
            if (geomAux == null || geomAux.IsEmpty)
            {
                ErrStr = "No se ha podido generar geometría de los ámbitos" + com.ConsultaAmbs + HelperGdb.OutStr;
                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;
                }
            }
            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 void Ejecuta(ModosEjec modo, ProgressorSource dlgProcess)
        {
            //lanza ventana de progreso
          
            
            //exporta los datos de entrada
            bool res=HelperGdb.ExportShp(com.CapaElems, filtroEspacial, com.NombreShpExport, OliviaGlob.Paths.DirData, dlgProcess).Result;
            if(!res)
            {
                string msg = HelperGdb.OutStr;
                if (!string.IsNullOrEmpty(msg))
                    msg = "Han ocurrido errores al convertir a shape.";
                HelperGlobal.ponMsg(msg);
            }

            

        }

    }
}