using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using Deltares.Geotechnics;
using Deltares.Geotechnics.ConePenetrationTest;
using Deltares.Geotechnics.GeotechnicalGeometry;
using Deltares.Geotechnics.Mechanisms;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard;
using Deltares.Standard.Attributes;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Language;
using Deltares.Standard.Validation;

namespace Deltares.DeltaModel
{
    /// <summary>
    /// Container of all key data, such as soil profiles, dike lines and revetment location and properties
    /// </summary>
    public class DeltaModel : IDomain, IVisibleEnabled
    {
        private readonly IDictionary<Type, IList> ListDictionary = new Dictionary<Type, IList>();

        /// <summary>
        /// Initializes a new instance of the <see cref="DeltaModel"/> class.
        /// Initializes all collections
        /// </summary>
        public DeltaModel()
        {
            Regions = RegisterList<Region>();
            AsphaltRegions = RegisterList<AsphaltRegion>();
            BlockRevetmentRegions = RegisterList<BlockRevetmentRegion>();

            DikeLines = RegisterList<DikeLine>();
            CharacteristicLines = RegisterList<CharacteristicLine>();

            SoilProfiles1D = RegisterList<SoilProfile1D>();
            SoilProfiles2D = RegisterList<SoilProfile2D>();
            SoilSegments = RegisterList<SoilSegment>();
            CPTs = RegisterList<ConePenetrationTestData>();
            CPTLookup1Ds = RegisterList<ConePenetrationTestLookup1D>();
            CPTLookup2Ds = RegisterList<ConePenetrationTestLookup2D>();
            Borings = RegisterList<Boring>();
            BoringLookup1Ds = RegisterList<BoringLookup1D>();
            BoringLookup2Ds = RegisterList<BoringLookup2D>();

            AsphaltZones = RegisterList<AsphaltZone>();
            RoughnessZones = RegisterList<RoughnessZone>();
            Structures = RegisterList<Structure>();
            BreakWaters = RegisterList<BreakWater>();
            PiezometricHeads = RegisterList<PiezometricHeads>();
            WaveZones = RegisterList<WaveZone>();
            SurfaceLines = RegisterList<LocalizedGeometryPointString>();
            SchematizedSurfaceLines = RegisterList<SurfaceLine2>();
            Soils = new SoilList();
            Soils.Soils = RegisterList<Soil>();
            HydraulicBoundaries = RegisterList<HydraulicBoundary>();
            BlockRevetmentCrossSections = RegisterList<BlockRevetmentCrossSection>();

            ListDictionary[typeof(TimeGeometryPointString)] = SurfaceLines;
        }

        /// <summary>
        /// Collection Regions
        /// A region is a geographic region, which comprises dike lines
        /// </summary>
        public List<Region> Regions { get; private set; }

        /// <summary>
        /// Collection of asphalt regions.
        /// </summary>
        [Mechanism(Mechanism.None, Mechanism.AsphaltRevetment)]
        public List<AsphaltRegion> AsphaltRegions { get; private set; }

        /// <summary>
        /// Collection of block revetment regions.
        /// </summary>
        [Mechanism(Mechanism.None, Mechanism.BlockRevetment)]
        public List<BlockRevetmentRegion> BlockRevetmentRegions { get; private set; }

        /// <summary>
        /// Collection Dikelines
        /// A dike line is a ‘backbone’ of a dike and applicable for all failure mechanisms. The user can select points along the dike line to view properties such as a name.
        /// Points have global XYZ-coordinates and local L-coordinates along dike line. Locations can have name (labels) or L-coordinate indications (km-pole)
        /// </summary>
        public List<DikeLine> DikeLines { get; private set; }

        /// <summary>
        /// Collection of characteristic lines, grouped per characteristic point type
        /// </summary>
        public List<CharacteristicLine> CharacteristicLines { get; private set; }

        /// <summary>
        /// Collection of characteristic points, grouped per characteristic point type
        /// </summary>
        public List<CharacteristicPoint> CharacteristicPoints { get; private set; }

        /// <summary>
        /// Collection subsoil profiles (1D)
        /// The sub soil library contains a List of 1D soil profiles. 
        /// Data for crossSection view
        /// </summary>
        [Mechanism(Mechanism.None, Mechanism.Piping, Mechanism.Stability, Mechanism.Dunes)]
        public List<SoilProfile1D> SoilProfiles1D { get; private set; }

        /// <summary>
        /// Collection subsoil profiles (2D)
        /// The sub soil library contains a List of 2D soil profiles. 
        /// Data for crossSection view
        /// </summary>
        [Mechanism(Mechanism.None, Mechanism.Piping, Mechanism.Stability)]
        public List<SoilProfile2D> SoilProfiles2D { get; private set; }

        /// <summary>
        /// Collection (stochastic) soil segments
        /// Stochastic soil segment is line segment linked to a collection of 1D/2D soil profiles, each having a given probability of occurence
        /// </summary>
        public List<SoilSegment> SoilSegments { get; private set; }

        /// <summary>
        /// Collection CPTs (Cone Pressure Tests)
        /// </summary>
        public List<ConePenetrationTestData> CPTs { get; private set; }

        /// <summary>
        /// Collection CPT to SoilProfile1D relationships
        /// </summary>
        public List<ConePenetrationTestLookup1D> CPTLookup1Ds { get; private set; }

        /// <summary>
        /// Collection CPT to SoilProfile2D relationships
        /// </summary>
        public List<ConePenetrationTestLookup2D> CPTLookup2Ds { get; private set; }

        /// <summary>
        /// Collection Borings (Bore hole tests)
        /// </summary>
        public List<Boring> Borings { get; private set; }

        /// <summary>
        /// Collection Boring to SoilProfile1D relationships
        /// </summary>
        public List<BoringLookup1D> BoringLookup1Ds { get; private set; }

        /// <summary>
        /// Collection Boring to SoilProfile2D relationships
        /// </summary>
        public List<BoringLookup2D> BoringLookup2Ds { get; private set; }

        /// <summary>
        /// Collection roughness zones
        /// Roughness zones are map polygons which are overlayed with the dike line and surfacelines to determine the roughness of surfaceline segments.
        /// </summary>
        [Mechanism(Mechanism.None)]
        [XmlOldName("Revetments")]
        public List<RoughnessZone> RoughnessZones { get; private set; }

        /// <summary>
        /// Collection asphalt revetment zones
        /// Revetment zones are map polygons which are overlayed with the dike line and surfacelines to determine the asphalt characteristics of surfaceline segments.
        /// </summary>
        [Mechanism(Mechanism.None)]
        public List<AsphaltZone> AsphaltZones { get; private set; }

        /// <summary>
        /// Collection structures
        /// Hydraulic Structures like gates, concrete defense walls, etc
        /// Structurs are line objects and have a begin and endpoint (location points). 
        /// </summary>
        [ReadOnly(true)]
        [Mechanism(Mechanism.None)]
        public List<Structure> Structures { get; private set; }

        /// <summary>
        /// Collection breakwater lines
        /// Breakwaters like dam caisson, rubble mound, are line objects. They have a begin and end point (location points). 
        /// </summary>
        [Mechanism(Mechanism.Overtopping)]
        public List<BreakWater> BreakWaters { get; private set; }

        /// <summary>
        /// Collection piezometric heads
        /// Piezometric Head is imported with key-data in the map editor as polygons. It is applied to all cross sections inside a particular polygon. 
        /// </summary>
        [Mechanism(Mechanism.None, Mechanism.Piping, Mechanism.Stability)]
        public List<PiezometricHeads> PiezometricHeads { get; private set; }

        /// <summary>
        /// Collection of wave zone areas
        /// Wave zones are imported with key-data in the map editor as dike sections. It is applied to all cross sections inside a particular polygon. 
        /// </summary>
        [Mechanism(Mechanism.None, Mechanism.Overtopping, Mechanism.BlockRevetment)]
        public List<WaveZone> WaveZones { get; private set; }

        /// <summary>
        /// Gets the surface lines.
        /// </summary>
        public List<LocalizedGeometryPointString> SurfaceLines
        {
            get; 
            private set;
            
        }

        /// <summary>
        /// Gets the surface lines.
        /// </summary>
        public List<SurfaceLine2> SchematizedSurfaceLines { get; private set; }

        /// <summary>
        /// Gets the soils
        /// </summary>
        [Mechanism(Mechanism.None, Mechanism.Piping, Mechanism.Stability)]
        [Label("SoilTypes")]
        public SoilList Soils { get; set; }

        /// <summary>
        /// List of boundary conditions from HydraRing dBase
        /// </summary>
        [ReadOnly(true)]
        [Browsable(false)]
        [Mechanism(Mechanism.AssessmentLevel, Mechanism.Overtopping, Mechanism.BlockRevetment, Mechanism.AsphaltRevetment, Mechanism.Structures)]
        public List<HydraulicBoundary> HydraulicBoundaries { get; private set; }

        /// <summary>
        /// List of revetment crossections from Steentoets
        /// </summary>
        [ReadOnly(true)]
        [Browsable(false)]
        [Mechanism(Mechanism.None)]
        public List<BlockRevetmentCrossSection> BlockRevetmentCrossSections { get; private set; }

        /// <summary>
        /// Default Fillmaterial to use when combining soil profile and surfaceline
        /// </summary>
        [Mechanism(Mechanism.None, Mechanism.Piping, Mechanism.Stability)]
        public Soil DefaultDikeEmbankmentMaterial { get; set; }

        /// <summary>
        /// Gets the list of the type.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <returns>List containing objects with given type</returns>
        /// <exception cref="System.ArgumentException">no list available for type</exception>
        public IList GetListForType(Type type)
        {
            IList list;
            ListDictionary.TryGetValue(type, out list);

            if (list == null)
            {
                throw new ArgumentException("no list available for type " + type);
            }

            return list;
        }

        /// <summary>
        /// Sends an event for lists with stochasts
        /// </summary>
        public void UpdateListsWithStochasts()
        {
            foreach (var list in new IList[]
                {
                    Soils.Soils, PiezometricHeads, Structures, BreakWaters, RoughnessZones
                })
            {
                DataEventPublisher.DataListModified(list);
            }
        }

        /// <summary>
        /// Clears all lists.
        /// </summary>
        public virtual void ClearAllLists()
        {
            foreach (var list in ListDictionary.Values)
            {
                list.Clear();
                DataEventPublisher.DataListModified(list);
            }
        }

        #region IDomain Members

        /// <summary>
        /// Gives a choice list for a certain property
        /// </summary>
        /// <param name="property">Property</param>
        /// <returns>Choice list</returns>
        public ICollection GetDomain(string property)
        {
            switch (property)
            {
                case "Region":
                    return Regions;
                case "Soil":
                    return Soils.Soils;
                case "SoilProfile":
                    return SoilProfiles1D;
                case "SurfaceLine":
                    return SurfaceLines;
                case "PiezometricHead":
                case "PiezometricHead3":
                case "PiezometricHead4":
                    return PiezometricHeads;
                case "BreakWater":
                case "BreakWaters":
                    return BreakWaters;
                case "Structure":
                case "Structures":
                    return Structures;
                case "RevetmentZone":
                case "RevetmentZones":
                    return RoughnessZones;
                case "HydraulicBoundaries":
                    return HydraulicBoundaries;
                default:
                    return null;
            }
        }

        #endregion

        #region IVisibleEnabled Members

        /// <summary>
        /// Determines whether the specified property is enabled.
        /// </summary>
        /// <param name="propertyName">The property.</param>
        /// <returns>whether the specified property is enabled</returns>
        public bool IsEnabled(string propertyName)
        {
            return true;
        }

        /// <summary>
        /// Determines whether the specified property is visible.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <returns>whether the specified property is visible</returns>
        public bool IsVisible(string property)
        {
            return MechanismSupport.IsMechanismVisible(typeof(DeltaModel), property);
        }

        #endregion

        #region Validation

        /// <summary>
        /// Validates the delta model = checks if hydraulic boundaries are present
        /// </summary>
        /// <returns>validation result of delta model</returns>
        [Validate]
        public ValidationResult[] ValidateDeltaModel()
        {
            var results = new List<ValidationResult>();

            //Hydraulic conditions
            if (HydraulicBoundaries.Count == 0)
            {
                results.Add(BuildErrorValidationResultForThis("NoHydraulicBoundariesMessage"));
            }

            return results.ToArray();
        }

        /// <summary>
        /// returns a build error validation result for delta model.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <returns>build error</returns>
        private ValidationResult BuildErrorValidationResultForThis(string message)
        {
            return new ValidationResult(ValidationResultType.Error, this.Translate(message), this);
        }

        #endregion

        /// <summary>
        /// Initializes collections of given type
        /// </summary>
        /// <typeparam name="T">given type</typeparam>
        /// <returns>registered list = initialized collection</returns>
        private List<T> RegisterList<T>()
        {
            var list = new List<T>();
            ListDictionary[typeof(T)] = list;
            return list;
        }
    }
}