// 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;
using System.Collections.Generic;
using System.Linq;
using Deltares.DamEngine.Data.Geometry;
using Deltares.DamEngine.Data.Standard;
using Deltares.DamEngine.Data.Standard.Language;
using Deltares.DamEngine.Data.Standard.Validation;

namespace Deltares.DamEngine.Data.Geotechnics;

/// <summary>
/// Validator for <see cref="SurfaceLine2"/>.
/// </summary>
public class SurfaceLine2Validator
{
    /// <summary>
    /// Performs all validation checks for a surfaceline.
    /// </summary>
    /// <param name="surfaceline">The surfaceline being evaluated.</param>
    /// <returns>The collection of validation results.</returns>
    public IEnumerable<ValidationResult> Validate(SurfaceLine2 surfaceline)
    {
        return ValidateGeometryPointsAreOrdered(surfaceline)
               .Concat(ValidateCharacteristicPointsAreOrdered(surfaceline))
               .Concat(ValidateDikeShape(surfaceline));
    }

    /// <summary>
    /// Checks if all <see cref="GeometryPoint"/> instances in <see cref="SurfaceLine2.Geometry"/>
    /// are ordered on ascending X.
    /// </summary>
    /// <param name="surfaceline">The surfaceline being evaluated.</param>
    /// <returns>The collection of validation results.</returns>
    public IEnumerable<ValidationResult> ValidateGeometryPointsAreOrdered(SurfaceLine2 surfaceline)
    {
        if (!ArePointsAscending(surfaceline))
        {
            yield return new ValidationResult(ValidationResultType.Error, this.Translate("SurfacePointsNotAscending"),
                                              surfaceline, surfaceline.GetMemberName(sl => sl.Geometry), "");
        }
    }

    /// <summary>
    /// Checks if all characteristic points that require proper ordering based on X coordinate
    /// are indeed properly ordered.
    /// </summary>
    /// <param name="surfaceline">The surfaceline being evaluated.</param>
    /// <returns>The collection of validation results.</returns>
    public IEnumerable<ValidationResult> ValidateCharacteristicPointsAreOrdered(SurfaceLine2 surfaceline)
    {
        if (!AreAllCharacteristicPointsXCoordinatesAscending(surfaceline))
        {
            yield return new ValidationResult(ValidationResultType.Error, this.Translate("ChartPointsNotAscending"),
                                              surfaceline, surfaceline.GetMemberName(sl => sl.CharacteristicPoints), "");
        }
    }

    /// <summary>
    /// Are all characteristic points x coordinates ascending.
    /// </summary>
    /// <param name="line">The line.</param>
    /// <returns></returns>
    public static bool AreAllCharacteristicPointsXCoordinatesAscending(SurfaceLine2 line)
    {
        CharacteristicPoint[] points = line.GetCharacteristicPointsRequiringAscendingX().ToArray();
        return AreGeometryPointsXCoordinatesAscending(points);
    }
    
    /// <summary>
    /// Are all points x coordinates ascending. 
    /// </summary>
    /// <param name="line"></param>
    /// <returns></returns>
    public static bool AreAllPointsXCoordinatesAscending(SurfaceLine2 line)
    {
        return AreGeometryPointsXCoordinatesAscending(line.Geometry.Points);
    }
    
    /// <summary>
    /// Determines whether all characteristic points are in correct shape.
    /// </summary>
    /// <returns><c>true</c> if all characteristic are in correct shape, otherwise <c>false</c></returns>
    public static bool AreAllCharacteristicPointsInCorrectShape(SurfaceLine2 line)
    {
        // when there are no points to check, make sure true is returned.
        var result = true;

        if (line.IsDefined(CharacteristicPointType.DikeToeAtRiver) && line.IsDefined(CharacteristicPointType.DikeTopAtRiver))
        {
            result = line.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtRiver).Z < line.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeTopAtRiver).Z;
        }

        if (line.IsDefined(CharacteristicPointType.DikeToeAtPolder) && line.IsDefined(CharacteristicPointType.DikeTopAtPolder))
        {
            result = result && line.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeToeAtPolder).Z < line.CharacteristicPoints.GetPoint2D(CharacteristicPointType.DikeTopAtPolder).Z;
        }

        return result;
    }

    /// <summary>
    /// Checks if the shape of the dike is proper.
    /// </summary>
    /// <param name="surfaceline">The surfaceline being evaluated.</param>
    /// <returns>The collection of validation results.</returns>
    private IEnumerable<ValidationResult> ValidateDikeShape(SurfaceLine2 surfaceline)
    {
        if (!AreAllCharacteristicPointsInCorrectShape(surfaceline))
        {
            yield return new ValidationResult(ValidationResultType.Error,
                                              this.Translate("ImproperDikeShape"), surfaceline);
        }
    }

    private bool ArePointsAscending(SurfaceLine2 line)
    {
        return AreGeometryPointsXCoordinatesAscending(line.Geometry.Points);
    }

    private static bool AreGeometryPointsXCoordinatesAscending(IList<CharacteristicPoint> characteristicPoints)
    {
        List<Point2D> points = new List<Point2D>();
        foreach (CharacteristicPoint characteristicPoint in characteristicPoints)
        {
            points.Add(characteristicPoint.Point);
        }
        return AreGeometryPointsXCoordinatesAscending(points);
    }
    
    private static bool AreGeometryPointsXCoordinatesAscending(IList<Point2D> points)
    {
        for (var i = 1; i < points.Count; i++)
        {
            if (points[i].X < points[i - 1].X + GeometryConstants.Accuracy)
            {
                // #Bka: in fact we now should return FALSE immediately but there is a snag. Due to faults with adding characteristic 
                //       points to a surface line, some surface lines can have identical points (in Location) but with different 
                //       characteristic (e.g. diketop and trafficload combined). These points should use the same reference to the point
                //       but it occurs that TWO fysical (and identical) points are added.
                //       So these points must now be ignored (so identical points must be seen as OK). This is in fact ok for the purpose
                //       of the validation as the main problem is that points may never give a vertical part in the geometry.
                if ((Math.Abs(points[i].X - points[i - 1].X) < GeometryConstants.Accuracy) && (Math.Abs(points[i].Z - points[i - 1].Z) < GeometryConstants.Accuracy))
                {
                    // Make sure points are made identical
                    points[i].X = points[i - 1].X;
                    points[i].Z = points[i - 1].Z;
                }
                else
                {
                    return false;
                }
            }
        }

        return true;
    }
}