using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using Deltares.Geotechnics;
using Deltares.Standard;
using Deltares.Standard.Attributes;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Units;
using Deltares.Standard.Validation;

namespace Deltares.DeltaModel
{
    /// <summary>
    /// Revetment Top Layer Data Object
    /// TODO: Comment
    /// </summary>
    public class BlockRevetmentTopLayerData : ICloneable
    {
        private double averageBlockLength;
        private double averageBlockWidth;
        private double characteristicOpenDiameter;
        private double d15Inwas;
        private double dOneffen;
        private YesNoQuestionMark goedGeklemd;
        private List<Hole> holes = new List<Hole>();
        private double ingegotenToplaagDiepte;
        private double ingegotenToplaagVgd;
        private bool ingewassen;
        private double omega;
        private double rho;
        private double spleetBreedteLangsVoeg;
        private double spleetBreedteStootVoeg;
        private TopLayerType topLayerMaterial;
        private double topLayerThickness;

        public BlockRevetmentTopLayerData()
        {
            topLayerMaterial = Deltares.DeltaModel.TopLayerType.GetTopLayerTypeByCode(1, 0, 0);
        }

        /// <summary>
        /// Gets or sets the type of the revetment top layer.
        /// </summary>
        /// <value>
        /// The type of the top layer.
        /// </value>
        [Unit(UnitType.None)]
        [Minimum(0)]
        [Maximum(1E9)]
        [Label("Type")]
        [Description("Type")]
        [Format("F3")]
        [Category("Toplaag")]
        public string TopLayerType
        {
            get
            {
                return topLayerMaterial.FormattedCode();
            }
        }

        /// <summary>
        /// Gets or sets the top layer thickness.
        /// </summary>
        /// <value>
        /// The top layer thickness.
        /// </value>
        [Unit(UnitType.Length)]
        [Minimum(0)]
        [Maximum(1E9)]
        [Label("D")]
        [Description("D")]
        [Format("F3")]
        [Category("Toplaag")]
        public double TopLayerThickness
        {
            get
            {
                return topLayerThickness;
            }
            set
            {
                this.SetAndNotify2(out topLayerThickness, value, d => d.TopLayerThickness);
            }
        }

        /// <summary>
        /// Gets or sets the average width of the blocks.
        /// </summary>
        /// <value>
        /// The average width of the blocks.
        /// </value>
        [Unit(UnitType.Length)]
        [Minimum(0)]
        [Maximum(1E9)]
        [Label("BBlok")]
        [Description("BBlok")]
        [Format("F3")]
        [Category("Toplaag")]
        [Clearable]
        public double AverageBlockWidth
        {
            get
            {
                return averageBlockWidth;
            }
            set
            {
                this.SetAndNotify2(out averageBlockWidth, value, d => d.AverageBlockWidth);
            }
        }

        /// <summary>
        /// Gets or sets the average length of the blocks.
        /// </summary>
        /// <value>
        /// The average length of the blocks.
        /// </value>
        [Unit(UnitType.Length)]
        [Minimum(0)]
        [Maximum(1E9)]
        [Label("LBlok")]
        [Description("LBlok")]
        [Format("F3")]
        [Category("Toplaag")]
        [Clearable]
        public double AverageBlockLength
        {
            get
            {
                return averageBlockLength;
            }
            set
            {
                this.SetAndNotify2(out averageBlockLength, value, d => d.AverageBlockLength);
            }
        }

        /// <summary>
        /// Relative open surface
        // Dutch original text:
        // Relatief open oppervlakt.
        /// </summary>
        /// <value>
        /// The omega.
        /// </value>
        [Unit(UnitType.Fractions)]
        [Minimum(0)]
        [Maximum(1)]
        [Label("Omega")]
        [Description("Omega")]
        [Format("F3")]
        [Category("Toplaag")]
        [Clearable]
        public double Omega
        {
            get
            {
                return omega;
            }
            set
            {
                this.SetAndNotify2(out omega, value, d => d.Omega);
            }
        }

        /// <summary>
        /// List containing one or more instances of class hole, which characterize holes in toplayer.
        /// </summary>
        [Category("Toplaag")]
        public List<Hole> Holes
        {
            get
            {
                return holes;
            }
            set
            {
                this.SetAndNotify2(out holes, value, d => d.Holes);
            }
        }

        /// <summary>
        /// Characteristical diamater of the relative large holes in the settlement
        /// (Average size of hole per squaremeter of settlement).
        /// This is used for the testing of the mechanism material transport 
        /// from the granular layer.
        /// TODO: Comment
        // 
        // Dutch original text:
        //  Karakteristiek diameter van de relatief grote gaten in 
        //  de zetting (gemiddelde van grootste gat per vierkante meter zetting).  
        //  Dit wordt gebruikt voor de toetsing van 
        //  het mechanisme materiaaltransport vanuit de granulaire laag.
        /// </summary>
        [Unit(UnitType.TinyLength)]
        [Minimum(0)]
        [Maximum(1E9)]
        [Label("Opening")]
        [Description("Opening")]
        [Format("F3")]
        [Category("Toplaag")]
        [Clearable]
        public double CharacteristicOpenDiameter
        {
            get
            {
                return characteristicOpenDiameter;
            }
            set
            {
                this.SetAndNotify2(out characteristicOpenDiameter, value, d => d.CharacteristicOpenDiameter);
            }
        }

        /// <summary>
        /// Specific mass of the blocks in the top layer.
        /// if empty, the value from the worksheet 'Info' will be used.
        /// TODO: Comment
        // 
        //  Dutch original text:
        //  Soortelijke massa van de stenen in de toplaag. 
        //  Als blanco, dan wordt waarde uit werkblad 'Info' aangehouden.
        /// </summary>
        [Minimum(0)]
        [Maximum(1E9)]
        [Label("Rho")]
        [Description("Rho")]
        [Format("F3")]
        [Category("Toplaag")]
        [Clearable]
        public double Rho
        {
            get
            {
                return rho;
            }
            set
            {
                this.SetAndNotify2(out rho, value, d => d.Rho);
            }
        }

        /// <summary>
        /// Whether slits (and holes) in the top layer are washed-in with 
        /// granular material such as stone chippings. Fill in yes in case the slits are 
        /// on average at least for a half the height of the slit washed-in. 
        /// TODO: Comment
        // 
        // Dutch original text:
        // Of de spleten (en gaten) in de tolaag zijn ingewassen met granulair
        // materiaal, zoals steenslag. Vul ja in als de spleten gemiddeld 
        // voor ten minste de halve spleethoogte zijn ingewassen.
        /// </summary>
        [Label("Ingewassen")]
        [Description("Ingewassen")]
        [Category("Toplaag")]
        [Clearable]
        public bool Ingewassen
        {
            get
            {
                return ingewassen;
            }
            set
            {
                this.SetAndNotify2(out ingewassen, value, d => d.Ingewassen);
            }
        }

        /// <summary>
        /// Grain-size of the washed in material (granular material in the 
        /// slits and holes), that will be undershot by 15 weight percent.
        /// TODO: Comment
        // 
        // Dutch original text:
        // Korrelgrootte van het inwasmateriaal 
        // (granulair materiaal in de spleten en gaten), 
        // dat door 15 gewichtsprocenten wordt onderschreden.
        /// </summary>
        [Unit(UnitType.TinyLength)]
        [Minimum(0)]
        [Maximum(1E9)]
        [Label("D15Inwas")]
        [Description("D15Inwas")]
        [Format("F3")]
        [Category("Toplaag")]
        [Clearable]
        public double D15Inwas
        {
            get
            {
                return d15Inwas;
            }
            set
            {
                this.SetAndNotify2(out d15Inwas, value, d => d.D15Inwas);
            }
        }

        /// <summary>
        /// For a well washed-in (closely set) blocksettlement, the interaction between the blocks is good.
        /// This is also called a well clamped settlement. The slits need to be filled for at least half the 
        /// slit height with stone chippings. Sand and mud do not contribute to the clamping.
        /// Rectangle blocks with no washing-ins are not well clamped.
        /// TODO: Comment
        // 
        // Dutch original text:
        // Voor een goed ingewassen (dicht gezette) steenzetting geldt dat de 
        // interactie tussen de stenen goed is. Men spreekt dan van een goed 
        // geklemde zetting. De spleten moeten minstens voor de helft van de 
        // spleethoogte gevuld zijn met steenslag. Zand en slib dragen niet bij aan 
        // de klemming. Rechthoekige blokken zonder inwassing zijn niet goed geklemd
        /// </summary>
        [Unit(UnitType.None)]
        [Label("GoedGeklemd")]
        [Description("GoedGeklemd")]
        [Category("Toplaag")]
        [Clearable]
        public YesNoQuestionMark GoedGeklemd
        {
            get
            {
                return goedGeklemd;
            }
            set
            {
                this.SetAndNotify2(out goedGeklemd, value, d => d.GoedGeklemd);
            }
        }

        /// <summary>
        /// The degree in which blocks are settled and/or the blocks stick out of the surrounding blocks.
        /// This is only relevant for stone settlements on the crown and the inner slope of the harbor dam.
        /// It is about the height of the highest standing edge in the settlement, against which the waves 
        /// can splash, formed by the two stones in the following lines.
        /// TODO: Comment
        // 
        // Dutch original text: 
        // De mate waarin stenen verzakt zijn en of stenen boven de omliggende stenen uitsteken. 
        // Dit is slechts relevant  voor steenzettingen op de kruin en het binnentalud 
        // van een havendam. Het gaat om de hoogte van de grootste opstaande rand in de 
        // zetting, waartegen de golfoverslag kan aanstromen, gevormd door twee stenen in 
        // opeenvolgende rijen.
        /// </summary>
        [Unit(UnitType.Length)]
        [Minimum(0)]
        [Maximum(1E9)]
        [Label("DOneffen")]
        [Description("DOneffen")]
        [Format("F3")]
        [Category("Toplaag")]
        [Clearable]
        public double DOneffen
        {
            get
            {
                return dOneffen;
            }
            set
            {
                this.SetAndNotify2(out dOneffen, value, d => d.DOneffen);
            }
        }

        /// <summary>
        /// The depth until which the cast between the blocks has permeated.
        /// The average penetration depth in the larger opening around the block is to be measured.
        /// That is done on several locations, whereas the smallest value is of relevance.
        /// Don't fill in anything if the top layer is not cast.
        /// TODO: Comment
        // 
        // Dutch original text:
        // De diepte tot waar de ingieting tussen de stenen is doorgedrongen. 
        // Men dient de gemiddelde penetratiediepte in de grotere openingen 
        // rondom een steen te meten. Dit doet men vervolgens op meerdere locaties, 
        // waarbij de kleinste waarde maatgevend is.  Vul niets in als de toplaag 
        // niet is ingegoten.
        /// </summary>
        [Unit(UnitType.Length)]
        [Minimum(0)]
        [Maximum(1E9)]
        [Label("IngegotenToplaagDiepte")]
        [Description("IngegotenToplaagDiepte")]
        [Format("F3")]
        [Category("IngegotenToplaag")]
        [Clearable]
        public double IngegotenToplaagDiepte
        {
            get
            {
                return ingegotenToplaagDiepte;
            }
            set
            {
                this.SetAndNotify2(out ingegotenToplaagDiepte, value, d => d.IngegotenToplaagDiepte);
            }
        }

        /// <summary>
        /// Value for the measurement of the VGD ("valgewichtdeflectie") in MegaPascal. On each level where 
        /// this is measured, the average value is determined per approximately 10m of the dike.
        /// The lowest value is relevant. Dont fill in anything if there has been no VGD measurement.
        /// TODO: Comment
        // 
        // Dutch original text:
        // Waarde van de valgewichtdeflectiemeting in megapascal.  Op elk niveau waar dit 
        // gemeten wordt, bepaald men de gemiddelde waarde per ca 10 m dijkstrekking. 
        // De laagste waarde is vervolgens maatgevend.  
        // Vul niets in als er geen VGD meting is uitgevoerd.
        /// </summary>
        [Unit(UnitType.Pressure)] // GPa
        [Minimum(0)]
        [Label("IngegotenToplaagVGD")]
        [Description("IngegotenToplaagVGD")]
        [Format("F3")]
        [Category("IngegotenToplaag")]
        [Clearable]
        public double IngegotenToplaagVgd
        {
            get
            {
                return ingegotenToplaagVgd;
            }
            set
            {
                this.SetAndNotify2(out ingegotenToplaagVgd, value, d => d.IngegotenToplaagDiepte);
            }
        }

        /// <summary>
        /// Average slit width of the slits which run up along the slope. In case of 
        /// Block settlements with very varying slits (such as basalt) it can also be sufficient to
        /// fill in only the relative open surface. This cell then stays empty.
        /// TODO: Comment
        // 
        // Dutch original text:
        // Gemiddelde spleetbreedte van de spleten die langs het talud 
        // omhoog lopen. In geval van steenzetting met erg varierende spleten 
        // (zoals basalt) kan ook volstaan worden met het invoeren van alleen het 
        // relatieve open oppervlak. Deze cel blijft dan blanco.
        /// </summary>
        [Unit(UnitType.TinyLength)]
        [Minimum(0)]
        [Maximum(1E9)]
        [Label("SpleetBreedteStootVoeg")]
        [Description("SpleetBreedteStootVoeg")]
        [Format("F3")]
        [Category("SpleetBreedte")]
        [Clearable]
        public double SpleetBreedteStootVoeg
        {
            get
            {
                return spleetBreedteStootVoeg;
            }
            set
            {
                this.SetAndNotify2(out spleetBreedteStootVoeg, value, d => d.SpleetBreedteStootVoeg);
            }
        }

        /// <summary>
        /// Average "slit width of the slits which run parllel to the waterline. In case of 
        /// block settlements with very varying slits (such as basalt) it can also be sufficient to
        /// fill in only the relative open surface. This cell then stays empty.
        /// TODO: Comment
        // 
        // Dutch original text:
        // Gemiddelde spleetbreedte van de spleten die evenwijdig aan 
        // de waterlijn lopen. In geval van steenzetting met erg varierende spleten (zoals basalt) 
        // kan ook volstaan worden met het invoeren van alleen 
        // het relatieve open oppervlak. Deze cel blijft dan blanco.  
        /// </summary>
        [Unit(UnitType.TinyLength)]
        [Minimum(0)]
        [Maximum(1E9)]
        [Label("SpleetBreedteLangsVoeg")]
        [Description("SpleetBreedteLangsVoeg")]
        [Format("F3")]
        [Category("SpleetBreedte")]
        [Clearable]
        public double SpleetBreedteLangsVoeg
        {
            get
            {
                return spleetBreedteLangsVoeg;
            }
            set
            {
                this.SetAndNotify2(out spleetBreedteLangsVoeg, value, d => d.SpleetBreedteLangsVoeg);
            }
        }

        /// <summary>
        /// The coding of the type top layer can be found on the worksheet 'Info', for example 26.0 for basalt 
        /// or 28.51 for casting asfalt with granit. Fill this code in as a number. See Chapter 1 in the 
        /// 'TR-Steenzettingen'.
        /// TODO: Comment
        // 
        // Dutch original text:
        // De codering van het type toplaag is te vinden op het werkblad 'Info', 
        // bijvoorbeeld 26.0 voor basalt of 28.51 voor met gietasfalt ingegoten graniet. 
        // Vul de code in als getal. Zie ook hoofdstuk 1 in TR-Steenzettingen.
        /// </summary>
        [Label("TopLaagType")]
        [Description("TopLaagType")]
        [Category("Type")]
        [Clearable]
        public TopLayerType TopLayerMaterial
        {
            get
            {
                return topLayerMaterial;
            }
            set
            {
                this.SetAndNotify2(out topLayerMaterial, value, x => x.TopLayerMaterial);
            }
        }

        /// <summary>
        /// Returns a <see cref="System.String" /> that represents this instance.
        /// </summary>
        /// <returns>
        /// "Top Layer Data"
        /// </returns>
        public override string ToString()
        {
            return "Top Layer Data";
        }

        public object Clone()
        {
            return new BlockRevetmentTopLayerData
                {
                    topLayerThickness = topLayerThickness,
                    averageBlockWidth = averageBlockWidth,
                    averageBlockLength = averageBlockLength,
                    omega = omega,
                    characteristicOpenDiameter = characteristicOpenDiameter,
                    rho = rho,
                    ingewassen = ingewassen,
                    d15Inwas = d15Inwas,
                    goedGeklemd = goedGeklemd,
                    dOneffen = dOneffen,
                    ingegotenToplaagDiepte = ingegotenToplaagDiepte,
                    ingegotenToplaagVgd = ingegotenToplaagVgd,
                    spleetBreedteStootVoeg = spleetBreedteStootVoeg,
                    spleetBreedteLangsVoeg = spleetBreedteLangsVoeg,
                    topLayerMaterial = (TopLayerType) topLayerMaterial.Clone(),
                    holes = holes.Select(h => h.Clone()).Cast<Hole>().ToList()
                };
        }
    }
}