// Copyright (C) Stichting Deltares 2021. 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.

namespace Deltares.DamEngine.Data.Geometry
{
    /// <summary>
    /// Represents the possible directions of the curve
    /// </summary>
    public enum CurveDirection
    {
        /// <summary>
        /// Unknown as direction
        /// </summary>
        Unknown = -1,
        /// <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>
        /// Gets or sets the head point of the curve.
        /// </summary>
        public virtual Point2D HeadPoint
        {
            get
            {
                return headPoint;
            }
            set
            {
                headPoint = value;
            }
        }

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

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

                string text = "";
                if (HeadPoint != null)
                {
                    text += HeadPoint.ToString().Trim();
                }
                text += "-";
                if (EndPoint != null)
                {
                    text += EndPoint.ToString().Trim();
                }
                return text;
            }
            set
            {
                base.Name = value;
            }
        }

        /// <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()
        {
            var point = HeadPoint;
            HeadPoint = EndPoint;
            EndPoint = point;            
        }

        /// <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)
        {
            if (aDirection == CurveDirection.Forward)
            {
                return headPoint;
            }

            return 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)
        {
            if (aDirection == CurveDirection.Forward)
            {
                return endPoint;
            }

            return headPoint;
        }
        
        /// <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>
        /// 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>
        /// 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;
        }

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

    }
}