// 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.Collections.Generic;

namespace Deltares.DamEngine.Data.Geometry;

/// <summary>
/// Represents the possible directions of the curve
/// </summary>
public enum CurveDirection
{
    /// <summary>
    /// Forward as direction
    /// </summary>
    Forward = 0,

    /// <summary>
    /// Reverse as direction
    /// </summary>
    Reverse = 1
}

/// <summary>
/// Contains the collection of all the curves data.
/// </summary>
public class GeometryCurve : GeometryObject
{
    private Point2D endPoint;
    private Point2D headPoint;

    /// <summary>
    /// Initializes a new instance of the <see cref="GeometryCurve"/> class.
    /// </summary>
    public GeometryCurve() {}

    /// <summary>
    /// Initializes a new instance of the <see cref="GeometryCurve"/> class.
    /// </summary>
    /// <param name="headPoint">The head point.</param>
    /// <param name="endPoint">The end point.</param>
    public GeometryCurve(Point2D headPoint, Point2D endPoint)
    {
        this.headPoint = headPoint;
        this.endPoint = endPoint;
    }

    /// <summary>
    /// The unique name of the object.
    /// </summary>
    public override string Name
    {
        get
        {
            if (!string.IsNullOrEmpty(base.Name))
            {
                return base.Name;
            }

            var text = "";
            if (HeadPoint != null)
            {
                text += HeadPoint.ToString()?.Trim();
            }

            text += "-";
            if (EndPoint != null)
            {
                text += EndPoint.ToString()?.Trim();
            }

            base.Name = text;
            return base.Name;
        }
        set => base.Name = value;
    }

    /// <summary>
    /// Gets or sets the head point of the curve.
    /// </summary>
    public virtual Point2D HeadPoint
    {
        get => headPoint;
        set => headPoint = value;
    }

    /// <summary>
    /// Gets or sets the end point of the curve.
    /// </summary>
    public virtual Point2D EndPoint
    {
        get => endPoint;
        set => endPoint = value;
    }

    /// <summary>
    /// Gets or sets the surface at the Left.
    /// </summary>
    public virtual GeometrySurface SurfaceAtLeft { get; set; }

    /// <summary>
    /// Gets or sets the surface at the Right.
    /// </summary>
    public virtual GeometrySurface SurfaceAtRight { get; set; }

    /// <summary>
    /// Locations the equals.
    /// </summary>
    /// <param name="aCurve">a curve.</param>
    /// <returns></returns>
    public bool LocationEquals(GeometryCurve aCurve)
    {
        return (headPoint.LocationEquals(aCurve.HeadPoint) && endPoint.LocationEquals(aCurve.EndPoint)) ||
               (headPoint.LocationEquals(aCurve.EndPoint) && endPoint.LocationEquals(aCurve.HeadPoint));
    }

    /// <summary>
    /// Swaps <see cref="HeadPoint"/> and <see cref="EndPoint"/>.
    /// </summary>
    public void Reverse()
    {
        (HeadPoint, EndPoint) = (EndPoint, HeadPoint);
    }

    /// <summary>
    /// Returns the head point in given direction
    /// </summary>
    /// <param name="aDirection">Direction is either Forward or Reverse or Unknown</param>
    /// <returns>Returns the head point in the given direction</returns>
    public Point2D GetHeadPoint(CurveDirection aDirection)
    {
        return aDirection == CurveDirection.Forward ? headPoint : endPoint;
    }

    /// <summary>
    /// Gets the end point in the given direction
    /// </summary>
    /// <param name="aDirection">Direction is either Forward or Reverse or Unknown</param>
    /// <returns>Returns the end point in the given direction</returns>
    public Point2D GetEndPoint(CurveDirection aDirection)
    {
        return aDirection == CurveDirection.Forward ? endPoint : headPoint;
    }

    /// <summary>
    /// Determines whether the curve contains the specified point within the given tolerance.
    /// </summary>
    /// <param name="point">The point.</param>
    /// <param name="tolerance">The tolerance.</param>
    /// <returns></returns>
    public bool ContainsPoint(Point2D point, double tolerance = GeometryConstants.Accuracy * 0.5)
    {
        return HeadPoint != null && EndPoint != null &&
               Routines2D.DoesPointExistInLine(HeadPoint, EndPoint, point, tolerance);
    }

    /// <summary>
    /// Assigns the surfaces from the curve.
    /// </summary>
    /// <param name="aCurve"></param>
    public void AssignSurfacesFromCurve(GeometryCurve aCurve)
    {
        if (aCurve.SurfaceAtLeft != SurfaceAtLeft)
        {
            SurfaceAtLeft = aCurve.SurfaceAtLeft;
        }

        if (aCurve.SurfaceAtRight != SurfaceAtRight)
        {
            SurfaceAtRight = aCurve.SurfaceAtRight;
        }
    }

    /// <summary>
    /// Clones the curve.
    /// </summary>
    /// <returns>Returns a clone</returns>
    public GeometryCurve Clone(List<Point2D> points)
    {
        Point2D clonedHeadPoint = points.Find(p => p.LocationEquals(HeadPoint));
        Point2D clonedEndPoint = points.Find(p => p.LocationEquals(EndPoint));
        var curve = new GeometryCurve(clonedHeadPoint, clonedEndPoint)
        {
            Name = Name
        };

        return curve;
    }

    /// <summary>
    /// Gets the geometry bounds.
    /// </summary>
    /// <returns></returns>
    public override GeometryBounds GetGeometryBounds()
    {
        if (HeadPoint != null && EndPoint != null)
        {
            var head = new GeometryBounds(HeadPoint.X, HeadPoint.X, HeadPoint.Z, HeadPoint.Z);
            var end = new GeometryBounds(EndPoint.X, EndPoint.X, EndPoint.Z, EndPoint.Z);
            return head + end;
        }

        return null;
    }

    /// <summary>
    /// Returns a string that represents the current object.
    /// </summary>
    /// <returns>
    /// A string that represents the current object.
    /// </returns>
    /// <filterpriority>2</filterpriority>
    public override string ToString()
    {
        return string.Empty;
    }
}