//-----------------------------------------------------------------------
// <copyright file="Group.cs" company="Deltares">
//  Copyright (c) 2009 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 ValidationResult = Deltares.Standard.Specifications.ValidationResult;
using Validator = Deltares.Standard.Specifications.Validator;
using XmlSerializer = Deltares.Standard.IO.Xml.XmlSerializer;

namespace Deltares.Dam.Data.Sensors
{
    [Serializable]
    public class Group
    {
        /// <summary>
        /// Holds a reference to the set of selected sensors 
        /// </summary>
        private readonly HashSet<Sensor> sensors;
        private List<Sensor> pickSensors;
        private int id;

        /// <summary>
        /// Holds a reference to a set of relative loctions along the profile
        /// </summary>
        private readonly IDictionary<Sensor, double> relativeLocationAlongProfileDictionary;

        public Group()
        {
            sensors = new HashSet<Sensor>();
            relativeLocationAlongProfileDictionary = new Dictionary<Sensor, double>();
            ID = -1;
            DataEventPublisher.AfterChange(this);
        }

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

        /// <summary>
        /// Gets the selected sensors.
        /// </summary>
        [XmlIgnore]
        [Browsable(false)]
        public IEnumerable<Sensor> Selection
        {
            get { return sensors; }
        }

        /// <summary>
        /// Gets or sets the selection as list for UI (table) purposes.
        /// </summary>
        /// <value>
        /// The selection as list.
        /// </value>
        [XmlIgnore]
        [PropertyOrder(1, 2)]
        public string SelectionAsString
        {
            get
            {
                string res = "";
                foreach (var sensor in sensors)
                {
                    res = res + sensor.ID + "; ";
                }
                return res;
            }
            set
            {
                ClearSelection();
                var locSensors = ParseStringToSensorIDs(value);
                if (pickSensors != null)
                {
                    foreach (var sensorID in locSensors)
                    {
                        var sensor = PickSensors.Find(x => x.ID == sensorID);
                        if (sensor != null)
                        {
                            Add(sensor);
                        }
                    }
                }
            }
        }

        private List<int> ParseStringToSensorIDs(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>
        /// Persistable sensor array. Only for internal use
        /// </summary>
        [Browsable(false)]
        public Sensor[] SensorArray
        {
            get { return sensors.ToArray(); }
            set { 
                ClearSelection();
                foreach (var sensor in value)
                {
                    Add(sensor);
                }
            }
        }

        /// <summary>
        /// Gets the sensor count.
        /// </summary>
        [Browsable(false)]
        public int SensorCount
        {
            get { return sensors.Count; }
        }

        [XmlIgnore]
        [Browsable(false)]
        public IEnumerable<KeyValuePair<Sensor, double>> SensorRelativeLocations
        {
            get { return relativeLocationAlongProfileDictionary; }
        }

        [XmlIgnore]
        [ReadOnly(true)]
        public List<Sensor> PickSensors
        {
            get { return pickSensors; }
            set { pickSensors = value; }
        }

        /// <summary>
        /// Determines whether this instance is valid.
        /// </summary>
        /// <returns></returns>
        public bool IsValid()
        {
            IEnumerable<ValidationResult> validationResults = Validator.Validate(this);
            return !validationResults.Any();
        }

        /// <summary>
        /// Determines whether this instance is transient (associated with an invalid ID).
        /// </summary>
        /// <returns>
        ///   <c>true</c> if this instance is transient; otherwise, <c>false</c>.
        /// </returns>
        public bool IsTransient()
        {
            return ID <= 0;
        }

        /// <summary>
        /// Sets the relative location.
        /// </summary>
        /// <param name="sensor">The sensor.</param>
        /// <param name="value">The value.</param>
        public void SetRelativeLocation(Sensor sensor, double value)
        {
            relativeLocationAlongProfileDictionary[sensor] = value;
        }

        /// <summary>
        /// Adds the specified sensor to the selected sensor list for this group.
        /// </summary>
        /// <param name="sensor">The sensor to add.</param>
        public void Add(Sensor sensor)
        {
            sensors.Add(sensor);
            if (!relativeLocationAlongProfileDictionary.ContainsKey(sensor))
                relativeLocationAlongProfileDictionary.Add(sensor, 0);

        }

        /// <summary>
        /// Removes the specified sensor from the selected sensor list from this group.
        /// </summary>
        /// <param name="sensor">The sensor to remove.</param>
        public void Remove(Sensor sensor)
        {
            sensors.Remove(sensor);
            if (relativeLocationAlongProfileDictionary.ContainsKey(sensor))
                relativeLocationAlongProfileDictionary.Remove(sensor);
        }

        /// <summary>
        /// Clears the sensor selection
        /// </summary>
        public void ClearSelection()
        {
            sensors.Clear();
            relativeLocationAlongProfileDictionary.Clear();
        }

        public string Serialize()
        {
            return new XmlSerializer().SerializeToString(this);
        }

        public static Group Deserialize(string xml)
        {
            return (Group)new XmlDeserializer().XmlDeserializeFromString(xml, typeof(Group));
        }

        public override string ToString()
        {
            return ID.ToString();
        }
    }
}