using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using Deltares.Standard.Language;

namespace Deltares.Maps
{
    /// <summary>
    ///     Sets property values of target objects which are retrieved from the ShapeFile attributes covering a given point
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class PolygonAttributeImporter<T> : IAttributeImporter<T>
    {
        private readonly IList<Exception> errors;

        public PolygonAttributeImporter()
        {
            errors = new List<Exception>();
        }

        public IEnumerable<Exception> Errors
        {
            get { return errors; }
        }

        /// <summary>
        /// Gets or sets the name of the file.
        /// </summary>
        /// <value>
        /// The name of the file.
        /// </value>
        public string FileName { private get; set; }

        public void AddError(Exception exception)
        {
            errors.Add(exception);
        }

        /// <summary>
        ///     Sets the feature repository containing the attribute data
        /// </summary>
        public IFeatureRepository AttributeRepository { private get; set; }

        /// <summary>
        ///     Sets the target objects containing the properties to set the retrieved coverage values on
        /// </summary>
        public IEnumerable<T> Targets { private get; set; }

        /// <summary>
        ///     Sets the x getter function, which is used to get the x value from a target object
        /// </summary>
        public Func<T, double> XGetter { private get; set; }

        /// <summary>
        ///     Sets the y getter function, which is used to get the y value from the target object
        /// </summary>
        public Func<T, double> YGetter { private get; set; }

        /// <summary>
        ///     Sets the list of attributes to read from the repository when a match is found
        /// </summary>
        public IEnumerable<AttributeMapping<T>> AttributeMappings { private get; set; }

        /// <summary>
        ///     Materializes the target object properties using its x and y values in the coverage function
        /// </summary>
        public void Import()
        {
            if (Targets == null)
            {
                throw new InvalidOperationException("No targets set");
            }

            if (AttributeRepository == null)
            {
                throw new InvalidOperationException("No repository set");
            }

            if (!AttributeRepository.SupportedAttributes.Any())
            {
                throw new InvalidOperationException("The repository doesn't contain attributes");
            }

            if (AttributeMappings == null)
            {
                throw new InvalidOperationException("No attribute set");
            }

            foreach (T target in Targets)
            {
                double x = XGetter(target);
                double y = YGetter(target);

                Debug.Write(string.Format("analyzing location at ({0} {1})", x, y));

                List<IFeature> features = AttributeRepository.GetFeaturesCovering(x, y).ToList();
                if (features.Count == 0)
                {
                    Debug.WriteLine("Error: No match");
                    AddError(new FeatureCoverageException(string.Format(LocalizationManager.GetTranslatedText(this, "NoMatchError"), target, FileName, x.ToString("F2"), y.ToString("F2"))));
                    continue;
                }

                if (features.Count > 1)
                {
                    Debug.WriteLine("Error: Multiple matches");
                    AddError(new FeatureCoverageException(string.Format("Multiple geometries found covering point ({0} {1})", x.ToString("F2"), y.ToString("F2"))));
                    continue;
                }

                Debug.WriteLine("Success");
                IFeature match = features[0];

                foreach (var mapping in AttributeMappings)
                {
                    string attributeName = mapping.Name;
                    if (!match.Attributes.Exists(attributeName))
                    {
                        AddError(new AttributeMissingException(attributeName));
                        continue;
                    }

                    mapping.Action(target, match.Attributes[attributeName]);
                }
            }
        }
    }
}