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

namespace Deltares.DamEngine.Data.Geotechnics
{
    /// <summary>
    /// <summary>
    /// A SoilSurfaceProfile constructs a SoilProfile2D object by merging an existing SoilProfile1D with a SurfaceLine
    /// </summary>
    /// Note that actual contruction of 2D based on surface line and 1D happens on setting the properties using dirty flags.
    /// </summary>
    public class SoilSurfaceProfile : SoilProfile2D
    {
        private Soil dikeEmbankmentMaterial;
        private SoilProfile1D soilProfile;
        private SoilProfile1D originalSoilProfile1D;
        private SurfaceLine2 surfaceLine2;
        
        /// <summary>
        /// Initializes a new instance of the <see cref="SoilSurfaceProfile"/> class.
        /// </summary>
        public SoilSurfaceProfile()
        {
            base.Name = "Soil Surface Profile";
        }

        /// <summary>
        /// Gets or sets the surface line2.
        /// </summary>
        [Validate]
        public SurfaceLine2 SurfaceLine2
        {
            get
            {
                return surfaceLine2;
            }
            set
            {
                surfaceLine2 = value;
            }
        }

        /// <summary>
        /// Gets or sets the soil profile.
        /// </summary>
        /// <value>
        /// The soil profile.
        /// </value>
        [Validate]
        public SoilProfile1D SoilProfile
        {
            get
            {
                return originalSoilProfile1D;
            }
            set
            {
                originalSoilProfile1D = value;
            }
        }

        /// <summary>
        /// Gets or sets the dike material.
        /// </summary>
        /// <value>
        /// The dike material.
        /// </value>
        public Soil DikeEmbankmentMaterial
        {
            get
            {
                return dikeEmbankmentMaterial;
            }
            set
            {
                dikeEmbankmentMaterial = value;
            }
        }

        /// <summary>
        /// Returns a <see cref="System.String" /> that represents this instance (either Name or SoilProfile1D).
        /// </summary>
        /// <returns>
        /// A <see cref="System.String" /> that represents this instance.
        /// </returns>
        public override string ToString()
        {
            if (!string.IsNullOrEmpty(Name))
            {
                return Name;
            }
            if (originalSoilProfile1D != null)
            {
                return originalSoilProfile1D.ToString();
            }
            return "Soil Surface Profile with null Soil Profile";
        }

        /// <summary>
        /// Converts to soil profile2D.
        /// </summary>
        /// <returns></returns>
        public SoilProfile2D ConvertToSoilProfile2D()
        {
            // Generate the geometry for the new 2D profile
            Create2DGeometryBasedOn1DProfileAndSurfaceLine();

            // Create the actual new 2D profile
            var soilProfile2D = new SoilProfile2D
            {
                Geometry = Geometry
            };
            soilProfile2D.Surfaces.AddRange(Surfaces);
            soilProfile2D.Name = Name;
            return soilProfile2D;

        }

        /// <summary>
        /// Function to create and update the <see cref="Geometry"/>, <see cref="SoilProfile2D.Surfaces"/>
        /// based on a 1D profile and a surface line.
        /// </summary>
        private void Create2DGeometryBasedOn1DProfileAndSurfaceLine()
        {
            var filteredSoilLayers = FilterSoilLayersToConvert(originalSoilProfile1D, surfaceLine2);

            var localSurfaceLinePoints = GetLocalSurfaceLinePoints(filteredSoilLayers, surfaceLine2);
            var layerData = CreateLayerData(filteredSoilLayers, localSurfaceLinePoints);
            var filteredLayerData = FilterLayerDataWithClosedLoops(layerData);

            BuildGeometryModel(Geometry, filteredLayerData, originalSoilProfile1D, surfaceLine2, localSurfaceLinePoints);
            AssignSoilLayer2DProperties(Surfaces, filteredLayerData, Geometry);
        }

        private static void BuildGeometryModel(GeometryData geometryData, 
            IEnumerable<LayerData> layers, 
            SoilProfile1D profile, 
            SurfaceLine2 surfaceLine, 
            IEnumerable<Point2D> localSurfaceLinePoints)
        {
            if (surfaceLine.Geometry == null
                || profile == null
                || profile.Layers.Count == 0
                || surfaceLine.Geometry.GetMaxZ() < profile.BottomLevel
                || surfaceLine.Geometry.Points.Count < 2)
            {
                return;
            }

            GeometryBounds bounds = surfaceLine.Geometry.GetGeometryBounds();
            double minX = bounds.Left;
            double maxX = bounds.Right;

            geometryData.Clear();
            geometryData.Left = minX;
            geometryData.Right = maxX;
            geometryData.Bottom = Math.Min(profile.BottomLevel, surfaceLine.Geometry.GetMinZ() - 1);

            var localSurfaceLineCurves = GenerateCurves(localSurfaceLinePoints.ToArray());

            var pointsToBeAdded = layers.SelectMany(l => l.Points)
                .Concat(localSurfaceLinePoints);
            var curvesToBeAdded = layers.SelectMany(l => l.Curves)
                .Concat(localSurfaceLineCurves);
            geometryData.NewlyEffectedPoints.AddRange(pointsToBeAdded);
            geometryData.NewlyEffectedCurves.AddRange(curvesToBeAdded);
            geometryData.RegenerateGeometry();
        }

        private static void AssignSoilLayer2DProperties(ICollection<SoilLayer2D> surfaces, 
            IEnumerable<LayerData> layers,
            GeometryData geometryData)
        {
            surfaces.Clear();

            foreach (GeometrySurface surface in geometryData.Surfaces)
            {
                GeometryBounds bounds = surface.GetGeometryBounds();
                double z = (bounds.Top + bounds.Bottom) * 0.5;

                // Get the corresponding layer data. This assumption only holds
                // because each z coordinate contains ONE single layer definition.
                LayerData layerData = layers.FirstOrDefault(l => l.IsZLocatedInLayer(z));
                if (layerData != null)
                {
                    surfaces.Add(new SoilLayer2D
                    {
                        GeometrySurface = surface,
                        IsAquifer = layerData.IsAquifer,
                        WaterpressureInterpolationModel = layerData.WaterpressureInterpolationModel,
                        Soil = layerData.Soil
                    });
                }
            }
        }

        /// <summary>
        /// Gets the collection of <see cref="SoilLayer1D"/> to convert based on the input arguments.
        /// </summary>
        /// <param name="profile">The <see cref="SoilProfile1D"/> to retrieve the layers for.</param>
        /// <param name="surfaceLine">The surface line.</param>
        /// <returns>The collection of <see cref="SoilLayer1D"/> to convert.</returns>
        private IEnumerable<SoilLayer1D> FilterSoilLayersToConvert(SoilProfile1D profile, SurfaceLine2 surfaceLine)
        {
            // Make a copy of the soil profile to prevent modifications of the reference argument.
            // The clone method does not copy the properties of the WaterPressureInterpolationModel
            // and the IsAquiferProperties properly, so these need to be set manually
            var copiedSoilProfile = (SoilProfile1D)profile.Clone();
            var soilLayers = copiedSoilProfile.Layers;
            for (int i = 0; i < soilLayers.Count; i++)
            {
                CopyLayerProperties(soilLayers[i], profile.Layers[i]);
            }

            double maxZCoordinateSurfaceLine = surfaceLine.Geometry.GetMaxZ();
            
            // Create an artificial top layer based on the dike embankment material in case the top of the highest soil layer
            // lies below the maximum coordinate of the surface line.
            double maxZCoordinateLayers = soilLayers.Select(l => l.TopLevel).Max();
            if (maxZCoordinateLayers < maxZCoordinateSurfaceLine)
            {
                soilLayers.Insert(0, new SoilLayer1D(DikeEmbankmentMaterial, maxZCoordinateSurfaceLine)
                {
                    WaterpressureInterpolationModel = WaterpressureInterpolationModel.Hydrostatic
                });
            }

            copiedSoilProfile.EnsureLastLayerHasHeight();
            
            return copiedSoilProfile.Layers.Where(l => !IsLayerAboveSurfaceLine(l, surfaceLine));
        }

        private static void CopyLayerProperties(SoilLayer1D copiedLayer, SoilLayer1D originalLayer)
        {
            copiedLayer.IsAquifer = originalLayer.IsAquifer;
            copiedLayer.WaterpressureInterpolationModel = originalLayer.WaterpressureInterpolationModel;
        }

        private static bool IsLayerBelowSurfaceLine(SoilLayer1D soilLayer, IEnumerable<Point2D> surfaceLinePoints)
        {
            return surfaceLinePoints.Min(p => p.Z) > soilLayer.TopLevel;
        }

        private static bool IsLayerAboveSurfaceLine(SoilLayer1D soilLayer, SurfaceLine2 surfaceLine2)
        {
            return soilLayer.BottomLevel > surfaceLine2.Geometry.GetMaxZ();
        }

        private static IEnumerable<Point2D> GetLocalSurfaceLinePoints(IEnumerable<SoilLayer1D> soilLayers, SurfaceLine2 surfaceLine)
        {
            var xCoordinates = GetXCoordinates(soilLayers, surfaceLine);
            return xCoordinates.Select(x => new Point2D(x, surfaceLine.Geometry.GetZatX(x))).ToArray();
        }

        /// <summary>
        /// Gets the X coordinates to determine the coordinates for through each layer.
        /// </summary>
        /// <param name="soilLayers">The collection of <see cref="SoilLayer1D"/>.</param>
        /// <param name="surfaceLine">The <see cref="SurfaceLine2"/>.</param>
        /// <returns>A collection of unique x coordinates, in an ascending order.</returns>
        /// <remarks>This function is necessary, because the algorithm in recognizing
        /// surfaces requires that curves are overlapping. Curves cannot be a subset (e.g, there is one
        /// curve definition that span two other curves, because the algorithm will not
        /// be able to determine a surface from it.</remarks>
        private static IEnumerable<double> GetXCoordinates(IEnumerable<SoilLayer1D> soilLayers, SurfaceLine2 surfaceLine)
        {
            var xCoordinates = new List<double>(surfaceLine.Geometry.CalcPoints.Select(p => p.X));

            foreach (SoilLayer1D layer in soilLayers)
            {
                xCoordinates.AddRange(GetUniqueXCoordinatesWithIntersections(surfaceLine, layer.TopLevel, layer.BottomLevel));
            }

            return xCoordinates.OrderBy(x => x).Distinct();
        }

        private static IEnumerable<double> GetUniqueXCoordinatesWithIntersections(SurfaceLine2 surfaceLine, double layerTopLevel, double layerBottomLevel)
        {
            GeometryPointString surfaceLineGeometry = surfaceLine.Geometry;
            double minXCoordinate = surfaceLineGeometry.GetMinX();
            double maxXCoordinate = surfaceLineGeometry.GetMaxX();

            // Create lines to determine intersections
            var topLeft = new Point2D(minXCoordinate, layerTopLevel);
            var topRight = new Point2D(maxXCoordinate, layerTopLevel);
            var topLine = new Line(topLeft, topRight);

            var bottomLeft = new Point2D(minXCoordinate, layerBottomLevel);
            var bottomRight = new Point2D(maxXCoordinate, layerBottomLevel);
            var bottomLine = new Line(bottomLeft, bottomRight);

            var xCoordinates = surfaceLineGeometry.IntersectionPointsXzWithLineXz(topLine).Select(p => p.X).ToList();
            xCoordinates.AddRange(surfaceLineGeometry.IntersectionPointsXzWithLineXz(bottomLine).Select(p => p.X));

            return xCoordinates.Distinct();
        }

        private static IEnumerable<LayerData> CreateLayerData(IEnumerable<SoilLayer1D> soilLayers, IEnumerable<Point2D> surfaceLinePoints)
        {
            var layerData = new List<LayerData>();
            foreach (SoilLayer1D soilLayer in soilLayers)
            {
                if (IsLayerBelowSurfaceLine(soilLayer, surfaceLinePoints))
                {
                    layerData.Add(CreateSurfaceLineWideSoilLayer(soilLayer, surfaceLinePoints));
                }
                else
                {
                    layerData.AddRange(CreateSoilLayerWithSurfaceLineIntersection(soilLayer, surfaceLinePoints));
                }
            }

            return layerData;
        }
        
        /// <summary>
        /// Filters layer data that consist of closed loops.
        /// </summary>
        /// <param name="layerData">The collection of <see cref="LayerData"/> to filter.</param>
        /// <returns>A collection of <see cref="LayerData"/> that define a closed loop.</returns>
        private static IEnumerable<LayerData> FilterLayerDataWithClosedLoops(IEnumerable<LayerData> layerData)
        {
            return layerData.Where(l => l.Curves.Count() > 2);
        }

        /// <summary>
        /// Creates a 2D soil layer with points at <paramref name="surfaceLinePoints"/>.
        /// </summary>
        /// <param name="soilLayer">The <see cref="SoilLayer1D"/> to create the 2D soil layer for.</param>
        /// <param name="surfaceLinePoints">The collection of <see cref="Point2D"/> that defines the surface line.</param>
        /// <returns>A <see cref="LayerData"/> based on the input arguments.</returns>
        private static LayerData CreateSurfaceLineWideSoilLayer(SoilLayer1D soilLayer, IEnumerable<Point2D> surfaceLinePoints)
        {
            // A single square definition does not suffice for the area definition. The 
            // curves need to overlap each other or the geometry generator fails to recognize
            // a surface
            double layerTopLevel = soilLayer.TopLevel;
            double layerBottomLevel = soilLayer.BottomLevel;
            var pointsToConvert = surfaceLinePoints.Select(p => new Point2D(p.X, layerTopLevel)).ToList();
            pointsToConvert.AddRange(surfaceLinePoints.Reverse().Select(p => new Point2D(p.X, layerBottomLevel)).ToArray());

            var curves = GenerateClosedLoopCurves(pointsToConvert);
            return new LayerData(pointsToConvert, curves, soilLayer.Soil, soilLayer.IsAquifer, soilLayer.WaterpressureInterpolationModel);
        }

        /// <summary>
        /// Creates a 2D soil layer with points at <paramref name="surfaceLinePoints"/> based on its input arguments.
        /// </summary>
        /// <param name="soilLayer">The <see cref="SoilLayer1D"/> to create the 2D soil layer for.</param>
        /// <param name="surfaceLinePoints">The collection of <see cref="Point2D"/> that defines the surface line.</param>
        /// <returns>A collection of <see cref="LayerData"/> based on the input arguments.</returns>
        private static IEnumerable<LayerData> CreateSoilLayerWithSurfaceLineIntersection(SoilLayer1D soilLayer, IEnumerable<Point2D> surfaceLinePoints)
        {
            // Surface cannot be determined if there are not at least 2 coordinates
            var pointsArray = surfaceLinePoints.ToArray();
            if (pointsArray.Length < 2)
            {
                return Enumerable.Empty<LayerData>();
            }

            var enclosedAreas = GetEnclosedAreas(pointsArray, soilLayer.TopLevel, soilLayer.BottomLevel);
            return enclosedAreas.Select(a => CreateLayerData(a, soilLayer)).ToArray();
        }

        /// <summary>
        /// Determines the enclosed areas that are formed by the intersections between the surface line, the top level and the bottom level.
        /// </summary>
        /// <param name="surfaceLinePoints">The collection of <see cref="Point2D"/> that define the surface line.</param>
        /// <param name="topLevel">The top level.</param>
        /// <param name="bottomLevel">The bottom level.</param>
        /// <returns>A collection of <see cref="EnclosedArea"/>.</returns>
        private static IEnumerable<EnclosedArea> GetEnclosedAreas(IReadOnlyList<Point2D> surfaceLinePoints, double topLevel, double bottomLevel)
        {
            var currentArea = new EnclosedArea();
            var enclosedAreas = new List<EnclosedArea>();

            double previousZCoordinate = surfaceLinePoints[0].Z;
            int j = 1;
            for (int i = 0; i < surfaceLinePoints.Count; i++)
            {
                Point2D currentPoint = surfaceLinePoints[i];
                double xCoordinate = currentPoint.X;
                double zCoordinateSurfaceLine = currentPoint.Z;
                double nextSurfaceLineZCoordinate = surfaceLinePoints[j].Z;

                double currentZCoordinate = zCoordinateSurfaceLine;
                if (zCoordinateSurfaceLine > topLevel)
                {
                    currentZCoordinate = topLevel;
                    currentArea.AddCoordinate(new Point2D(xCoordinate, topLevel));
                }
                else if (Math.Abs(zCoordinateSurfaceLine - bottomLevel) < GeometryConstants.Accuracy // Surface line is at layer bottom level
                         || (zCoordinateSurfaceLine >= bottomLevel && zCoordinateSurfaceLine <= topLevel)) // Surface line is between the layer top and bottom level
                {
                    currentArea.AddCoordinate(new Point2D(xCoordinate, zCoordinateSurfaceLine));
                }

                // Determine if the current surface line point is located as a point on the horizontal line on the layer bottom level.
                // If yes, then a new area should be added
                if (Math.Abs(zCoordinateSurfaceLine - bottomLevel) < GeometryConstants.Accuracy
                    && Math.Abs(nextSurfaceLineZCoordinate - bottomLevel) < GeometryConstants.Accuracy)
                {
                    enclosedAreas.Add(currentArea);
                    currentArea = new EnclosedArea();
                }
                else if (previousZCoordinate > bottomLevel // Area should also be added when the area already started above or at the soil layer bottom
                         && zCoordinateSurfaceLine < previousZCoordinate // The surface line has a decreasing trend w.r.t. the previous z coordinate
                         && zCoordinateSurfaceLine <= bottomLevel) // The surface line crossed the bottom of the layer 
                {
                    enclosedAreas.Add(currentArea);
                    currentArea = new EnclosedArea();

                    // If the next z coordinate is increasing, it means that the surface line is intersecting
                    // the bottom level with an inflection point. In this situation, the current coordinate should be 
                    // added to the new area
                    if (nextSurfaceLineZCoordinate > currentZCoordinate)
                    {
                        currentArea.AddCoordinate(new Point2D(xCoordinate, currentZCoordinate));
                    }
                }

                previousZCoordinate = currentZCoordinate;

                // End of array, take the last Z coordinate as the next coordinate
                j = i == surfaceLinePoints.Count - 2 ? j : j + 1;
            }

            // The last area needs to be added manually
            enclosedAreas.Add(currentArea);

            // Filter the areas that contain more than 1 coordinate
            return enclosedAreas.Where(area => area.Coordinates.Count() > 1);
        }

        private static LayerData CreateLayerData(EnclosedArea area, SoilLayer1D soilLayer)
        {
            double layerBottomLevel = soilLayer.BottomLevel;
            var pointsToConvert = new List<Point2D>(area.Coordinates);

            // Determine the additional points need to be added to close the area
            // The area ends at the top right point. Go clockwise to close the area by adding 
            // points corresponding to the layer bottom level.
            var pointsToTraverse = area.Coordinates.Reverse();
            foreach (Point2D point in pointsToTraverse)
            {
                var bottomPoint = new Point2D(point.X, layerBottomLevel);
                if (!point.LocationEquals(bottomPoint))
                {
                    pointsToConvert.Add(bottomPoint);
                }
            }

            var curves = GenerateClosedLoopCurves(pointsToConvert);
            return new LayerData(pointsToConvert, curves, soilLayer.Soil, soilLayer.IsAquifer, soilLayer.WaterpressureInterpolationModel);
        }

        /// <summary>
        /// Generates curves based on a collection of points.
        /// </summary>
        /// <param name="pointsToConvert">The collection points to generate a curve collection for.</param>
        /// <returns>A collection of <see cref="GeometryCurve"/>.</returns>
        private static IEnumerable<GeometryCurve> GenerateCurves(IReadOnlyList<Point2D> pointsToConvert)
        {
            Point2D startPoint = pointsToConvert[0];
            var curves = new List<GeometryCurve>();
            for (int i = 1; i < pointsToConvert.Count; i++)
            {
                Point2D endPoint = pointsToConvert[i];
                curves.Add(new GeometryCurve(startPoint, endPoint));
                startPoint = endPoint;
            }

            return curves;
        }

        /// <summary>
        /// Generates curves that define a clockwise closed loop based on a collection of points.
        /// </summary>
        /// <param name="pointsToConvert">The collection points to generate a curve collection for.</param>
        /// <returns>A collection of <see cref="GeometryCurve"/>.</returns>
        private static IEnumerable<GeometryCurve> GenerateClosedLoopCurves(IReadOnlyList<Point2D> pointsToConvert)
        {
            var curves = GenerateCurves(pointsToConvert).ToList();

            // Close the geometry by connecting the first and last points with each other
            // This closes the outer loop in a clockwise definition.
            curves.Add(new GeometryCurve(pointsToConvert.Last(), pointsToConvert.First()));
            return curves;
        }

        /// <summary>
        /// Class to hold the geometry data of a layer.
        /// </summary>
        private class LayerData
        {
            /// <summary>
            /// Creates a new instance of <see cref="LayerData"/>.
            /// </summary>
            /// <param name="points">The collection of <see cref="Point2D"/>.</param>
            /// <param name="curves">The collection of <see cref="GeometryCurve"/>.</param>
            /// <param name="soil">The <see cref="Soil"/> belonging to this layer.</param>
            /// <param name="isAquifer">Indicator whether the layer is an aquifer or not.</param>
            /// <param name="waterpressureInterpolationModel">The <see cref="WaterpressureInterpolationModel"/> of this layer.</param>
            public LayerData(IEnumerable<Point2D> points,
                IEnumerable<GeometryCurve> curves,
                Soil soil, 
                bool isAquifer, 
                WaterpressureInterpolationModel waterpressureInterpolationModel)
            {
                Points = points;
                Curves = curves;
                Soil = soil;
                IsAquifer = isAquifer;
                WaterpressureInterpolationModel = waterpressureInterpolationModel;
            }

            /// <summary>
            /// Gets the collection of <see cref="Point2D"/> that define this layer.
            /// </summary>
            public IEnumerable<Point2D> Points { get; }

            /// <summary>
            /// Gets the collection of <see cref="GeometryCurve"/> that define this layer.
            /// </summary>
            public IEnumerable<GeometryCurve> Curves { get; }

            /// <summary>
            /// Gets the soil of this layer.
            /// </summary>
            public Soil Soil { get; }

            /// <summary>
            /// Gets the indicator whether this layer is an aquifer.
            /// </summary>
            public bool IsAquifer { get; }

            /// <summary>
            /// Gets the <see cref="WaterpressureInterpolationModel"/> belonging to this layer.
            /// </summary>
            public WaterpressureInterpolationModel WaterpressureInterpolationModel { get; }

            /// <summary>
            /// Function to determine whether the z coordinate lies between the top and
            /// bottom coordinate of this layer.
            /// </summary>
            /// <param name="z">The z coordinate to determine the whether it is located inside this layer.</param>
            /// <returns><c>true</c> if z lies between the top and bottom coordinate of this layer, <c>false</c> otherwise</returns>
            public bool IsZLocatedInLayer(double z)
            {
                double maxZCoordinate = Points.Select(p => p.Z).Max();
                double minZCoordinate = Points.Select(p => p.Z).Min();

                return z >= minZCoordinate && z <= maxZCoordinate;
            }
        }

        /// <summary>
        /// Class to hold the information about the area between a surface line and a soil layer.
        /// </summary>
        private class EnclosedArea
        {
            private readonly List<Point2D> coordinates;
            
            /// <summary>
            /// Creates a new instance of <see cref="EnclosedArea"/>.
            /// </summary>
            public EnclosedArea()
            {
                coordinates = new List<Point2D>();
            }

            /// <summary>
            /// Gets the coordinates of the enclosed area.
            /// </summary>
            public IEnumerable<Point2D> Coordinates { get{ return coordinates; }}

            /// <summary>
            /// Adds a coordinate to the area.
            /// </summary>
            /// <param name="coordinate">The <see cref="Point2D"/> coordinate to add.</param>
            /// <exception cref="ArgumentNullException">Thrown when <paramref name="coordinate"/>
            /// is <c>null</c>.</exception>
            public void AddCoordinate(Point2D coordinate)
            {
                if (coordinate == null)
                {
                    throw new ArgumentNullException(nameof(coordinate));
                }
                coordinates.Add(coordinate);
            }
        }
    }
}