// Copyright (C) Stichting Deltares 2018. All rights reserved.
//
// This file is part of the Dam Engine.
//
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System;
using System.Collections.Generic;
using System.Linq;
using Deltares.DamEngine.Data.Standard;

namespace Deltares.DamEngine.Data.General.Sensors
{
    /// <summary>
    /// This class represents a sensor or monitoring point used in dikes. 
    /// This entity is created for Dam Live
    /// </summary>
    public class Sensor : IName
    {
        #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;
        private double xRd;
        private double yRd;
        private double zRd;

        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))
        {
            xRd = x;
            yRd = y;
            zRd = z;
        }

        /// <summary>
        /// Gets or sets the ID.
        /// </summary>
        /// <value>
        /// The ID should be unique.
        /// </value>
        public int ID 
        { 
            get { return id; }
            set
            {
                id = value;                
            } 
        }

        /// <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))]
        public string Name { get; set; }

        /// <summary>
        /// Gets or sets the depth.
        /// </summary>
        /// <value>
        /// The depth.
        /// </value>
        public double Depth
        {
            get { return ZRd; }
            set
            {
                ZRd = value;                
            }
        }

        /// <summary>
        /// Gets or sets the relative location along the profile.
        /// </summary>
        /// <value>
        /// The relative location in meter.
        /// </value>
        public double RelativeLocation
        {
            get { return relativeLocation; }
            set 
            {
                relativeLocation = value;
                RelativeLocationSpecified = true;                
            }
        }

        /// <summary>
        /// Gets or sets the X rd.
        /// </summary>
        /// <value>
        /// The X rd.
        /// </value>
        public double XRd
        {
            get { return xRd; }
            set { xRd = value; }
        }

        /// <summary>
        /// Gets or sets the Y rd.
        /// </summary>
        /// <value>
        /// The Y rd.
        /// </value>
        public double YRd
        {
            get { return yRd; }
            set { yRd = value; }
        }

        /// <summary>
        /// Gets or sets the Z rd. Same as Depth??
        /// </summary>
        /// <value>
        /// The Z rd.
        /// </value>
        public double ZRd
        {
            get { return zRd; }
            set { zRd = 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>
        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>
        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>
      //  [Specification(typeof(NotNullSpecification))]
       // [Specification(typeof(ContiansAtLeastOneItem))]
        public PLLineType[] PLLineMappings 
        {
            get { return plLineTypes.ToArray(); }
            set 
            { 
                ClearPLLines();
                foreach (var lineType in value)
                {
                    Add(lineType);    
                }                
            }
        }

        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>
        /// 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);
        }
    }
}