using Deltares.Mathematics;
using Deltares.Standard;

namespace Deltares.Stability.Calculation2
{
    public class GeneticAlgorithmSingleCircleCalculation : SlidingCurvesProcessor, IExtremeCalculation
    {
        private SlipCircleGrid calculationgrid;
        private GeneticAlgorithm geneticAlgorithm = new GeneticAlgorithm();
        private SlidingCircle minimumSlidingCurve = null;
        private SlipCircleTangentLine tangentLine;

        public GeneticAlgorithmSingleCircleCalculation(SlipCircle slipCircle)
        {
            calculationgrid = slipCircle.SlipCircleGrid;
            tangentLine = slipCircle.SlipCircleTangentLine;
        }

        public override void Initialize(StabilityModel stabilityModel)
        {
            base.Initialize(stabilityModel);

            geneticAlgorithm.GeneticAlgorithmOptions = stabilityModel.GeneticAlgorithmOptions;

            // Set options
            geneticAlgorithm.GenomeCount = 3;
            // Set the bounds for the genetic algorithm; the radius is composed of middle point and tanggeent line

            geneticAlgorithm.SetBounds(0, new TBounds(calculationgrid.GridXLeft, calculationgrid.GridXRight - calculationgrid.GridXLeft));
            geneticAlgorithm.SetBounds(1, new TBounds(calculationgrid.GridZBottom, calculationgrid.GridZTop - calculationgrid.GridZBottom));
            geneticAlgorithm.SetBounds(2, new TBounds(tangentLine.TangentLineZBottom, tangentLine.TangentLineZTop - tangentLine.TangentLineZBottom));

            // Communicate the address of the calculation
            geneticAlgorithm.GeneticCalculation = this;
        }

        public override SlidingCurve Calculate()
        {
            minimumSlidingCurve = null;

            // Determine safety factor
            geneticAlgorithm.Calculation();

            return minimumSlidingCurve;
        }

        public double ComputeExtremeResult(double[] AGenome)
        {
            var slidingCircle = new SlidingCircle();
            slidingCircle.Center = new Point2D(AGenome[0], AGenome[1]);
            slidingCircle.Radius = AGenome[1] - AGenome[2];

            // LBishopSlipCirkel.InterfaceData = this.FInterfaceData;
            // Calculation
            double stabilityFactor = GetSafetyFactor(slidingCircle);

            if (minimumSlidingCurve == null || stabilityFactor < minimumSlidingCurve.SafetyFactor)
            {
                minimumSlidingCurve = slidingCircle;
            }

            return stabilityFactor;
        }
    }
}