// Copyright (C) Stichting Deltares 2025. 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 Deltares.DamEngine.Data.Geometry;
using NUnit.Framework;

namespace Deltares.DamEngine.Data.Tests.Geometry;

[TestFixture]
public class GeometrySurfaceTests
{
    private const double cTolerance = 1e-5;
    [Test]
    public void TestDetermineValidTestPointBasedOnNewSurfaceWithDonutGeometry()
    {
        GeometryData geometry = CreateDonutGeometry();
        Point2D testPoint = geometry.Surfaces[0].DetermineValidTestPointBasedOnNewSurface();
        GeometryLoop outerLoop = geometry.Surfaces[0].OuterLoop;
        GeometryLoop innerLoop = geometry.Surfaces[0].InnerLoops[0];
        Assert.Multiple(() =>
        {
            Assert.That(Routines2D.CheckIfPointIsInPolygon(outerLoop, testPoint.X, testPoint.Z) == PointInPolygon.InsidePolygon);
            Assert.That(Routines2D.CheckIfPointIsInPolygon(innerLoop, testPoint.X, testPoint.Z) == PointInPolygon.OutsidePolygon);
        });
        testPoint = geometry.Surfaces[1].DetermineValidTestPointBasedOnNewSurface();
        outerLoop = geometry.Surfaces[1].OuterLoop;
        Assert.Multiple(() =>
        {
            Assert.That(Routines2D.CheckIfPointIsInPolygon(outerLoop, testPoint.X, testPoint.Z) == PointInPolygon.InsidePolygon);
            Assert.That(geometry.Surfaces[1].InnerLoops.Count, Is.EqualTo(0));
        });
    }
    
    [Test]
    public void TestDetermineValidTestPointBasedOnNewSurfaceWithPointedGeometryToTestOffsetReduction()
    {
        GeometryData geometry = CreatePointedGeometry();
        Point2D testPoint = geometry.Surfaces[0].DetermineValidTestPointBasedOnNewSurface();
        GeometryLoop outerLoop = geometry.Surfaces[0].OuterLoop;
        Assert.Multiple(() =>
        {
            Assert.That(Routines2D.CheckIfPointIsInPolygon(outerLoop, testPoint.X, testPoint.Z) == PointInPolygon.InsidePolygon);
            Assert.That(geometry.Surfaces[0].InnerLoops.Count, Is.EqualTo(0));
        });
    }
    
    private static GeometryData CreateDonutGeometry()
    {
        var geometryModel = new GeometryData
        {
            Left = -10,
            Bottom = -10,
            Right = 20
        };

        /* The following model looks as follows
         *
         *  |----------|
         *  |  ------  |
         *  |  |    |  |
         *  |  |    |  |
         *  |  ------  |
         *  |----------|
         *
         */

        var point1 = new Point2D(0, 0);
        var point2 = new Point2D(0, 10);
        var point3 = new Point2D(10, 10);
        var point4 = new Point2D(10, 0);
        var point5 = new Point2D(3, 3);
        var point6 = new Point2D(3, 7);
        var point7 = new Point2D(7, 7);
        var point8 = new Point2D(7, 3);

        var curve1 = new GeometryCurve(point1, point2);
        var curve2 = new GeometryCurve(point2, point3);
        var curve3 = new GeometryCurve(point3, point4);
        var curve4 = new GeometryCurve(point4, point1);
        var curve5 = new GeometryCurve(point5, point6);
        var curve6 = new GeometryCurve(point6, point7);
        var curve7 = new GeometryCurve(point7, point8);
        var curve8 = new GeometryCurve(point8, point5);

        geometryModel.Points.AddRange([
            point1,
            point2,
            point3,
            point4,
            point5,
            point6,
            point7,
            point8
        ]);
        geometryModel.Curves.AddRange([
            curve1,
            curve2,
            curve3,
            curve4,
            curve5,
            curve6,
            curve7,
            curve8
        ]);

        geometryModel.NewlyEffectedPoints.AddRange(geometryModel.Points);
        geometryModel.NewlyEffectedCurves.AddRange(geometryModel.Curves);
        geometryModel.RegenerateGeometry();
        return geometryModel;
    }
    
    private static GeometryData CreatePointedGeometry()
    {
        var geometryModel = new GeometryData
        {
            Left = -10,
            Bottom = -10,
            Right = 20
        };

        /* The following model looks as follows and forces offset reduction
         *
         *  |----------------------------------------------------------------------------------------------------------|
         *                                                                                ----------------------------|
         */

        var point1 = new Point2D(-10, 10);
        var point2 = new Point2D(20, 10);
        var point3 = new Point2D(19.8, 9.999);
        
        var curve1 = new GeometryCurve(point1, point2);
        var curve2 = new GeometryCurve(point2, point3);
        var curve3 = new GeometryCurve(point3, point1);
        
        geometryModel.Points.AddRange([
            point1,
            point2,
            point3
        ]);
        geometryModel.Curves.AddRange([
            curve1,
            curve2,
            curve3
        ]);

        geometryModel.NewlyEffectedPoints.AddRange(geometryModel.Points);
        geometryModel.NewlyEffectedCurves.AddRange(geometryModel.Curves);
        geometryModel.RegenerateGeometry();
        return geometryModel;
    }
}