//-----------------------------------------------------------------------
// <copyright file="Dike.cs" company="Deltares">     
//  Copyright (c) 2009 Deltares. All rights reserved.
// </copyright>
// <author>R.C. blankenburgh</author>
// <email>remko.blankenburgh@deltares.nl</email>
// <date>26-08-2009</date>
// <summary>n.a.</summary>
//-----------------------------------------------------------------------

using Deltares.Geotechnics.Converter;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Geotechnics.Validation;
using Deltares.Standard.Attributes;
using Deltares.Standard.Data;
using Deltares.Standard.Language;
using Deltares.Standard.Logging;

namespace Deltares.Dam.Data
{
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using Soilbase;
    using Standard;
    using Geotechnics;
    using System.ComponentModel;
    using System.Xml.Serialization;

    using Standard.Extensions;

    public class DikeException : Exception
    {
        public DikeException(string message)
            : base(message)
        {
        }
    }

    public class DikeParameterNames
    {
        public const string MapForSoilGeometries2D = "MapForSoilGeometries2D";
    }

    [TrackChanges]
    public class Dike: IVisibleEnabled, IDisposable
    {
        private string description = "";
        public virtual string MapForSoilGeometries2D { get; set; }
        private IList<Location> locations;

        private IList<PL1Line> pl1Lines;
        private bool removeStiFiles;
        private MStabShearStrength shearmodel;
        private SoilList soilList;
        private IList<Gauge> gauges = new List<Gauge>();
        private IList<GaugePLLine> gaugePLLines = new List<GaugePLLine>();
        private IList<NonWaterRetainingObject> nonWaterRetainingObjects;
        private IList<SoilProfile1D> soilProfiles;
        private string soilDatabaseName = "";
        private List<Soil> databaseSoils = new List<Soil>();

        public Dike()
        {
            this.Name = "Dijkring";
            this.MapForSoilGeometries2D = "";

            this.locations = new List<Location>();
            this.soilProfiles = new List<SoilProfile1D>();

            this.surfaceLines = new DelegatedList<SurfaceLine> { AddMethod = ConvertAddedOldSurfaceLineToNewFormat };
            SurfaceLines2 = new List<SurfaceLine2>();
            this.pl1Lines = new List<PL1Line>();
            this.soilList = new SoilList();
            this.nonWaterRetainingObjects = new List<NonWaterRetainingObject>();
            removeStiFiles = true;
        }

        public bool IsRemoveStiFiles { get { return removeStiFiles; } set { removeStiFiles = value; } }
        public MStabShearStrength ShearStrengthModel { get { return shearmodel; } set { shearmodel = value; } }

        public virtual string Name { get; set; }

        public virtual string SoilDatabaseName
        {
            get { return this.soilDatabaseName; }
            set
            {
                this.soilDatabaseName = value;
                UpdateLocationsDatabaseName();
            }
        }

        /// <summary>
        /// Updates the locations for scenarios.
        /// </summary>
        public void UpdateLocationsForScenarios()
        {
            foreach (Location location in this.Locations)
            {
                foreach (Scenario scenario in location.Scenarios)
                {
                    scenario.Location = location;
                }
            }
        }

        /// <summary>
        /// Updates the name soil database for all locations.
        /// </summary>
        public void UpdateLocationsDatabaseName()
        {
            foreach (Location location in this.Locations)
            {
                location.SoildatabaseName = this.SoilDatabaseName;
            }

        }

        [XmlIgnore]
        public SoilbaseDB SoilBaseDB { get; set; }

        /// <summary>
        /// Gets the locations.
        /// </summary>
        /// <value>
        /// The locations.
        /// </value>
        public virtual IList<Location> Locations
        {
            get { return this.locations; }
            private set { this.locations = value; }
        }

        /// <summary>
        /// Sorts the locations.
        /// </summary>
        public void SortLocations()
        {
            this.locations = this.Locations.OrderBy(o => o.Name).ToList();
        }

        public IList<SurfaceLine2> SurfaceLines2 { get; set; }

        public virtual IList<PL1Line> PL1Lines
        {
            get { return this.pl1Lines; }
            set { this.pl1Lines = value; }
        }

        public virtual IList<SoilProfile1D> SoilProfiles
        {
            get { return this.soilProfiles; }
            set { this.soilProfiles = value; }
        }

        public virtual SoilList SoilList
        {
            get { return this.soilList; }
            set { this.soilList = value; }
        }

        [Browsable(false)]
        public virtual IList<Gauge> Gauges
        {
            get { return this.gauges; }
            set { this.gauges = value; }
        }

        [Browsable(false)]
        public virtual IList<GaugePLLine> GaugePLLines
        {
            get { return this.gaugePLLines; }
            set { this.gaugePLLines = value; }
        }

        public virtual IList<NonWaterRetainingObject> NonWaterRetainingObjects
        {
            get { return this.nonWaterRetainingObjects; }
            set { this.nonWaterRetainingObjects = value; }
        }

        public bool UsesGauges { get { return this.GaugePLLines != null && this.GaugePLLines.Count > 0 && this.Gauges != null; } }

        public virtual List<Scenario> Scenarios
        {
            get
            {
                var scenarios = new List<Scenario>();
                foreach (Location location in Locations)
                {
                    scenarios.AddRange(location.Scenarios);
                }
                return scenarios;
            }
        }

        public string Description
        {
            get { return description; }
            set { description = value; }
        }

        public void Validate()
        {
            if (Locations == null || Locations.Count < 1)
            {
                throw new DikeException("The dike ring has no locations defined");
            }
            foreach (Location location in Locations)
            {
                if (location.LocalXZSurfaceLine2 != null)
                {
                    var validator = new SurfaceLine2Validator();
                    var validationResults = validator.ValidateCharacteristicPointsAreOrdered(location.LocalXZSurfaceLine2)
                            .Concat(validator.ValidateGeometryPointsAreOrdered(location.LocalXZSurfaceLine2)).ToArray();
                    if (validationResults.Length > 0)
                    {
                        throw new SurfaceLineException(validationResults[0].Text);
                    }
                }
            }
        }

        public void CreateSoilBase()
        {
            if (this.SoilDatabaseName == null || !File.Exists(this.SoilDatabaseName))
            {
                throw new DikeException(String.Format("The soil database '{0}' cannot be found", this.SoilDatabaseName));
            }
            this.SoilBaseDB = SoilbaseDB.Create(this.SoilDatabaseName);
        }

        /// <summary>
        /// Read all the soils and their parameters from the database
        /// </summary>
        public void FillDataBaseSoilListFromSoilBase()
        {
            using (var geoDatabase = new GeoDatabase(this.SoilDatabaseName))
            {
                geoDatabase.ReUseSoils = true;
                var newSoilList = geoDatabase.ReadSoils(soilList.Soils);
                databaseSoils = newSoilList.Soils;
            }
        }

        /// <summary>
        /// Add 1D-soilprofiles from MGeobase database
        /// </summary>
        public void AddSoilProfilesFromDB()
        {
            if (this.SoilDatabaseName == null || !File.Exists(this.SoilDatabaseName))
            {
                throw new DikeException(String.Format("The MGeobase database '{0}' cannot be found", this.SoilDatabaseName));
            }
            if (soilList.Soils.Count == 0)
            {
                FillDataBaseSoilListFromSoilBase();
                soilList.Soils.AddRange(databaseSoils);
            }
            if (soilList.Soils.Count == 0)
            {
                throw new DikeException(String.Format("The MGeobase database '{0}' does not contain soils and can not be used.", this.SoilDatabaseName));
            }
            MGeobaseDB mgbDB = new MGeobaseDB(soilList);
            IList<SoilProfile1D> addedSoilProfiles = mgbDB.AddSoilProfiles(this.SoilDatabaseName);
            foreach (var addedSoilProfile in addedSoilProfiles)
            {
                soilProfiles.Add(addedSoilProfile);
            }
        }

        /// <summary>
        /// Adapt data so it is consistent
        /// </summary>
        public List<LogMessage> MakeDataConsistent()
        {
            var errorSoils = TryToMakeSoilDataConsistent();
            var logMessages = new List<LogMessage>();
            // Delete all locations without surfaceline
            logMessages.AddRange(DeleteLocationsWithoutSurfaceLines());
            // Delete all locations that have profiles (in their segment) which hold soils 
            // that are not in the soil database and so have no parameters.
            logMessages.AddRange(DeleteLocationsWithProfilesWithUnknownSoils(errorSoils));
            return logMessages;
        }

        /// <summary>
        /// Tries to make the soil data as read for 1D profiles consistent with the data in the soil database.
        /// In the end we have a neat soil list with parameters for every soil as read from the database.
        /// We might have a list with errors (soils that were not to be found in the database so soils for which
        /// no parameters could be found).
        /// </summary>
        /// <returns></returns>
        private List<Soil> TryToMakeSoilDataConsistent()
        {
            var errorSoils = new List<Soil>();
            // Fill the list of errorSoils with soils that are in the current soillist (as result of importing
            // 1D profiles) but that are not found in the soil database because that are errors
            foreach (var soil in soilList.Soils)
            {
                var fs = databaseSoils.Find(t => String.Equals(t.Name, soil.Name, StringComparison.CurrentCultureIgnoreCase));
                if (fs == null)
                {
                    errorSoils.Add(soil);
                }
            }
            // Remove the error soils form the list
            foreach (var errorSoil in errorSoils)
            {
                soilList.Soils.Remove(errorSoil);
            }
            // Get the parameters for every soil in the now proper soil list from the database. Add soils
            // that are in the database but not yet in the soil list.
            foreach (Soil soil in databaseSoils)
            {
                Soil existingSoil = this.soilList.GetSoilByName(soil.Name);
                if (existingSoil == null)
                {
                    this.soilList.Soils.Add(soil);
                }
                else
                {
                    existingSoil.Assign(soil);
                }
            }
            return errorSoils;
        }

        /// <summary>
        /// Removes all locations which have profiles that have invalid soils
        /// </summary>
        private List<LogMessage> DeleteLocationsWithProfilesWithUnknownSoils(List<Soil> invalidSoils)
        {
            var logMessages = new List<LogMessage>();
            var invalidLocations = new List<Location>();
            string soilProf;
            string invSoil;
            foreach (var location in locations)
            {
                bool isInValid;
                string message = "";
                if (location.Segment == null)
                {
                    isInValid = true;
                    message = String.Format(LocalizationManager.GetTranslatedText(this.GetType(), "LocationWitNameHasNoSegment"), location.Name);
                }
                else
                {
                    isInValid = DoesLocationHaveInvalidSoils(invalidSoils, location, out soilProf, out invSoil);
                    if (isInValid)
                    {
                        message = String.Format(LocalizationManager.GetTranslatedText(this.GetType(), "LocationHasProfileWithInvalidSoils"), location.Name, soilProf, invSoil);
                    }
                }
                if (isInValid)
                {
                    invalidLocations.Add(location);
                    logMessages.Add(new LogMessage(LogMessageType.Warning, this, message));
                }
            }
            foreach (var invalidLocation in invalidLocations)
            {

                locations.Remove(invalidLocation);
            }
            return logMessages;
        }

        /// <summary>
        /// Checks wether a location (or rather the soilprofiles in the segement of the location) contains invalid soils.
        /// A soil is hereby considered invalid if it is not found in the database.
        /// </summary>
        /// <param name="invalidSoils"></param>
        /// <param name="location"></param>
        /// <param name="soilProf"></param>
        /// <param name="invSoil"></param>
        /// <returns></returns>
        private bool DoesLocationHaveInvalidSoils(List<Soil> invalidSoils, Location location, out string soilProf, out string invSoil)
        {
            soilProf = " ";
            invSoil = " ";
            foreach (var spp in location.Segment.SoilProfileProbabilities)
            {
                foreach (var invalidSoil in invalidSoils)
                {
                    var fl = spp.SoilProfile.Layers.Find(l => String.Equals(l.Soil.Name, invalidSoil.Name, StringComparison.CurrentCultureIgnoreCase));

                    if (fl != null)
                    {
                        soilProf = spp.SoilProfile.Name;
                        invSoil = invalidSoil.Name;
                        return true;
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// Delete all locations without surfacelines
        /// </summary>
        private List<LogMessage> DeleteLocationsWithoutSurfaceLines()
        {
            var logMessages = new List<LogMessage>();

            //Add all locations with valid surfaceline
            var newLocations = new List<Location>();
            newLocations.AddRange(this.Locations.Where(loc => loc.SurfaceLine2 != null));

            // Report which locations are not added because no valid surfaceline is found
            var deletedLocations = new List<Location>();
            deletedLocations.AddRange(this.Locations.Where(loc => loc.SurfaceLine2 == null));
            foreach (var deletedLocation in deletedLocations)
            {
                var locationHasNoSurfaceLine = LocalizationManager.GetTranslatedText(this.GetType(), "LocationHasNoSurfaceLine");
                logMessages.Add(new LogMessage(LogMessageType.Warning, this,
                    String.Format(locationHasNoSurfaceLine, deletedLocation.Name)));
            }

            this.Locations = newLocations;
            return logMessages;
        }

        public override string ToString()
        {
            return this.Name;
        }

        public Dictionary<string, string> GetParametersAsNameValuePairs()
        {
            var nameValuePairs = new Dictionary<string, string>();
            nameValuePairs.Add(DikeParameterNames.MapForSoilGeometries2D, MapForSoilGeometries2D);
            return nameValuePairs;
        }

        public void SetParameterFromNameValuePair(string parameterName, string parameterValue)
        {
            if (parameterName.Equals(DikeParameterNames.MapForSoilGeometries2D))
                this.MapForSoilGeometries2D = parameterValue;
        }

        public void UpdateLocation(Location location)
        {
            location.SoildatabaseName = this.SoilDatabaseName;
            location.SoilList = this.SoilList;
            location.MapForSoilGeometries2D = this.MapForSoilGeometries2D;

            location.Gauges.Clear();
            location.Gauges.AddRange(this.Gauges);

            location.GaugePLLines.Clear();
            location.GaugePLLines.AddRange(this.GaugePLLines);
        }

        public bool IsVisible(string property)
        {
            return true;
        }

        public bool IsEnabled(string property)
        {
            switch (property)
            {
                case "Name": return false;
                case "SoilList": return false;
                default: return true;
            }
        }

        #region Backwards compatibility

        private IList<SurfaceLine> surfaceLines;

        /// <summary>
        /// Gets or sets all surface lines instances associated with this dike.
        /// </summary>
        /// <remarks>Composite owner of all <see cref="SurfaceLine"/> that are part of the
        /// application that are associated with this dike.</remarks>
        [Obsolete("Do not use this member; Only exists for backwards compatibility.", true)]
        public virtual IList<SurfaceLine> SurfaceLines
        {
            get { return surfaceLines; }
            set { surfaceLines = value; }
        }

        /// <summary>
        /// Performs backwards compatibility conversion from old-style surfaceline to new-style
        /// surfaceline, and ensures that shared references are set correctly.
        /// </summary>
        /// <param name="argument">Persisted version of the old-style surfaceline.</param>
        private void ConvertAddedOldSurfaceLineToNewFormat(SurfaceLine argument)
        {
            var surfaceLine2 = new OldSurfaceLineToNewConverter().Convert(argument);
            SurfaceLines2.Add(surfaceLine2);

            foreach (var location in Locations)
            {
                location.SetNewSurfaceLineIfMatchesWithOldPersistedSurfaceLine(surfaceLine2);
            }

            // Remove old entry; it is no longer required.
            surfaceLines.Remove(argument);
            argument.Dispose();
        }

        #endregion

        public void Dispose()
        {
            foreach (var location in Locations)
            {
                location.Dispose();
            }
            foreach (var surfaceLine2 in SurfaceLines2)
            {
                surfaceLine2.Dispose();
            }
        }
    }
}