// 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;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using Deltares.DamEngine.Data.Geometry;
using NUnit.Framework;

namespace Deltares.DamEngine.Data.Tests.Geometry;

[TestFixture]
public class GeometryGeneratorTests
{
    [TestCase(0.52, 0.51, false, true)]
    [TestCase(0.51, 0.52, true, false)]
    [TestCase(0.51, 0.51, true, true)]
    [Test]
    public void WhenDeterminePointClosestToLine_ThenResultIsAsExpected(double x1, double x2, bool isPoint1Closest, bool isPoint2Closest)
    {
        // Given
        var line = new GeometryCurve(new Point2D(0.0, 0.0), new Point2D(1.0, 1.0));
        var point1 = new Point2D(x1, 0.5);
        var point2 = new Point2D(x2, 0.5);
        var isPoint1ClosestToLine = true;
        var isPoint2ClosestToLine = true;
        // When
        GeometryGenerator.DeterminePointClosestToLine(point1, point2, line, ref isPoint1ClosestToLine,  ref isPoint2ClosestToLine);
        Assert.Multiple(() =>
        {
            // Then
            Assert.That(isPoint1ClosestToLine, Is.EqualTo(isPoint1Closest));
            Assert.That(isPoint2ClosestToLine, Is.EqualTo(isPoint2Closest));
        });
    }

    [Test, TestCaseSource(nameof(CurvesToBeTestedForParallelCurves))]
    public void TestRegenerateParallelCurves(TestCaseCurvesToBeTestedForParallelCurves testCase)
    {
        // Given
        var geometryData = new GeometryData();
        geometryData.Points.Add(testCase.InputPoint1);
        geometryData.Points.Add(testCase.InputPoint2);
        geometryData.Points.Add(testCase.InputPoint3);
        geometryData.Points.Add(testCase.InputPoint4);
        var curve1 = new GeometryCurve(testCase.InputPoint1, testCase.InputPoint2);
        var curve2 = new GeometryCurve(testCase.InputPoint3, testCase.InputPoint4);
        geometryData.Curves.Add(curve1);
        geometryData.Curves.Add(curve2);
        var generator = new GeometryGenerator(geometryData);
        
        // When
        bool isCurveInserted = false;
        generator.RegenerateParallelCurves(curve1, curve2, ref isCurveInserted);
        
        // Then
        Assert.Multiple(() =>
        {
            Assert.That(curve1.HeadPoint, Is.EqualTo(testCase.ExpectedPoint1));
            Assert.That(curve1.EndPoint, Is.EqualTo(testCase.ExpectedPoint2));
            Assert.That(curve2.HeadPoint, Is.EqualTo(testCase.ExpectedPoint3));
            Assert.That(curve2.EndPoint, Is.EqualTo(testCase.ExpectedPoint4));
            Assert.That(isCurveInserted, Is.EqualTo(testCase.IsCurveInserted));
            if (testCase.ExpectedPoint5 != null)
            {
                Assert.That(geometryData.NewlyEffectedCurves[0].HeadPoint, Is.EqualTo(testCase.ExpectedPoint5));
            }
            if (testCase.ExpectedPoint6 != null)
            {
                Assert.That(geometryData.NewlyEffectedCurves[0].EndPoint, Is.EqualTo(testCase.ExpectedPoint6));
            }
        });
    }
    
    /// <summary>
    /// Test case class for parallel curves
    /// </summary>
    public class TestCaseCurvesToBeTestedForParallelCurves
    {
        public Point2D InputPoint1 { get; init; }
        public Point2D InputPoint2 { get; init; }
        public Point2D InputPoint3 { get; init; }
        public Point2D InputPoint4 { get; init; }
        public Point2D ExpectedPoint1 { get; init; }
        public Point2D ExpectedPoint2 { get; init; }
        public Point2D ExpectedPoint3 { get; init; }
        public Point2D ExpectedPoint4 { get; init; }
        public Point2D ExpectedPoint5 { get; init; }
        public Point2D ExpectedPoint6 { get; init; }
        public bool IsCurveInserted { get; init; }
        public int TestNumber { get; init; }
    }
    private static IEnumerable<TestCaseData> CurvesToBeTestedForParallelCurves
    {
        get
        {
            var point1 = new Point2D(0.0, 0.0);
            var point2 = new Point2D(1.0, 1.0);
            var point3 = new Point2D(2.0, 0.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point1, 
                    InputPoint2 = point2, 
                    InputPoint3 = point2, 
                    InputPoint4 = point3,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point1,
                    ExpectedPoint2 = point2,
                    ExpectedPoint3 = point2,
                    ExpectedPoint4 = point3,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 1: ordered, not parallel should do nothing");
            
            var point2_1 = new Point2D(0.0, 0.0);
            var point2_2 = new Point2D(4.0, 4.0);
            var point2_3 = new Point2D(2.0, 2.0);
            var point2_4 = new Point2D(3.0, 3.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point2_1, 
                    InputPoint2 = point2_2, 
                    InputPoint3 = point2_3, 
                    InputPoint4 = point2_4,
                    IsCurveInserted = true,
                    ExpectedPoint1 = point2_1,
                    ExpectedPoint2 = point2_3,
                    ExpectedPoint3 = point2_3,
                    ExpectedPoint4 = point2_4,
                    ExpectedPoint5 = point2_4,
                    ExpectedPoint6 = point2_2
                }).SetName("Test 2: p1--p3--p4--p2 -> split c1 to c(p1--p3) keep c2, insert c(p4--p2)");
            
            var point3_1 = new Point2D(0.0, 0.0);
            var point3_2 = new Point2D(4.0, 4.0);
            var point3_3 = new Point2D(3.0, 3.0);
            var point3_4 = new Point2D(2.0, 2.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point3_1, 
                    InputPoint2 = point3_2, 
                    InputPoint3 = point3_3, 
                    InputPoint4 = point3_4,
                    IsCurveInserted = true,
                    ExpectedPoint1 = point3_1,
                    ExpectedPoint2 = point3_4,
                    ExpectedPoint3 = point3_3,
                    ExpectedPoint4 = point3_4,
                    ExpectedPoint5 = point3_3,
                    ExpectedPoint6 = point3_2
                }).SetName("Test 3: p1--p4--p3--p2 split c1 to c(p1--p4) keep c2, insert c(p3--p2)");
            
            var point4_1 = new Point2D(0.0, 0.0);
            var point4_2 = new Point2D(3.0, 3.0);
            var point4_3 = new Point2D(2.0, 2.0);
            var point4_4 = new Point2D(4.0, 4.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point4_1, 
                    InputPoint2 = point4_2, 
                    InputPoint3 = point4_3, 
                    InputPoint4 = point4_4,
                    IsCurveInserted = true,
                    ExpectedPoint1 = point4_1,
                    ExpectedPoint2 = point4_3,
                    ExpectedPoint3 = point4_2,
                    ExpectedPoint4 = point4_4,
                    ExpectedPoint5 = point4_3,
                    ExpectedPoint6 = point4_2
                }).SetName("Test 4: p1--p3--p2--p4 split c1 to c(p1--p3) split c2 to c(p2--p4), insert c(p3--p2)");
            
            var point5_1 = new Point2D(0.0, 0.0);
            var point5_2 = new Point2D(3.0, 3.0);
            var point5_3 = new Point2D(4.0, 4.0);
            var point5_4 = new Point2D(2.0, 2.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point5_1, 
                    InputPoint2 = point5_2, 
                    InputPoint3 = point5_3, 
                    InputPoint4 = point5_4,
                    IsCurveInserted = true,
                    ExpectedPoint1 = point5_1,
                    ExpectedPoint2 = point5_4,
                    ExpectedPoint3 = point5_3,
                    ExpectedPoint4 = point5_2,
                    ExpectedPoint5 = point5_4,
                    ExpectedPoint6 = point5_2
                }).SetName("Test 5: p1--p4--p2--p3 split c1 to c(p1--p4) split c2 to c(p3--p2), insert c(p4--p2)");
            
            var point6_1 = new Point2D(0.0, 0.0);
            var point6_2 = new Point2D(2.0, 2.0);
            var point6_3 = new Point2D(4.0, 4.0);
            var point6_4 = new Point2D(3.0, 3.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point6_1, 
                    InputPoint2 = point6_2, 
                    InputPoint3 = point6_3, 
                    InputPoint4 = point6_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point6_1,
                    ExpectedPoint2 = point6_2,
                    ExpectedPoint3 = point6_3,
                    ExpectedPoint4 = point6_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 6: p1--p2 <--> p4--p3 in each other's extension, no overlap do nothing");
            
            var point7_1 = new Point2D(0.0, 0.0);
            var point7_2 = new Point2D(2.0, 2.0);
            var point7_3 = new Point2D(3.0, 3.0);
            var point7_4 = new Point2D(4.0, 4.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point7_1, 
                    InputPoint2 = point7_2, 
                    InputPoint3 = point7_3, 
                    InputPoint4 = point7_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point7_1,
                    ExpectedPoint2 = point7_2,
                    ExpectedPoint3 = point7_3,
                    ExpectedPoint4 = point7_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 7: p1--p2 <--> p3--p4 in each other's extension, no overlap do nothing");
            
            var point8_1 = new Point2D(0.0, 0.0);
            var point8_2 = new Point2D(2.0, 2.0);
            var point8_3 = point8_1;
            var point8_4 = new Point2D(4.0, 4.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point8_1, 
                    InputPoint2 = point8_2, 
                    InputPoint3 = point8_3, 
                    InputPoint4 = point8_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point8_1,
                    ExpectedPoint2 = point8_2,
                    ExpectedPoint3 = point8_2,
                    ExpectedPoint4 = point8_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 8: p1/p3--p2--p4 keep c1, split c2 to c(p2--p4)");
            
            var point9_1 = new Point2D(0.0, 0.0);
            var point9_2 = new Point2D(4.0, 4.0);
            var point9_3 = point9_1;
            var point9_4 = new Point2D(2.0, 2.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point9_1, 
                    InputPoint2 = point9_2, 
                    InputPoint3 = point9_3, 
                    InputPoint4 = point9_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point9_4,
                    ExpectedPoint2 = point9_2,
                    ExpectedPoint3 = point9_3,
                    ExpectedPoint4 = point9_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 9: p1/p3--p4--p2 split c1 to c(p4--p2), keep c2 (p3-p4)");
            
            var point10_1 = new Point2D(0.0, 0.0);
            var point10_2 = new Point2D(2.0, 2.0);
            var point10_3 = new Point2D(4.0, 4.0);
            var point10_4 = point10_1;
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point10_1, 
                    InputPoint2 = point10_2, 
                    InputPoint3 = point10_3, 
                    InputPoint4 = point10_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point10_1,
                    ExpectedPoint2 = point10_2,
                    ExpectedPoint3 = point10_3,
                    ExpectedPoint4 = point10_2,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 10: p1/p4--p2--p3 keep c1(p1,p2) , split c2 to c(p3--p2)");
            
            var point11_1 = new Point2D(0.0, 0.0);
            var point11_2 = new Point2D(4.0, 4.0);
            var point11_3 = new Point2D(2.0, 2.0);
            var point11_4 = point11_1;
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point11_1, 
                    InputPoint2 = point11_2, 
                    InputPoint3 = point11_3, 
                    InputPoint4 = point11_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point11_3,
                    ExpectedPoint2 = point11_2,
                    ExpectedPoint3 = point11_3,
                    ExpectedPoint4 = point11_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 11: p1/p4--p3--p2 split c1 to c1(p3,p2), keep c2 (p3--p4)");
            
            var point12_1 = new Point2D(0.0, 0.0);
            var point12_2 = new Point2D(2.0, 2.0);
            var point12_3 = point12_2;
            var point12_4 = new Point2D(4.0, 4.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point12_1, 
                    InputPoint2 = point12_2, 
                    InputPoint3 = point12_3, 
                    InputPoint4 = point12_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point12_1,
                    ExpectedPoint2 = point12_2,
                    ExpectedPoint3 = point12_3,
                    ExpectedPoint4 = point12_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 12: p1--p2/p3--p4 keep c1(p1,p2) , split c2(p2--p4)");
            
            var point13_1 = new Point2D(4.0, 4.0);
            var point13_2 = new Point2D(2.0, 2.0);
            var point13_3 = point13_2;
            var point13_4 = new Point2D(0.0, 0.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point13_1, 
                    InputPoint2 = point13_2, 
                    InputPoint3 = point13_3, 
                    InputPoint4 = point13_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point13_1,
                    ExpectedPoint2 = point13_2,
                    ExpectedPoint3 = point13_3,
                    ExpectedPoint4 = point13_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 13: p4--p2/p3--p1 keep c1(p1,p2) , keep c2(p3--p4)");
            
            var point14_1 = new Point2D(2.0, 2.0);
            var point14_2 = new Point2D(4.0, 4.0);
            var point14_3 = new Point2D(0.0, 0.0);
            var point14_4 = point14_1;
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point14_1, 
                    InputPoint2 = point14_2, 
                    InputPoint3 = point14_3, 
                    InputPoint4 = point14_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point14_1,
                    ExpectedPoint2 = point14_2,
                    ExpectedPoint3 = point14_3,
                    ExpectedPoint4 = point14_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 14: p3--p1/p4--p2 keep c1(p1,p2) , keep c2(p3--p4)");
            
            var point15_1 = new Point2D(2.0, 2.0);
            var point15_2 = new Point2D(0.0, 0.0);
            var point15_3 = new Point2D(4.0, 4.0);
            var point15_4 = point15_1;
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point15_1, 
                    InputPoint2 = point15_2, 
                    InputPoint3 = point15_3, 
                    InputPoint4 = point15_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point15_1,
                    ExpectedPoint2 = point15_2,
                    ExpectedPoint3 = point15_3,
                    ExpectedPoint4 = point15_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 15: p2--p1/p4--p3 keep c1(p1,p2) , keep c2(p3--p4)");
        
            var point16_1 = new Point2D(4.0, 4.0);
            var point16_2 = new Point2D(0.0, 0.0);
            var point16_3 = new Point2D(2.0, 2.0);
            var point16_4 = point16_1;
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point16_1, 
                    InputPoint2 = point16_2, 
                    InputPoint3 = point16_3, 
                    InputPoint4 = point16_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point16_3,
                    ExpectedPoint2 = point16_2,
                    ExpectedPoint3 = point16_3,
                    ExpectedPoint4 = point16_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 16: p2--p3--p1/p4 split c1(p3,p2) , keep c2(p3--p4)");
            
            var point17_1 = new Point2D(4.0, 4.0);
            var point17_2 = new Point2D(2.0, 2.0);
            var point17_3 = new Point2D(0.0, 0.0);
            var point17_4 = point17_1;
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point17_1, 
                    InputPoint2 = point17_2, 
                    InputPoint3 = point17_3, 
                    InputPoint4 = point17_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point17_1,
                    ExpectedPoint2 = point17_2,
                    ExpectedPoint3 = point17_3,
                    ExpectedPoint4 = point17_2,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 17: p3--p2--p1/p4 keep c1(p1,p2) , split c2(p3--p2)");
            
            var point18_1 = new Point2D(2.0, 2.0);
            var point18_2 = new Point2D(4.0, 4.0);
            var point18_3 = point18_1;
            var point18_4 = new Point2D(0.0, 0.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point18_1, 
                    InputPoint2 = point18_2, 
                    InputPoint3 = point18_3, 
                    InputPoint4 = point18_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point18_1,
                    ExpectedPoint2 = point18_2,
                    ExpectedPoint3 = point18_3,
                    ExpectedPoint4 = point18_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 18: p4--p1/p3--p2 keep c1(p1,p2) , keep c2(p3--p4)");
            
            var point19_1 = new Point2D(2.0, 2.0);
            var point19_2 = new Point2D(0.0, 0.0);
            var point19_3 = point19_1;
            var point19_4 = new Point2D(4.0, 4.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point19_1, 
                    InputPoint2 = point19_2, 
                    InputPoint3 = point19_3, 
                    InputPoint4 = point19_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point19_1,
                    ExpectedPoint2 = point19_2,
                    ExpectedPoint3 = point19_3,
                    ExpectedPoint4 = point19_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 19: p2--p1/p3--p4 keep c1(p1,p2) , keep c2(p3--p4)");
            
            var point20_1 = new Point2D(4.0, 4.0);
            var point20_2 = new Point2D(0.0, 0.0);
            var point20_3 = point20_1;
            var point20_4 = new Point2D(2.0, 2.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point20_1, 
                    InputPoint2 = point20_2, 
                    InputPoint3 = point20_3, 
                    InputPoint4 = point20_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point20_4,
                    ExpectedPoint2 = point20_2,
                    ExpectedPoint3 = point20_3,
                    ExpectedPoint4 = point20_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 20: p2--p4--p1/p3 split c1(p4,p2) , keep c2(p3--p4)");
            
            var point21_1 = new Point2D(4.0, 4.0);
            var point21_2 = new Point2D(2.0, 2.0);
            var point21_3 = point21_1;
            var point21_4 = new Point2D(0.0, 0.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point21_1, 
                    InputPoint2 = point21_2, 
                    InputPoint3 = point21_3, 
                    InputPoint4 = point21_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point21_1,
                    ExpectedPoint2 = point21_2,
                    ExpectedPoint3 = point21_2,
                    ExpectedPoint4 = point21_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 21: p4--p2--p1/p3 keep c1(p1,p2) , split c2(p2-p4)");
            
            var point22_1 = new Point2D(2.0, 2.0);
            var point22_2 = new Point2D(0.0, 0.0);
            var point22_3 = new Point2D(4.0, 4.0);
            var point22_4 = point22_2;
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point22_1, 
                    InputPoint2 = point22_2, 
                    InputPoint3 = point22_3, 
                    InputPoint4 = point22_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point22_1,
                    ExpectedPoint2 = point22_2,
                    ExpectedPoint3 = point22_3,
                    ExpectedPoint4 = point22_1,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 22: p2/p4--p1--p3 keep c1(p1,p2) , split c2(p3-p1)");
            
            var point23_1 = new Point2D(4.0, 4.0);
            var point23_2 = new Point2D(0.0, 0.0);
            var point23_3 = new Point2D(2.0, 2.0);
            var point23_4 = point23_2;
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point23_1, 
                    InputPoint2 = point23_2, 
                    InputPoint3 = point23_3, 
                    InputPoint4 = point23_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point23_1,
                    ExpectedPoint2 = point23_3,
                    ExpectedPoint3 = point23_3,
                    ExpectedPoint4 = point23_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 23: p2/p4--p3--p1 split c1(p1,p3) , keep c2(p3-p4)");
            
            var point24_1 = new Point2D(0.0, 0.0);
            var point24_2 = new Point2D(2.0, 2.0);
            var point24_3 = new Point2D(4.0, 4.0);
            var point24_4 = point24_2;
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point24_1, 
                    InputPoint2 = point24_2, 
                    InputPoint3 = point24_3, 
                    InputPoint4 = point24_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point24_1,
                    ExpectedPoint2 = point24_2,
                    ExpectedPoint3 = point24_3,
                    ExpectedPoint4 = point24_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 24: p1--p2/p4--p3 keep c1(p1,p2) , keep c2(p3-p4)");
            
            var point25_1 = new Point2D(4.0, 4.0);
            var point25_2 = new Point2D(2.0, 2.0);
            var point25_3 = new Point2D(0.0, 0.0);
            var point25_4 = point25_2;
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point25_1, 
                    InputPoint2 = point25_2, 
                    InputPoint3 = point25_3, 
                    InputPoint4 = point25_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point25_1,
                    ExpectedPoint2 = point25_2,
                    ExpectedPoint3 = point25_3,
                    ExpectedPoint4 = point25_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 25: p3--p2/p4--p1 keep c1(p1,p2) , keep c2(p3-p4)");
            
            var point26_1 = new Point2D(0.0, 0.0);
            var point26_2 = new Point2D(4.0, 4.0);
            var point26_3 = new Point2D(2.0, 2.0);
            var point26_4 = point26_2;
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point26_1, 
                    InputPoint2 = point26_2, 
                    InputPoint3 = point26_3, 
                    InputPoint4 = point26_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point26_1,
                    ExpectedPoint2 = point26_3,
                    ExpectedPoint3 = point26_3,
                    ExpectedPoint4 = point26_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 26: p1--p3--p2/p4 split c1(p1,p3) , keep c2(p3-p4)");
            
            var point27_1 = new Point2D(2.0, 2.0);
            var point27_2 = new Point2D(4.0, 4.0);
            var point27_3 = new Point2D(0.0, 0.0);
            var point27_4 = point27_2;
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point27_1, 
                    InputPoint2 = point27_2, 
                    InputPoint3 = point27_3, 
                    InputPoint4 = point27_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point27_1,
                    ExpectedPoint2 = point27_2,
                    ExpectedPoint3 = point27_3,
                    ExpectedPoint4 = point27_1,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 27: p3--p1--p2/p4 keep c1(p1,p2) , split c2(p3-p1)");
            
            var point28_1 = new Point2D(2.0, 2.0);
            var point28_2 = new Point2D(0.0, 0.0);
            var point28_3 = point28_2;
            var point28_4 = new Point2D(4.0, 4.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point28_1, 
                    InputPoint2 = point28_2, 
                    InputPoint3 = point28_3, 
                    InputPoint4 = point28_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point28_1,
                    ExpectedPoint2 = point28_2,
                    ExpectedPoint3 = point28_1,
                    ExpectedPoint4 = point28_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 28: p2/p3--p1--p4 keep c1(p1,p2) , split c2(p1-p4)");
            
            var point29_1 = new Point2D(4.0, 4.0);
            var point29_2 = new Point2D(0.0, 0.0);
            var point29_3 = point29_2;
            var point29_4 = new Point2D(2.0, 2.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point29_1, 
                    InputPoint2 = point29_2, 
                    InputPoint3 = point29_3, 
                    InputPoint4 = point29_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point29_1,
                    ExpectedPoint2 = point29_4,
                    ExpectedPoint3 = point29_3,
                    ExpectedPoint4 = point29_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 29: p2/p3--p4--p1 split c1(p1,p4) , keep c2(p3-p4)");
            
            var point30_1 = new Point2D(0.0, 0.0);
            var point30_2 = new Point2D(2.0, 2.0);
            var point30_3 = point30_2;
            var point30_4 = new Point2D(4.0, 4.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point30_1, 
                    InputPoint2 = point30_2, 
                    InputPoint3 = point30_3, 
                    InputPoint4 = point30_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point30_1,
                    ExpectedPoint2 = point30_2,
                    ExpectedPoint3 = point30_3,
                    ExpectedPoint4 = point30_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 30: p1--p2/p3--p4 keep c1(p1,p2) , keep c2(p3-p4)");
            
            var point31_1 = new Point2D(4.0, 4.0);
            var point31_2 = new Point2D(2.0, 2.0);
            var point31_3 = point31_2;
            var point31_4 = new Point2D(0.0, 0.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point31_1, 
                    InputPoint2 = point31_2, 
                    InputPoint3 = point31_3, 
                    InputPoint4 = point31_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point31_1,
                    ExpectedPoint2 = point31_2,
                    ExpectedPoint3 = point31_3,
                    ExpectedPoint4 = point31_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 31: p4--p2/p3--p1 keep c1(p1,p2) , keep c2(p3-p4)");
            
            var point32_1 = new Point2D(0.0, 0.0);
            var point32_2 = new Point2D(4.0, 4.0);
            var point32_3 = point32_2;
            var point32_4 = new Point2D(2.0, 2.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point32_1, 
                    InputPoint2 = point32_2, 
                    InputPoint3 = point32_3, 
                    InputPoint4 = point32_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point32_1,
                    ExpectedPoint2 = point32_4,
                    ExpectedPoint3 = point32_3,
                    ExpectedPoint4 = point32_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 32: p1--p4--p2/p3 split c1(p1,p4) , keep c2(p3-p4)");
            
            
            var point33_1 = new Point2D(2.0, 2.0);
            var point33_2 = new Point2D(4.0, 4.0);
            var point33_3 = point33_2;
            var point33_4 = new Point2D(0.0, 0.0);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point33_1, 
                    InputPoint2 = point33_2, 
                    InputPoint3 = point33_3, 
                    InputPoint4 = point33_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point33_1,
                    ExpectedPoint2 = point33_2,
                    ExpectedPoint3 = point33_1,
                    ExpectedPoint4 = point33_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 33: p4--p1--p2/p3 keep c1(p1,p2) , split c2(p1-p4)");
            
            var point34_1 = new Point2D(39.580, 4.550);
            var point34_2 = new Point2D(41.070, 4.540);
            var point34_3 = point34_1;
            var point34_4 = new Point2D(39.730, 4.549);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point34_1, 
                    InputPoint2 = point34_2, 
                    InputPoint3 = point34_3, 
                    InputPoint4 = point34_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point34_4,
                    ExpectedPoint2 = point34_2,
                    ExpectedPoint3 = point34_3,
                    ExpectedPoint4 = point34_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 34: near parallel p1/p3--p4--p2 split c1 to c(p4--p2), keep c2 (p3-p4)");
            
            var point35_1 = new Point2D(39.580, 4.550);
            var point35_2 = new Point2D(39.730, 4.549);
            var point35_3 =point35_1;
            var point35_4 = new Point2D(41.070, 4.540);
            yield return new TestCaseData(
                new TestCaseCurvesToBeTestedForParallelCurves
                {
                    TestNumber = 1,
                    InputPoint1 = point35_1, 
                    InputPoint2 = point35_2, 
                    InputPoint3 = point35_3, 
                    InputPoint4 = point35_4,
                    IsCurveInserted = false,
                    ExpectedPoint1 = point35_1,
                    ExpectedPoint2 = point35_2,
                    ExpectedPoint3 = point35_2,
                    ExpectedPoint4 = point35_4,
                    ExpectedPoint5 = null,
                    ExpectedPoint6 = null
                }).SetName("Test 35: near parallel p1/p3--p2--p4 keep c1, split c2 to c(p2--p4)");
        }
    }
}