using Deltares.Mathematics;

namespace Deltares.Stability.Calculation2
{
    public class GeneticAlgorithmDualCircleCalculation : SlidingCurvesProcessor, IExtremeCalculation
    {
        private GeneticAlgorithm geneticAlgorithm = new GeneticAlgorithm();
        private SlipCircleGrid leftGridActive;
        private SlidingCurve minimumSlidingCurve = null;
        private SlipCircleGrid rightGridPassive;
        private SlipCircleTangentLine slipCircleTangentLine;
        private SlipPlaneUpliftVan slipPlaneUpliftVan;

        public GeneticAlgorithmDualCircleCalculation(StabilityModel stabilityModel)
        {
            slipPlaneUpliftVan = stabilityModel.SlipPlaneUpliftVan;
            //TODO: check slipPlaneUplift.SlipPlaneLeftGrid or right
            leftGridActive = slipPlaneUpliftVan.SlipPlaneLeftGrid;
            rightGridPassive = slipPlaneUpliftVan.SlipPlaneRightGrid;
            slipCircleTangentLine = slipPlaneUpliftVan.SlipPlaneTangentLine;
        }

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

            // Set options
            geneticAlgorithm.GenomeCount = 5;
            // Set the bounds for the genetic algorithm; the radius is composed of middle point and tangent line
            geneticAlgorithm.SetBounds(0, new TBounds(leftGridActive.GridXLeft, leftGridActive.GridXRight - leftGridActive.GridXLeft));
            geneticAlgorithm.SetBounds(1, new TBounds(leftGridActive.GridZBottom, leftGridActive.GridZTop - leftGridActive.GridZBottom));
            geneticAlgorithm.SetBounds(2, new TBounds(rightGridPassive.GridXLeft, rightGridPassive.GridXRight - rightGridPassive.GridXLeft));
            geneticAlgorithm.SetBounds(3, new TBounds(rightGridPassive.GridZBottom, rightGridPassive.GridZTop - rightGridPassive.GridZBottom));
            geneticAlgorithm.SetBounds(4, new TBounds(slipCircleTangentLine.TangentLineZBottom, slipCircleTangentLine.TangentLineZTop - slipCircleTangentLine.TangentLineZBottom));

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

            minimumSlidingCurve = null;
        }

        public override SlidingCurve Calculate()
        {
            minimumSlidingCurve = null;

            // Determine safety factor
            geneticAlgorithm.Calculation();

            return minimumSlidingCurve;
        }

        public double ComputeExtremeResult(double[] AGenome)
        {
            // Create uplift circle and pass data
            var slidingCircle = new SlidingDualCircle();
            slidingCircle.ActiveCircle.X = AGenome[0];
            slidingCircle.ActiveCircle.Y = AGenome[1];
            slidingCircle.PassiveCircle.X = AGenome[2];
            slidingCircle.PassiveCircle.Y = AGenome[3];
            slidingCircle.TangentLine = AGenome[4];
            slidingCircle.LeftCircleIsActive = slipPlaneUpliftVan.SlipPlaneLeftGrid.GridXLeft < slipPlaneUpliftVan.SlipPlaneRightGrid.GridXLeft;

            double stabilityFactor = GetSafetyFactor(slidingCircle);

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

            return stabilityFactor;
        }
    }
}