using System;
using System.ComponentModel;
using System.Xml.Serialization;
using Deltares.Geotechnics;
using Deltares.Standard;
using Deltares.Standard.Attributes;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Language;
using Deltares.Standard.Units;
using Deltares.Standard.Validation;

namespace Deltares.DeltaModel
{
    /// <summary>
    /// Revetment Layer Object
    /// TODO: Comment
    /// </summary>
    public class BlockRevetmentLayer : IVisibleEnabled, ICloneable<BlockRevetmentLayer>
    {
        private object material;
        private bool obliged;
        private bool present = true;
        private double thickness;
        private BlockRevetmentLayerType type = BlockRevetmentLayerType.None;

        /// <summary>
        /// Initializes a new instance of the <see cref="BlockRevetmentLayer"/> class.
        /// </summary>
        public BlockRevetmentLayer() {}

        /// <summary>
        /// Initializes a new instance of the <see cref="BlockRevetmentLayer"/> class.
        /// </summary>
        /// <param name="material">The material.</param>
        /// <param name="obliged">if set to <c>true</c>, internal present and obliged will be set to <c>true</c>.</param>
        /// <param name="type">The revetment layer type.</param>
        public BlockRevetmentLayer(object material, bool obliged, BlockRevetmentLayerType type)
        {
            this.type = type;
            this.material = material;
            this.obliged = obliged;
            present = obliged;
        }

        /// <summary>
        /// Gets the type.
        /// </summary>
        /// <value>
        /// The type.
        /// </value>
        [ReadOnly(true)]
        public BlockRevetmentLayerType Type
        {
            get
            {
                return type;
            }
            set
            {
                this.SetAndNotify2(out type, value, x => x.Type);
            }
        }

        /// <summary>
        /// Indicates whether the layer is used in the revetment calculation
        /// </summary>
        [PropertyOrder(1, 1)]
        public bool Present
        {
            get
            {
                return present;
            }
            set
            {
                this.SetAndNotify2(out present, value || obliged, x => x.Present);
            }
        }

        /// <summary>
        /// Gets or sets the thickness.
        /// </summary>
        /// <value>
        /// The thickness.
        /// </value>
        [Unit(UnitType.Length)]
        [Format("F3")]
        [PropertyOrder(1, 2)]
        [Clearable]
        public virtual double Thickness
        {
            get
            {
                return thickness;
            }
            set
            {
                this.SetAndNotify2(out thickness, value, x => x.Thickness);
            }
        }

        /// <summary>
        /// Gets or sets the material.
        /// </summary>
        /// <value>
        /// The material.
        /// </value>
        [PropertyOrder(1, 2)]
        [Validate]
        public object Material
        {
            get
            {
                return material;
            }
            set
            {
                this.SetAndNotify2(out material, value, x => x.Material);
            }
        }

        /// <summary>
        /// Gets or sets the revetment profile.
        /// </summary>
        /// <value>
        /// The revetment profile.
        /// </value>
        [XmlIgnore]
        [Browsable(false)]
        public BlockRevetmentProfile BlockRevetmentProfile { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether obliged.
        /// </summary>
        /// <value>
        ///   <c>true</c> if obliged; otherwise, <c>false</c>.
        /// </value>
        [Browsable(false)]
        public bool Obliged
        {
            get
            {
                return obliged;
            }
            set
            {
                obliged = value;
            }
        }

        public override string ToString()
        {
            return LocalizationManager.GetTranslatedText(typeof(BlockRevetmentLayerType), Type.ToString());
        }

        /// <summary>
        /// Creates a deep clone of the <see cref="BlockRevetmentLayer"/>.
        /// </summary>
        /// <returns>A deep clone.</returns>
        /// <exception cref="InvalidOperationException">When <see cref="Material"/> is not cloneable.</exception>
        public BlockRevetmentLayer Clone()
        {
            if (material != null && !(material is ICloneable))
            {
                throw new InvalidOperationException("Material should be cloneable");
            }

            var clonedMaterial = material != null ? ((ICloneable) material).Clone() : null;

            return new BlockRevetmentLayer(clonedMaterial, Obliged, Type)
                {
                    present = present,
                    thickness = thickness
                };
        }

        /// <summary>
        /// Determines whether the specified property is enabled.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <returns>for Property <c>false</c> if obliged is <c>true</c>, otherwisse <c>true</c></returns>
        public bool IsEnabled(string property)
        {
            switch (property)
            {
                case "Present":
                    return !Obliged;
                default:
                    return true;
            }
        }

        /// <summary>
        /// Determines whether the specified property is visible.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <returns><c>true</c>for property is Present, otherwise value of this.Present</returns>
        public bool IsVisible(string property)
        {
            return property.Equals("Present") || Present;
        }
    }
}