// Copyright (C) Stichting Deltares 2018. All rights reserved.
//
// This file is part of the application DAM - Clients Library.
//
// DAM - UI is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System;
using System.Collections.Generic;
using System.Linq;

using GeoAPI.Geometries;

using NetTopologySuite.Features;
using NetTopologySuite.Index.Quadtree;

namespace Deltares.Maps
{
    /// <summary>
    ///     Spatial Indexed Feature Repository
    /// </summary>
    public class FeatureRepository : IFeatureRepository
    {
        private readonly IList<IFeature> emptyGeometryFeatures;
        private readonly IList<IFeature> features;
        private Quadtree<IFeature> spatialIndex;

        public FeatureRepository()
        {
            features = new List<IFeature>();
            emptyGeometryFeatures = new List<IFeature>();
            spatialIndex = new Quadtree<IFeature>();
        }

        public static IFeatureRepository CreateFromShapeFile(string fileName)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException("fileName");
            }

            return CreateFromShapeFile(new ShapeFileLocation(fileName));
        }

        public IEnumerable<IFeature> Query(IFeature feature)
        {
            return Query(feature.Geometry);
        }

        public IEnumerable<IFeature> Query(IGeometry geometry)
        {
            return geometry.IsEmpty ? emptyGeometryFeatures : Query(geometry.EnvelopeInternal);
        }

        /// <summary>
        ///     Gets features based on the envelope.
        /// </summary>
        /// <remarks>
        ///     Note that this call won't handle empty geometries. To return empty geometries as well use Query(IFeature) or
        ///     Query(IGeometry)
        ///     instead of this call
        /// </remarks>
        /// <param name="envelope"></param>
        /// <returns></returns>
        public IEnumerable<IFeature> Query(Envelope envelope)
        {
            //return this.featureLookup.Values.Where(f => envelope.Intersects(f.Geometry.EnvelopeInternal));
            return spatialIndex.Query((Envelope)envelope);
        }

        public static IFeatureRepository CreateFromShapeFile(ShapeFileLocation shapeFileLocation)
        {
            if (shapeFileLocation == null)
            {
                throw new ArgumentNullException("shapeFileLocation");
            }
            var repository = new FeatureRepository();
            try
            {
                FeatureImporter.ImportFromShapeFile(shapeFileLocation, repository);
            }
            catch (Exception e)
            {
                throw e;
            }
            return repository;
        }

        public IEnumerable<Guid> FeatureIds
        {
            get { return Features.Select(geom => geom.Id); }
        }

        public IGeometry GetGeometryById(Guid id)
        {
            //var feature = this.featureLookup.Values.FirstOrDefault(item => item.Id == id);
            IFeature feature = Features.FirstOrDefault(item => item.Id == id);
            if (feature != null)
            {
                return feature.Geometry;
            }

            throw new ArgumentException(string.Format("Unknown id '{0}', geometry not found", id));
        }

        public IEnumerable<KeyValuePair<string, object>> GetAttributes(IGeometry geom)
        {
            if (geom == null)
            {
                throw new ArgumentNullException("geom");
            }

            IFeature feature =
                Features.SingleOrDefault(
                    f => f.Geometry == geom || f.Geometry.AsText().GetHashCode() == geom.AsText().GetHashCode());

            if (feature != null)
            {
                IAttributesTable attributes = feature.Attributes;
                return attributes.GetNames().Select(attr => new KeyValuePair<string, object>(attr, attributes[attr]));
                ;
            }

            throw new ArgumentException("Couldn't find the geometry in the repository");
        }

        public IEnumerable<IFeature> Features
        {
            get { return features.Concat(emptyGeometryFeatures); }
        }

        /// <summary>
        ///     TODO: Is it allowed to have different attributes per geometry? If this is the case the we have to create a fast and
        ///     robust attribute collector.
        /// </summary>
        public IEnumerable<string> SupportedAttributes
        {
            get
            {
                if (Features == null || !Features.Any())
                {
                    return new List<string>();
                }

                return Features.SelectMany(geometry => geometry.Attributes.GetNames()).Distinct();
            }
        }

        public void Add(IFeature feature)
        {
            if (feature == null)
            {
                throw new ArgumentNullException("feature");
            }

            if (feature.Geometry.IsEmpty)
            {
                emptyGeometryFeatures.Add(feature);
            }
            else
            {
                features.Add(feature);
                AddToSpatialIndex(feature);
            }
        }

        private void AddToSpatialIndex(IFeature feature)
        {
            try
            {
                spatialIndex.Insert(feature.Geometry.EnvelopeInternal, feature);
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        private void RemoveFromSpatialIndex(IFeature feature)
        {
            spatialIndex.Insert(feature.Geometry.EnvelopeInternal, feature);
        }

        public void Add(IEnumerable<IFeature> featureCollection)
        {
            if (featureCollection == null)
            {
                throw new ArgumentNullException("featureCollection");
            }

            foreach (IFeature feature in featureCollection)
            {
                Add(feature);
            }
        }

        public void Remove(IFeature feature)
        {
            if (feature == null)
            {
                throw new ArgumentNullException("feature");
            }

            if (feature.Geometry.IsEmpty)
            {
                emptyGeometryFeatures.Remove(feature);
            }
            else
            {
                features.Remove(feature);
                RemoveFromSpatialIndex(feature);
            }
        }

        public void Remove(Func<IFeature, bool> predicate)
        {
            if (predicate == null)
            {
                throw new ArgumentNullException("predicate");
            }

            var work = new Queue<IFeature>(Count);
            foreach (IFeature feature in Features.Where(predicate))
            {
                work.Enqueue(feature);
            }

            while (work.Count > 0)
            {
                Remove(work.Dequeue());
            }
        }

        public void Add(Feature feature, Func<IFeature, bool> predicate)
        {
            if (feature == null)
            {
                throw new ArgumentNullException("feature");
            }

            if (predicate == null)
            {
                throw new ArgumentNullException("predicate");
            }

            if (predicate(feature))
            {
                Add(feature);
            }
        }

        /// <summary>
        ///     Clears the list of features in the repository
        /// </summary>
        public void Clear()
        {
            features.Clear();
            emptyGeometryFeatures.Clear();
            spatialIndex = new Quadtree<IFeature>();
        }

        /// <summary>
        ///     Gets the feature count in the repository
        /// </summary>
        public int Count
        {
            get { return features.Count + emptyGeometryFeatures.Count; }
        }
    }
}