// Copyright (C) Stichting Deltares 2024. 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;
using System.Collections.Generic;
using System.Linq;
using Deltares.DamEngine.Data.Geometry;

namespace Deltares.DamEngine.Data.Geotechnics;

/// <summary>
/// Represents a meta-data set of <see cref="CharacteristicPoint"/> instances that describe
/// special point-locations of a geometric surfaceline.
/// </summary>
public class CharacteristicPointSet : IList<CharacteristicPoint>, IList
{
    private readonly List<CharacteristicPoint> annotations;
    private readonly Dictionary<CharacteristicPointType, Point2D> typeCache;
    private GeometryPointString geometry;
    private bool geometryMustContainPoint;

    /// <summary>
    /// Creates a characteristic point set whose points act as meta data for a geometric 
    /// description (<see cref="GeometryMustContainPoint"/> false) of a surfaceline.
    /// </summary>
    public CharacteristicPointSet()
    {
        typeCache = new Dictionary<CharacteristicPointType, Point2D>();
        annotations = new List<CharacteristicPoint>();
        geometryMustContainPoint = false;
    }

    /// <summary>
    /// The observed localized geometry point string, describing the dike surfaceline
    /// shape.
    /// </summary>
    /// <remarks>References by aggregation.</remarks>
    public GeometryPointString Geometry
    {
        get
        {
            return geometry;
        }
        set
        {
            geometry = value;

            FullSyncWithGeometry();
        }
    }

    /// <summary>
    /// <para>When true, requires all <see cref="GeometryPoint"/> instances part of 
    /// this set to be contained in <see cref="Geometry"/> and cannot have instances 
    /// not part of <see cref="Geometry"/>.</para> 
    /// <para>When false, all <see cref="GeometryPoint"/> instances are required NOT 
    /// to be part of <see cref="Geometry"/>. Their height will then be determined by 
    /// the height profile defined by <see cref="Geometry"/>.</para>
    /// </summary>
    public bool GeometryMustContainPoint
    {
        get
        {
            return geometryMustContainPoint;
        }
        set
        {
            geometryMustContainPoint = value;

            FullSyncWithGeometry();
        }
    }

    /// <summary>
    /// Retrieves the <see cref="GeometryPoint"/> annotated with the given type.
    /// </summary>
    /// <param name="characteristicPointType">Annotation to look for.</param>
    /// <returns>The <see cref="GeometryPoint"/> instances annotated with the given type;
    /// Null if no definition can be found.</returns>
    /// <remarks>This method relies on this class observing changes to its <see cref="CharacteristicPoint"/>
    /// to work correctly.</remarks>
    public Point2D GetPoint2D(CharacteristicPointType characteristicPointType)
    {
        return typeCache.ContainsKey(characteristicPointType)
                   ? typeCache[characteristicPointType]
                   : null;
    }

    /// <summary>
    /// Sorts this characteristic point set items on <see cref="CharacteristicPoint.X"/>
    /// ascending. If <see cref="GeometryMustContainPoint"/> is true, <see cref="Geometry"/>
    /// shall also be sorted.
    /// </summary>
    public void Sort()
    {
        if (GeometryMustContainPoint && Geometry != null)
        {
            Geometry.SortPointsByXAscending();
        }

        annotations.Sort();
    }

    /// <summary>
    /// Annotates the characteristic point at the specified index.
    /// </summary>
    /// <param name="index">The index.</param>
    /// <param name="characteristicPointType">The new type of the characteristic point.</param>
    /// <exception cref="ArgumentOutOfRangeException">When <paramref name="index"/> is
    /// less then 0 or greater or equal to <see cref="Count"/>.</exception>
    /// <see cref="GetPoint2D"/> will be returning the correct points.
    public void Annotate(int index, CharacteristicPointType characteristicPointType)
    {
        annotations[index].CharacteristicPointType = characteristicPointType;
        UpdateTypeCache(annotations[index]);
    }

    /// <summary>
    /// Snaps the characteristic point height to <see cref="Geometry"/> if it's not part
    /// of it, or set it to <see cref="double.NaN"/> in case no <see cref="Geometry"/>
    /// is available.
    /// </summary>
    /// <param name="characteristicPoint">The characteristic point whose height is to be updated.</param>
    private void UpdateCharacteristicPointHeight(CharacteristicPoint characteristicPoint)
    {
        if (geometry == null)
        {
            characteristicPoint.Point.Z = double.NaN;
        }
        else if (!geometry.Points.Contains(characteristicPoint.Point))
        {
            if (double.IsNaN(characteristicPoint.Point.X))
            {
                characteristicPoint.Point.Z = double.NaN;
            }
            else
            {
                // Note: Cannot use GeometryPointString.GetZAtX due to its requirement
                // that Geometry.Points is sorted on X.
                characteristicPoint.Point.Z = geometry.GetZAtUnsortedX(characteristicPoint.Point.X);
            }
        }
        // Else: Keep Z the same as in Geometry
    }

    private void FullSyncWithGeometry()
    {
        if (GeometryMustContainPoint)
        {
            // Resync with geometry; Do not keep previous data:
            ClearCharacteristicPointSet();

            if (geometry == null)
            {
                return;
            }

            foreach (Point2D point in geometry.Points)
            {
                Add(new CharacteristicPoint
                {
                    Point = point,
                    CharacteristicPointType = CharacteristicPointType.None
                });
            }
        }
        else
        {
            // Remove all characteristic points whose GeometryPoint are part of Geometry
            // as per required by the value of GeometryMustContainPoint. All other
            // characteristic points should have their height updated:
            foreach (CharacteristicPoint characteristicPoint in annotations.ToArray())
            {
                if (geometry != null && geometry.Points.Contains(characteristicPoint.Point))
                {
                    Remove(characteristicPoint);
                }
                else
                {
                    UpdateCharacteristicPointHeight(characteristicPoint);
                }
            }
        }
    }

    private void ClearCharacteristicPointSet()
    {
        ClearAnnotations();
        typeCache.Clear();
    }

    private void ClearAnnotations()
    {
        annotations.Clear();
    }

    private void UpdateTypeCache(CharacteristicPoint item)
    {
        if (item.CharacteristicPointType != CharacteristicPointType.None)
        {
            // Prevent duplication:
            CharacteristicPoint alreadyDefined = annotations.FirstOrDefault(cp => cp.CharacteristicPointType == item.CharacteristicPointType &&
                                                                                  !ReferenceEquals(cp.Point, item.Point));
            if (alreadyDefined != null)
            {
                alreadyDefined.CharacteristicPointType = CharacteristicPointType.None;
            }

            // Set new annotation definition:
            typeCache[item.CharacteristicPointType] = item.Point;
        }
    }

    #region Implementation: IList<CharacteristicPoint>, IList

    /// <summary>
    /// Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection" />.
    /// </summary>
    public object SyncRoot { get; } = new object();

    /// <summary>
    /// Gets a value indicating whether access to the <see cref="T:System.Collections.ICollection" /> is synchronized (thread safe).
    /// </summary>
    public bool IsSynchronized
    {
        get
        {
            return false;
        }
    }

    /// <summary>
    /// Gets a value indicating whether the <see cref="T:System.Collections.IList" /> has a fixed size.
    /// </summary>
    public bool IsFixedSize
    {
        get
        {
            return false;
        }
    }

    /// <summary>
    /// Gets or sets the element at the specified index.
    /// </summary>
    /// <param name="index">The index.</param>
    /// <returns></returns>
    object IList.this[int index]
    {
        get
        {
            return this[index];
        }
        set
        {
            this[index] = (CharacteristicPoint) value;
        }
    }

    /// <summary>
    /// Gets the number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1" />.
    /// </summary>
    public int Count
    {
        get
        {
            return annotations.Count;
        }
    }

    /// <summary>
    /// Gets a value indicating whether the <see cref="T:System.Collections.Generic.ICollection`1" /> is read-only.
    /// </summary>
    public bool IsReadOnly
    {
        get
        {
            return false;
        }
    }

    /// <summary>
    /// Gets or sets the element at the specified index.
    /// </summary>
    /// <param name="index">The index.</param>
    /// <returns></returns>
    public CharacteristicPoint this[int index]
    {
        get
        {
            return annotations[index];
        }
        set
        {
            RemoveAt(index);
            Insert(index, value);
        }
    }

    /// <summary>
    /// Adds an item to the <see cref="T:System.Collections.IList" />.
    /// </summary>
    /// <param name="value">The object to add to the <see cref="T:System.Collections.IList" />.</param>
    /// <returns>
    /// The position into which the new element was inserted, or -1 to indicate that the item was not inserted into the collection,
    /// </returns>
    public int Add(object value)
    {
        Add((CharacteristicPoint) value);
        return Count - 1;
    }

    /// <summary>
    /// Determines whether the <see cref="T:System.Collections.IList" /> contains a specific value.
    /// </summary>
    /// <param name="value">The object to locate in the <see cref="T:System.Collections.IList" />.</param>
    /// <returns>
    /// true if the <see cref="T:System.Object" /> is found in the <see cref="T:System.Collections.IList" />; otherwise, false.
    /// </returns>
    public bool Contains(object value)
    {
        var cp = value as CharacteristicPoint;
        if (cp == null)
        {
            return false;
        }

        return Contains(cp);
    }

    /// <summary>
    /// Copies the elements of the <see cref="T:System.Collections.ICollection" /> to an <see cref="T:System.Array" />, starting at a particular <see cref="T:System.Array" /> index.
    /// </summary>
    /// <param name="array">The one-dimensional <see cref="T:System.Array" /> that is the destination of the elements copied from <see cref="T:System.Collections.ICollection" />. The <see cref="T:System.Array" /> must have zero-based indexing.</param>
    /// <param name="index">The zero-based index in <paramref name="array" /> at which copying begins.</param>
    public void CopyTo(Array array, int index)
    {
        CopyTo((CharacteristicPoint[]) array, index);
    }

    /// <summary>
    /// Determines the index of a specific item in the <see cref="T:System.Collections.IList" />.
    /// </summary>
    /// <param name="value">The object to locate in the <see cref="T:System.Collections.IList" />.</param>
    /// <returns>
    /// The index of <paramref name="value" /> if found in the list; otherwise, -1.
    /// </returns>
    public int IndexOf(object value)
    {
        return IndexOf((CharacteristicPoint) value);
    }

    /// <summary>
    /// Inserts an item to the <see cref="T:System.Collections.IList" /> at the specified index.
    /// </summary>
    /// <param name="index">The zero-based index at which <paramref name="value" /> should be inserted.</param>
    /// <param name="value">The object to insert into the <see cref="T:System.Collections.IList" />.</param>
    public void Insert(int index, object value)
    {
        Insert(index, (CharacteristicPoint) value);
    }

    /// <summary>
    /// Removes the first occurrence of a specific object from the <see cref="T:System.Collections.IList" />.
    /// </summary>
    /// <param name="value">The object to remove from the <see cref="T:System.Collections.IList" />.</param>
    public void Remove(object value)
    {
        Remove((CharacteristicPoint) value);
    }

    /// <summary>
    /// Removes the first occurrence of a specific object from the <see cref="T:System.Collections.Generic.ICollection`1" />.
    /// </summary>
    /// <param name="item">The object to remove from the <see cref="T:System.Collections.Generic.ICollection`1" />.</param>
    /// <returns>
    /// true if <paramref name="item" /> was successfully removed from the <see cref="T:System.Collections.Generic.ICollection`1" />; otherwise, false. This method also returns false if <paramref name="item" /> is not found in the original <see cref="T:System.Collections.Generic.ICollection`1" />.
    /// </returns>
    public bool Remove(CharacteristicPoint item)
    {
        bool removed = PerformCollectionRemoveWithEvents(annotations, item);

        if (removed)
        {
            typeCache.Remove(item.CharacteristicPointType);

            bool removeGeometryPoint = GeometryMustContainPoint && Geometry != null &&
                                       Geometry.Points.Contains(item.Point) &&
                                       !annotations.Any(cp => ReferenceEquals(cp.Point, item.Point));

            if (removeGeometryPoint)
            {
                PerformCollectionRemoveWithEvents(Geometry.Points, item.Point);
            }
        }

        return removed;
    }

    /// <summary>
    /// Adds an item to the <see cref="T:System.Collections.Generic.ICollection`1" />.
    /// </summary>
    /// <param name="item">The object to add to the <see cref="T:System.Collections.Generic.ICollection`1" />.</param>
    public void Add(CharacteristicPoint item)
    {
        Insert(Count, item);
    }

    /// <summary>
    /// Removes all items from the <see cref="T:System.Collections.Generic.ICollection`1" />.
    /// </summary>
    public void Clear()
    {
        ClearCharacteristicPointSet();

        if (GeometryMustContainPoint && Geometry != null)
        {
            Geometry.Points.Clear();
        }
    }

    /// <summary>
    /// Determines whether the <see cref="T:System.Collections.Generic.ICollection`1" /> contains a specific value.
    /// </summary>
    /// <param name="item">The object to locate in the <see cref="T:System.Collections.Generic.ICollection`1" />.</param>
    /// <returns>
    /// true if <paramref name="item" /> is found in the <see cref="T:System.Collections.Generic.ICollection`1" />; otherwise, false.
    /// </returns>
    public bool Contains(CharacteristicPoint item)
    {
        return annotations.Contains(item);
    }

    /// <summary>
    /// Copies to.
    /// </summary>
    /// <param name="array">The array.</param>
    /// <param name="arrayIndex">Index of the array.</param>
    public void CopyTo(CharacteristicPoint[] array, int arrayIndex)
    {
        annotations.CopyTo(array, arrayIndex);
    }

    /// <summary>
    /// Determines the index of a specific item in the <see cref="T:System.Collections.Generic.IList`1" />.
    /// </summary>
    /// <param name="item">The object to locate in the <see cref="T:System.Collections.Generic.IList`1" />.</param>
    /// <returns>
    /// The index of <paramref name="item" /> if found in the list; otherwise, -1.
    /// </returns>
    public int IndexOf(CharacteristicPoint item)
    {
        return annotations.IndexOf(item);
    }

    /// <summary>
    /// Inserts an item to the <see cref="T:System.Collections.Generic.IList`1" /> at the specified index.
    /// </summary>
    /// <param name="index">The zero-based index at which <paramref name="item" /> should be inserted.</param>
    /// <param name="item">The object to insert into the <see cref="T:System.Collections.Generic.IList`1" />.</param>
    public void Insert(int index, CharacteristicPoint item)
    {
        if (!ReferenceEquals(item.PointSet, this))
        {
            item.PointSet = this;
        }

        Point2D itemAtIndex = index < annotations.Count ? annotations[index].Point : null;
        PerformListInsertWithEvents(annotations, item, index);
        if (GeometryMustContainPoint && Geometry != null && !Geometry.Points.Contains(item.Point))
        {
            int geometryIndex = Geometry.Points.Count;
            if (null != itemAtIndex)
            {
                for (var i = 0; i < Geometry.Points.Count; i++)
                {
                    if (ReferenceEquals(Geometry.Points[i], itemAtIndex))
                    {
                        geometryIndex = i;
                        break;
                    }
                }
            }

            // Check if point at same position already exists and set that point to the existing point
            // Do this to avoid points in Surfaceline.Geometry with the same location
            var IsPointExist = false;
            for (var i = 0; i < Geometry.Points.Count; i++)
            {
                if (Geometry.Points[i].LocationEquals(item.Point))
                {
                    item.Point = Geometry.Points[i];
                    IsPointExist = true;
                    break;
                }
            }

            if (!IsPointExist)
            {
                // Only add new point if no point on same location was found
                PerformListInsertWithEvents(Geometry.Points, item.Point, geometryIndex);
            }
        }

        if (geometry != null)
        {
            UpdateCharacteristicPointHeight(item);
        }

        UpdateTypeCache(item);
    }

    /// <summary>
    /// Removes the <see cref="T:System.Collections.Generic.IList`1" /> item at the specified index.
    /// </summary>
    /// <param name="index">The zero-based index of the item to remove.</param>
    public void RemoveAt(int index)
    {
        Remove(annotations[index]);
    }

    /// <summary>
    /// Returns an enumerator that iterates through a collection.
    /// </summary>
    /// <returns>
    /// An <see cref="T:System.Collections.IEnumerator" /> object that can be used to iterate through the collection.
    /// </returns>
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    /// <summary>
    /// Returns an enumerator that iterates through the collection.
    /// </summary>
    /// <returns>
    /// A <see cref="T:System.Collections.Generic.IEnumerator`1" /> that can be used to iterate through the collection.
    /// </returns>
    public IEnumerator<CharacteristicPoint> GetEnumerator()
    {
        return annotations.GetEnumerator();
    }

    #endregion

    #region Events

    /// <summary>
    /// </summary>
    /// <typeparam name="T">Type of the list elements.</typeparam>
    /// <param name="list">The list where the item is inserted into.</param>
    /// <param name="item">The item inserted into the list.</param>
    /// <param name="index">Index where the item is inserted.</param>
    private static void PerformListInsertWithEvents<T>(IList<T> list, T item, int index)
    {
        list.Insert(index, item);
    }

    private static bool PerformCollectionRemoveWithEvents<T>(ICollection<T> list, T item)
    {
        bool removed = list.Remove(item);

        return removed;
    }

    #endregion
}