using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Deltares.Dam.Data.DataPlugins.Configuration;
using Deltares.Maps;
using GeoAPI.Geometries;

namespace Deltares.Dam.Data.Importers
{
    internal class LocationShapeFileImporter : IImporter<Location>
    {
        /// <summary>
        /// Creates a location shape file importer instance.
        /// </summary>
        /// <param name="existingLocationList">The existing location list.</param>
        /// <param name="configuredAttributes">The configured attributes.</param>
        /// <param name="shapeFileLocation">The shape file location.</param>
        /// <returns></returns>
        public static LocationShapeFileImporter Create(IEnumerable<Location> existingLocationList, IEnumerable<DataAttribute> configuredAttributes, string shapeFileLocation)
        {
            if (string.IsNullOrEmpty(shapeFileLocation) || shapeFileLocation.Trim() == "")
                throw new ArgumentException("shapeFileLocation");

            const string locationAttrId = LocationShapeFileAttributeMap.LocationAttributeId;
            var configuredAttribute = configuredAttributes.SingleOrDefault(a => a.AttributeId.Equals(locationAttrId, StringComparison.InvariantCultureIgnoreCase));

            if (configuredAttribute == null)
                return null;

            var locationMapping = LocationShapeFileAttributeMap.GetAttributeMapping(configuredAttribute, locationAttrId);

            var file = new ShapeFileLocation(shapeFileLocation, locationMapping.File);
            if (!file.Exists)
                throw new FileNotFoundException(string.Format("The file '{0}' is not found", file.FullPath));

            var importer = new LocationShapeFileImporter(existingLocationList, configuredAttributes)
                               {
                                   Repository = FeatureRepository.CreateFromShapeFile(file)
                               };

            return importer;
        }

        private readonly IEnumerable<DataAttribute> configuredAttributes;
        private readonly ICollection<Location> locations;
        private readonly IList<Exception> errors;

        /// <summary>
        /// Constructs a location importer class were data will be imported from ShapeFiles
        /// </summary>
        /// <param name="existingLocationList"></param>
        /// <param name="configuredAttributes"></param>
        public LocationShapeFileImporter(IEnumerable<Location> existingLocationList, IEnumerable<DataAttribute> configuredAttributes)
        {
            this.configuredAttributes = configuredAttributes;
            this.locations = new List<Location>();

            if (existingLocationList != null)
            {
                foreach (var location in existingLocationList.Where(location => location != null))
                {
                    this.locations.Add(location);
                }
            }

            this.errors = new List<Exception>();
        }

        public IEnumerable<Exception> ImportErrors
        {
            get { return this.errors; }
        }

        internal IFeatureRepository Repository { get; set; }

        #region Implementation of IImporter<Location>

        public IEnumerable<Location> ImportedItems
        {
            get { return locations; }
        }

        #endregion

        public void Import()
        {
            if (Repository == null)
                return;

            const string locationAttrId = LocationShapeFileAttributeMap.LocationAttributeId;
            var configuredAttribute = configuredAttributes.Single(a => a.AttributeId.Equals(locationAttrId, StringComparison.InvariantCultureIgnoreCase));
            var locationMapping = LocationShapeFileAttributeMap.GetAttributeMapping(configuredAttribute, locationAttrId);

            const string damTypeAttrId = LocationShapeFileAttributeMap.DamTypeAttributeId;
            configuredAttribute = configuredAttributes.SingleOrDefault(a => a.AttributeId.Equals(damTypeAttrId, StringComparison.InvariantCultureIgnoreCase));
            var damTypeMapping = LocationShapeFileAttributeMap.GetAttributeMapping(configuredAttribute, damTypeAttrId);

            const string dikeRingAttrId = LocationShapeFileAttributeMap.DikeRingAttributeId;
            configuredAttribute = configuredAttributes.SingleOrDefault(a => a.AttributeId.Equals(dikeRingAttrId, StringComparison.InvariantCultureIgnoreCase));
            var dikeRingMapping = LocationShapeFileAttributeMap.GetAttributeMapping(configuredAttribute, dikeRingAttrId);

            foreach (var feature in Repository.Features)
            {
                var locationIDValue = feature.Attributes[locationMapping.Name].ToString();
                var dikeRingIdValue = feature.Attributes[dikeRingMapping.Name].ToString();
                var damTypeValue = LocationImportHelper.ToDamType(feature.Attributes[damTypeMapping.Name]);

                var location = this.locations.FirstOrDefault(l => l.Name == locationIDValue);
                if (location == null)
                {
                    location = new Location();
                    location.SetDefaultValues(damTypeValue, Location.DamProjectType);
                    this.locations.Add(location);
                }
                location.Name = locationIDValue;
                location.DamType = damTypeValue;
                location.DikeRingId = dikeRingIdValue;
                location.XRd = feature.Geometry.Coordinate.X;
                location.YRd = feature.Geometry.Coordinate.Y;
            }
        }
    }
}