//-----------------------------------------------------------------------
// <copyright file="Sensor.cs" company="Deltares">
//  Copyright (c) 2012 Deltares. All rights reserved.
// </copyright>
// <author>B. Faassen</author>
// <email>barry.faassen@deltares.nl</email>
// <date>1-8-2012</date>
// <summary>n.a.</summary>
//-----------------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Xml.Serialization;
using Deltares.Standard;
using Deltares.Standard.Attributes;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.IO.Xml;
using Deltares.Standard.Specifications;
using GeoAPI.Geometries;
using NetTopologySuite.Geometries;
using Validator = Deltares.Standard.Specifications.Validator;
using XmlSerializer = Deltares.Standard.IO.Xml.XmlSerializer;

namespace Deltares.Dam.Data.Sensors
{
    /// <summary>
    /// This class represents a sensor or monitoring point used in dikes. 
    /// This entity is created for Dam Live
    /// </summary>
    [Serializable]
    public class Sensor : IName, IVisibleEnabled
    {
        #region Business Rules

        /// <summary>
        /// Specication to test if the value of the candidate is valid
        /// </summary>
        internal class ContiansAtLeastOneItem : PredicateSpecification<IEnumerable<PLLineType>>
        {
            public ContiansAtLeastOneItem()
                : base(x => x.Any())
            {
                Description = "The sensor should contain at least one PL Line mapping.";
            }
        }

        #endregion

        private readonly IGeometry geometry;
        private double relativeLocation;
        private readonly HashSet<PLLineType> plLineTypes;
        private int id;

        public Sensor()
        {
            plLineTypes = new HashSet<PLLineType>();
            ID = -1;
            geometry = new Point(0,0,0);            
        }

        public Sensor(Point point) : this()
        {
            if (point == null) throw new ArgumentNullException("point");
            this.geometry = point;

        }

        public Sensor(double x, double y, double z) : this(new Point(x, y, z))
        {           
        }

        /// <summary>
        /// Gets or sets the ID.
        /// </summary>
        /// <value>
        /// The ID should be unique.
        /// </value>
        [PropertyOrder(1,1)]
        public int ID 
        { 
            get { return id; }
            set
            {
                id = value;
                DataEventPublisher.AfterChange(this, s => s.ID);
            } 
        }

        /// <summary>
        /// Gets or sets the name of this sensor.
        /// </summary>
        /// <value>
        /// The name string value should not be empty and unique.  
        /// </value>
        [Specification(typeof(NotEmptySpecification))]
        [PropertyOrder(1, 2)]
        public string Name { get; set; }

        /// <summary>
        /// Gets or sets the depth.
        /// </summary>
        /// <value>
        /// The depth.
        /// </value>
        [PropertyOrder(1, 5)]
        [Format("F3")]
        public double Depth
        {
            get { return ZRd; }
            set
            {
                DataEventPublisher.BeforeChange(this, s => s.Depth);
                ZRd = value;
                DataEventPublisher.AfterChange(this, s => s.Depth);
            }
        }

        /// <summary>
        /// Gets or sets the relative location along the profile.
        /// </summary>
        /// <value>
        /// The relative location in meter.
        /// </value>
        [PropertyOrder(1, 4)]
        [Format("F3")]
        public double RelativeLocation
        {
            get { return relativeLocation; }
            set 
            {
                DataEventPublisher.BeforeChange(this, s => s.RelativeLocation);
                relativeLocation = value;
                RelativeLocationSpecified = true;
                DataEventPublisher.AfterChange(this, s => s.RelativeLocation);
            }
        }

        /// <summary>
        /// Gets or sets the X rd.
        /// </summary>
        /// <value>
        /// The X rd.
        /// </value>
        [Browsable(false)]
        public double XRd
        {
            get { return geometry.Coordinate.X; }
            set { geometry.Coordinate.X = value; }
        }

        /// <summary>
        /// Gets or sets the Y rd.
        /// </summary>
        /// <value>
        /// The Y rd.
        /// </value>
        [Browsable(false)]
        public double YRd
        {
            get { return geometry.Coordinate.Y; }
            set { geometry.Coordinate.Y = value; }
        }

        /// <summary>
        /// Gets or sets the Z rd. Same as Depth??
        /// </summary>
        /// <value>
        /// The Z rd.
        /// </value>
        [Browsable(false)]
        public double ZRd
        {
            get { return geometry.Coordinate.Z; }
            set { geometry.Coordinate.Z = value; }
        }

        /// <summary>
        /// Gets a value indicating whether the relative location is specified.
        /// </summary>
        /// <value>
        /// 	<c>true</c> if the relative location is specified; otherwise, <c>false</c>.
        /// </value>
        [Browsable(false)]
        public bool RelativeLocationSpecified { get; private set; } 

        private SensorType type;

        /// <summary>
        /// Gets or sets the type of this sensor.
        /// </summary>
        /// <value>
        /// The type. Default value is PiezoMetricHead.
        /// </value>
        [PropertyOrder(1, 7)]
        public SensorType Type
        {
            get { return type; }
            set { type = value; }
        }

        /// <summary>
        /// Gets or sets the PL line array. Used for serialization only.      
        /// </summary>
        /// <value>
        /// The PL line array.
        /// </value>
        [XmlElement("PLLineMappings")]
        [Specification(typeof(NotNullSpecification))]
        [Specification(typeof(ContiansAtLeastOneItem))]
        [Browsable(false)]
        public PLLineType[] PLLineMappings 
        {
            get { return plLineTypes.ToArray(); }
            set 
            { 
                ClearPLLines();
                foreach (var lineType in value)
                {
                    Add(lineType);    
                }                
            }
        }

        [XmlIgnore]
        [PropertyOrder(1, 6)]
        public string PLLineMappingsAsString
        {
            get
            {
                string res = "";
                foreach (var plLineType in plLineTypes)
                {
                    switch (plLineType)
                    {
                        case PLLineType.PL1: res = res + "1; "; break;
                        case PLLineType.PL2: res = res + "2; "; break;
                        case PLLineType.PL3: res = res + "3; "; break;
                        case PLLineType.PL4: res = res + "4; "; break;                       
                    }                    
                }
                return res;
            }
            set
            {
                ClearPLLines();
                var locPlLineTypes = ParseStringToPlLineTypes(value);
                foreach (var plLineType in locPlLineTypes)
                {
                    switch (plLineType)
                    {
                        case 1: plLineTypes.Add(PLLineType.PL1); break;
                        case 2: plLineTypes.Add(PLLineType.PL2); break;
                        case 3: plLineTypes.Add(PLLineType.PL3); break;
                        case 4: plLineTypes.Add(PLLineType.PL4); break;
                    }                    
                }
            }
        }

        private List<int> ParseStringToPlLineTypes(string value)
        {
            value = value.Trim();
            var ids = new List<int>();
            var idsarr = value.Split(new Char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
            foreach (var s in idsarr)
            {
                try
                {
                    var val = Int32.Parse(s);
                    ids.Add(val);
                }
                catch (Exception)
                {
                    // surpress errors, just do not use value
                }
            }
            return ids;
        }

        /// <summary>
        /// Adds the specified PL line.
        /// </summary>
        /// <param name="plLine">The PL line.</param>
        public void Add(PLLineType plLine)
        {
            plLineTypes.Add(plLine);
        }

        /// <summary>
        /// Removes the specified PL line.
        /// </summary>
        /// <param name="plLine">The PL line.</param>
        public void Remove(PLLineType plLine)
        {
            plLineTypes.Remove(plLine);
        }

        /// <summary>
        /// Clears the PL lines list.
        /// </summary>
        public void ClearPLLines()
        {
            plLineTypes.Clear();
        }


        /// <summary>
        /// Serializes this instance to a xml string.
        /// </summary>
        /// <returns>A xml string</returns>
        internal string Serialize()
        {
            var xmlSerializer = new XmlSerializer();
            return xmlSerializer.SerializeToString(this);
        }


        /// <summary>
        /// Deserializes the specified XML.
        /// </summary>
        /// <param name="xml">The XML to deserialize.</param>
        /// <returns>A sensor instance</returns>
        internal static Sensor Deserialize(string xml)
        {
            var xmlDeserializer = new XmlDeserializer();
            return (Sensor)xmlDeserializer.XmlDeserializeFromString(xml, typeof(Sensor));
        }

        /// <summary>
        /// Determines whether this instance is valid.
        /// </summary>
        /// <returns>
        ///   <c>true</c> if this instance is valid; otherwise, <c>false</c>.
        /// </returns>
        public bool IsValid()
        {
            return !Validator.Validate(this).Any();
        }

        /// <summary>
        /// Determines whether this instance is transient (associated with a correct ID in the context of the repository).
        /// </summary>
        /// <returns>
        ///   <c>true</c> if this instance is transient; otherwise, <c>false</c>.
        /// </returns>
        public bool IsTransient()
        {
            return ID < 0;
        }

        public override string ToString()
        {
            var name = string.IsNullOrWhiteSpace(Name) ? "name_not_set" : Name;

            return string.Format("[ID: {0}, Name: {1}, Depth: {2}, Type: {3}, RelativeLocation: {4}]", 
                ID, name, Depth, Type, RelativeLocation);
        }

        public bool IsVisible(string property)
        {
            switch (property)
            {
                case "XRd": return false;
                case "YRd": return false;
                case "ZRd": return false;
                default: return true;
            }            
        }

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