// Copyright (C) Stichting Deltares 2025. All rights reserved.
// 
// This file is part of the application DAM - UI.
// 
// DAM - UI is free software: you can redistribute it and/or modify
// it under the terms of the GNU 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 General Public License for more details.
// 
// You should have received a copy of the GNU 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.ComponentModel;
using System.Linq;
using System.Xml.Serialization;
using Deltares.Dam.Data.Specifications;
using Deltares.Standard.Attributes;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.IO.Xml;
using Deltares.Standard.Specifications;
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;

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

    private List<Sensor> pickSensors;
    private int id;

    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
        {
            var res = "";
            foreach (Sensor sensor in sensors)
            {
                res = res + sensor.ID + "; ";
            }

            return res;
        }
        set
        {
            ClearSelection();
            List<int> locSensors = ParseStringToSensorIDs(value);
            if (pickSensors != null)
            {
                foreach (int sensorID in locSensors)
                {
                    Sensor sensor = PickSensors.Find(x => x.ID == sensorID);
                    if (sensor != null)
                    {
                        Add(sensor);
                    }
                }
            }
        }
    }

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

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

        return ids;
    }
}