using System;

// =======================================================================================================================
// Class name: TCircularCalculation
//
// Description:
//
// Copyright (c) 2008-2010 Deltares
//
// Date        ID   Modification
// 2010-04-20  Best Created
// 2010-04-20  Sel  Implementation general StabilityCalculation class
// =======================================================================================================================

namespace Deltares.Stability.Calculation.Inner
{
    // TODO -oManders : zones not found
    // , zones
    public abstract class TCircularCalculation : TStabilityCalculation
    {
        // Protected fields
        protected TCentrePoints FCentrePoints = null;
        protected TSlipCircleData FLocalSlipData;
        // FZone: TZones;
        //       protected TRestProfileRec[] FRestProfile;
        // =======================================================================================================================
        // Date        ID   Modification
        // 2010-04-20  Best Created
        // =======================================================================================================================
        //Constructor  Create()
        public TCircularCalculation() : base()
        {
            // TODO: Add any constructor code here
        }

        // procedure TestCirkelOnEntryExitPoints(
        // LXMid, LZMid, LRad: Double; var ANumberofCirkels: Integer; var AXRightIntersect, AXLeftIntersect: TdoubleArray);
        // function TestCenterpointInGeometry(AXMid, AZMid: Double): string;
        // function TestEntyExitPointTooHigh(AZMid, AZR, AZL: Double): string;
        // function TestIntersectsForbiddenLines(AXMid, AZMid, ARadius, AXL, AXR: Double): string;
        // (*
        // {=======================================================================================================================
        // Date        ID   Modification
        // 2008-04-10  Best Created
        // =======================================================================================================================}
        // function TCircularCalculation.TestIntersectsForbiddenLines(AXMid, AZMid, ARadius, AXL, AXR: Double): string;
        // var
        // i: Integer;
        // LFound: Boolean;
        // begin
        // LFound := False;
        // for i := low(FInterfaceData.ForbiddenLines) to High(FInterfaceData.ForbiddenLines) do
        // begin
        // if (FInterfaceData.ForbiddenLines[i].CircleIntersectsForbiddenLine(
        // AXMid, AZMid, ARadius, AXl, AXr)) then
        // begin
        // LFound := True;
        // end;
        // end;
        //
        // if LFound then
        // Result := 'circle intersects forbidden line'
        // else
        // Result := '';
        //
        // end;
        // *)
        // =======================================================================================================================
        //
        // Date        ID   Modification
        // 2008-04-09  Best Created
        // =======================================================================================================================
        protected double DistanceToTangentLine(double AX, double AY)
        {
            double result;
            double A;
            double AA;
            // richtings coef tussen boven en oderkant raaklijn
            double B;
            double Ba;
            double Xs;
            double Ys;
            TSlipCircleData _wvar1 = FInterfaceData.SlipCircleData;
            if ((Math.Abs(_wvar1.TopTangentX - _wvar1.BottomTangentX) < 1.0E-4))
            {
                // horizontale raaklijnen
                result = Math.Abs(AY - _wvar1.BottomTangentZ);
            }
            else
            {
                if ((Math.Abs(_wvar1.BottomTangentZ - _wvar1.TopTangentZ) < 1.0E-4))
                {
                    // vertikale raaklijnen
                    result = Math.Max(Math.Abs(AX - _wvar1.TopTangentX), Math.Abs(AX - _wvar1.BottomTangentX));
                }
                else
                {
                    // helling van lijn door middelpunt
                    A = (_wvar1.BottomTangentZ - _wvar1.TopTangentZ)/(_wvar1.BottomTangentX - _wvar1.TopTangentX);
                    B = AY - A*AX;
                    // lijn door middelpunt y = ax + b
                    // onderste tangent lijn  y = aax + BA
                    AA = -1/A;
                    Ba = _wvar1.BottomTangentZ - _wvar1.BottomTangentX*AA;
                    Xs = (Ba - B)/(A - AA);
                    Ys = Xs*A + B;
                    result = MStabDatafunctions.Distance2D(AX, AY, Xs, Ys);
                }
            }
            return result;
        }

        // Protected methods
        // =======================================================================================================================
        // Descriptiom  From the centerpoint pattern circles are created
        // A check on the validity of the circles is made
        // A valid circle means:
        // an entry and exit point must be lower than the middelpoints
        // A cirkel may not intersect with forbidden lines
        //
        // Date        ID   Modification
        // 2008-03-26  Best Created
        // =======================================================================================================================
        protected void CreateCircles()
        {
            int i;
            int j;
            int k;
            double dx;
            double dz;
            double dr;
            double LXMid;
            double LZMid;
            double LRad;
            double LMaxRad;
            TCentrePoint LCentrePoint;
            double LZTangent;
            FCentrePoints = new TCentrePoints();
            // Validate for each potential circle the exit/entry points
            // lies centre point in geometry
            // Intersects circle a forbidden line
            // bepaal de intervallen tussen de punten
            if ((FLocalSlipData.XIntervalCount > 0))
            {
                dx = (FLocalSlipData.XRightCenterPoint - FLocalSlipData.XLeftCenterPoint)/(FLocalSlipData.XIntervalCount);
            }
            else
            {
                dx = 0.0;
            }
            if ((FLocalSlipData.ZIntervalCount > 0))
            {
                dz = (FLocalSlipData.ZTopCenterPoint - FLocalSlipData.ZBottomCenterPoint)/(FLocalSlipData.ZIntervalCount);
            }
            else
            {
                dz = 0.0;
            }
            if ((FLocalSlipData.TangentIntervalCount > 0))
            {
                dr = MStabDatafunctions.Distance2D(FLocalSlipData.TopTangentX, FLocalSlipData.TopTangentZ, FLocalSlipData.BottomTangentX, FLocalSlipData.BottomTangentZ)/FLocalSlipData.TangentIntervalCount;
            }
            else
            {
                dr = 0.0;
            }
            // zet middelpunten en raaklijnen in resultaat
            for (j = 0; j <= (FLocalSlipData.XIntervalCount); j ++)
            {
                LXMid = FLocalSlipData.XLeftCenterPoint + j*dx;
                for (i = 0; i <= FLocalSlipData.ZIntervalCount; i ++)
                {
                    LZMid = FLocalSlipData.ZBottomCenterPoint + i*dz;
                    LCentrePoint = new TCentrePoint();
                    LCentrePoint.XMid = LXMid;
                    LCentrePoint.ZMid = LZMid;
                    LMaxRad = DistanceToTangentLine(LXMid, LZMid);
                    for (k = 0; k <= (FLocalSlipData.TangentIntervalCount); k ++)
                    {
                        LRad = LMaxRad - k*dr;
                        // straal van raakl
                        // Test if cirkel is correrct cirkel
                        LZTangent = LZMid - LRad;
                        LCentrePoint.Addcircle(LZTangent);
                    }
                    // voeg eventueel het vaste punt toe
                    if ((FLocalSlipData.UseFixedpoint))
                    {
                        LRad = MStabDatafunctions.Distance2D(LXMid, LZMid, FLocalSlipData.XFixed, FLocalSlipData.Zfixed);
                        LZTangent = LZMid - LRad;
                        LCentrePoint.Addcircle(LZTangent);
                    }
                    // Fixed point circle
                    FCentrePoints.AddCentrePoint(LCentrePoint);
                }
                // Loop on Z
            }
            // Loop on x
            // With
        }

        /// <summary>
        /// Create circles with the minimal cicle so far 
        /// in the middle
        /// </summary>
        /// <param name="AMinimumZone"></param>
        protected void CreateCircles(TMinCircleType AMinimumZone)
            //=========================================================

        {
            double dx = (FLocalSlipData.XRightCenterPoint - FLocalSlipData.XLeftCenterPoint);
            double dy = (FLocalSlipData.ZTopCenterPoint - FLocalSlipData.ZBottomCenterPoint);
            double dz = (FLocalSlipData.TopTangentZ - FLocalSlipData.BottomTangentZ);

            //{nu nieuwe gridpunten neerleggen}
            FLocalSlipData.XRightCenterPoint = AMinimumZone.ActiveCentrePointX + 0.5*dx;
            FLocalSlipData.XLeftCenterPoint = AMinimumZone.ActiveCentrePointX - 0.5*dx;

            FLocalSlipData.ZTopCenterPoint = AMinimumZone.ActiveCentrePointY + 0.5*dy;
            FLocalSlipData.ZBottomCenterPoint = AMinimumZone.ActiveCentrePointY - 0.5*dy;

            double tangent = AMinimumZone.ActiveCentrePointY - AMinimumZone.ActiveCentrePointRad;
            FLocalSlipData.TopTangentZ = tangent + 0.5*dz;
            FLocalSlipData.BottomTangentZ = tangent - 0.5*dz;

            CreateCircles();
        }
    }

    // end TCircularCalculation
}