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

namespace Deltares.DamEngine.Data.General.Sensors
{
    /// <summary>
    /// Class for sensor group
    /// </summary>
    public class SensorGroup
    {
        /// <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;

        /// <summary>
        /// Initializes a new instance of the <see cref="SensorGroup"/> class.
        /// </summary>
        public SensorGroup()
        {
            sensors = new HashSet<Sensor>();
            relativeLocationAlongProfileDictionary = new Dictionary<Sensor, double>();
            ID = -1;            
        }

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

        /// <summary>
        /// Gets the selected sensors.
        /// </summary>
        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>
        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>
        public Sensor[] SensorArray
        {
            get { return sensors.ToArray(); }
            set { 
                ClearSelection();
                foreach (var sensor in value)
                {
                    Add(sensor);
                }
            }
        }

        /// <summary>
        /// Gets the sensor count.
        /// </summary>
        public int SensorCount
        {
            get { return sensors.Count; }
        }

        /// <summary>
        /// Gets the sensor relative locations.
        /// </summary>
        /// <value>
        /// The sensor relative locations.
        /// </value>
        public IEnumerable<KeyValuePair<Sensor, double>> SensorRelativeLocations
        {
            get { return relativeLocationAlongProfileDictionary; }
        }

        /// <summary>
        /// Gets or sets the pick sensors.
        /// </summary>
        /// <value>
        /// The pick sensors.
        /// </value>
        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>
        /// Adds the specified sensor to the selected sensor list for this sensorGroup.
        /// </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 sensorGroup.
        /// </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();
        }

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