// Copyright (C) Stichting Deltares 2026. 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.Standard;
using Deltares.Standard.Attributes;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.IO.Xml;
using Deltares.Standard.Specifications;
using NetTopologySuite.Geometries;
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
{
    private readonly NetTopologySuite.Geometries.Geometry geometry;
    private readonly HashSet<PLLineType> plLineTypes;
    private double relativeLocation;
    private int id;

    private SensorType type;

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

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

    /// <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 (PLLineType lineType in value)
            {
                Add(lineType);
            }
        }
    }

    [XmlIgnore]
    [PropertyOrder(1, 6)]
    public string PLLineMappingsAsString
    {
        get
        {
            var res = "";
            foreach (PLLineType 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();
            List<int> locPlLineTypes = ParseStringToPlLineTypes(value);
            foreach (int 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;
                }
            }
        }
    }

    /// <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>
    /// 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()
    {
        string name = string.IsNullOrWhiteSpace(Name) ? "name_not_set" : Name;

        return $"[ID: {ID}, Name: {name}, Depth: {Depth}, Type: {Type}, RelativeLocation: {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;
    }

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

    private List<int> ParseStringToPlLineTypes(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;
    }

    #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
}