using Deltares.Mathematics;

// =======================================================================================================================
// Class name: THorizontalBalanceCalculation
//
// Description:
//
// Copyright (c) 1993-2010 Deltares
//
// Date        ID   Modification
// 2010-06-17       Created
// =======================================================================================================================

namespace Deltares.Stability.Calculation.Inner
{
    public class THorizontalBalanceCalculation : TStabilityCalculation
    {
        private double FDeltaZ = 0;
        private double FGammaWater = 0;
        private int FNZInterval = 0;
        private double FXLeft = 0;
        private double FXRight = 0;
        private double FZBottom = 0;
        private double FZFreaLeft = 0;
        private double FZFreaRight = 0;
        private double FZTop = 0;

        // procedure SlipPlaneHeadOutputUitvoer;
        // procedure SlipPlanelUitvoer(AXL, AXR, AY, AF: Double);
        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-06-17       Created
        // =======================================================================================================================
        public override void CreateShortCuts()
        {
            THorizontalbalanceData LHorizontalBalanceData;
            // inherited
            LHorizontalBalanceData = FInterfaceData.GetHorizontalBalance();
            FXLeft = LHorizontalBalanceData.XCoorMin;
            FXRight = LHorizontalBalanceData.XCoormax;
            FZFreaLeft = DetermineFreaticlevelAtX(FXLeft);
            FZFreaRight = DetermineFreaticlevelAtX(FXRight);
            FZTop = LHorizontalBalanceData.ZCoorTop;
            FZBottom = LHorizontalBalanceData.ZCoorMin;
            FNZInterval = LHorizontalBalanceData.NumberOfIntervalOnZ;
            FDeltaZ = (FZTop - FZBottom)/FNZInterval;
            FGammaWater = FInterfaceData.CurrentWaternet.GammaWater;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2007-04-24  Best Created
        // 2007-05-23  Zant PeatDikeData record replaced by object.
        // 2007-06-06  Vks  Renamed *STPeatDikePlane into *STHorizontalBalancePlane.
        // =======================================================================================================================
        public override void CalculationGrid()
        {
            int i;
            double LZBot;
            THorizontalBalancePlane LHorPlane;
            double LStabValue;
            THorizontalBalancePlane LMinplane;
            THorizontalBalanceResult LBalanceResult;
            TSingleHorizontalBalanceResult LSingleBalanceResult;
            int LNSlices;
            CreateShortCuts();
            FMinStabilityFactor = Constants.CFMinStart;
            LMinplane = null;
            LBalanceResult = new THorizontalBalanceResult();
            for (i = 0; i <= FNZInterval; i ++)
            {
                LZBot = FZBottom + i*FDeltaZ;
                LHorPlane = new THorizontalBalancePlane();
                LHorPlane.InterfaceData = FInterfaceData;
                LHorPlane.XLeftSurface = FXLeft;
                LHorPlane.XRightSurface = FXRight;
                LHorPlane.ZFreaLeft = FZFreaLeft;
                LHorPlane.ZFreaRight = FZFreaRight;
                LHorPlane.ZTangent = LZBot;
                LHorPlane.GamWater = FGammaWater;
                LStabValue = LHorPlane.SafetyFactor;
                // put results in dump
                LSingleBalanceResult.HorizontalForceleft = LHorPlane.Hor1;
                LSingleBalanceResult.HorizontalForceRight = LHorPlane.Hor2;
                LSingleBalanceResult.Resisting = LHorPlane.Resisting;
                LSingleBalanceResult.XRight = FXRight;
                LSingleBalanceResult.XLeft = FXLeft;
                LSingleBalanceResult.Safety = LStabValue;
                LSingleBalanceResult.ZTangent = LZBot;
                LBalanceResult.AddResult(LSingleBalanceResult);
                if ((LStabValue < FMinStabilityFactor))
                {
                    FMinStabilityFactor = LStabValue;
                    LMinplane = LHorPlane;
                }
            }
            // dump minimum stability factor
            // FillDump
            if ((LMinplane != null))
            {
                LNSlices = LMinplane.NSlices;
                LBalanceResult.AddSliceDimension(LNSlices);
                for (i = 0; i < LNSlices; i ++)
                {
                    LBalanceResult.Slices[i] = new Tslice(LMinplane.GetSlice(i));
                }
                LBalanceResult.MinStability = FMinStabilityFactor;
                FDumpData.Horizontalbalance.Add(LBalanceResult);
            }
        }

        public override void CalculationGA(GeneticAlgorithm AGeneticAlgorithm)
        {
            CalculationGrid();
        }

        public override void CalculationLM(LevenbergMarquardtExtreme ALevenbergMarquardt)
        {
            CalculationGrid();
        }

        private double DetermineFreaticlevelAtX(double AXCoor)
        {
            double result;
            result = MStabDatafunctions.ZTopAtSurface(AXCoor, FInterfaceData.CurrentWaternet.PLLines[FInterfaceData.CurrentWaternet.PhreaticLineNumber]);
            return result;
        }
    }

    // end THorizontalBalanceCalculation
}