using System;

namespace Deltares.Stability.Calculation.Inner

{
    public class TTreeOnSlope
    {
        private double FAngleOfDistribution = 0;
        private bool FIsUsed = false;
        private TLineLoad FLineLoad;
        private int FLineLoadIndex = 0;
        private TPoints[] FSurfaceLine;
        private TUniformLoad FUniformLoading;
        private int FUniformLoadingIndex = 0;
        private TUniformLoad FUniformUnLoading;
        private int FUniformUnloadingIndex = 0;
        private double FWidthOfRootZone = 0;
        private double FWindForce = 0;
        private double FXCoordinate = 0;
        private double FZCoordinate = 0;

        public double WindForce
        {
            get
            {
                return FWindForce;
            }
            set
            {
                FWindForce = value;
            }
        }

        public double XCoordinate
        {
            get
            {
                return FXCoordinate;
            }
            set
            {
                FXCoordinate = value;
            }
        }

        public double ZCoordinate
        {
            get
            {
                return FZCoordinate;
            }
            set
            {
                FZCoordinate = value;
            }
        }

        public double WidthOfRootZone
        {
            get
            {
                return FWidthOfRootZone;
            }
            set
            {
                FWidthOfRootZone = value;
            }
        }

        public double AngleOfDistribution
        {
            get
            {
                return FAngleOfDistribution;
            }
            set
            {
                FAngleOfDistribution = value;
            }
        }

        public TUniformLoad UniformLoading
        {
            get
            {
                return FUniformLoading;
            }
            set
            {
                FUniformLoading = value;
            }
        }

        public TUniformLoad UniformUnLoading
        {
            get
            {
                return FUniformUnLoading;
            }
            set
            {
                UniformUnLoading = value;
            }
        }

        public TLineLoad LineLoad
        {
            get
            {
                return FLineLoad;
            }
            set
            {
                FLineLoad = value;
            }
        }

        public bool IsUsed
        {
            get
            {
                return FIsUsed;
            }
            set
            {
                FIsUsed = value;
            }
        }

        public int UniformLoadingIndex
        {
            get
            {
                return FUniformLoadingIndex;
            }
            set
            {
                FUniformLoadingIndex = value;
            }
        }

        public int UniformUnloadingIndex
        {
            get
            {
                return FUniformUnloadingIndex;
            }
            set
            {
                FUniformUnloadingIndex = value;
            }
        }

        public int LineLoadIndex
        {
            get
            {
                return FLineLoadIndex;
            }
            set
            {
                FLineLoadIndex = value;
            }
        }

        public TPoints[] SurfaceLine
        {
            get
            {
                return FSurfaceLine;
            }
            set
            {
                FSurfaceLine = value;
            }
        }

        public void CreateLoads()
        {
            double LYAtBottom;
            double LMoment;
            double LMagnitude;
            double LDirAngle;
            double LDefaultDistriAngle;
            if (Math.Abs(FWindForce) > 0)
            {
                //  define direction for line loads
                if (FWindForce > 0)
                {
                    LDirAngle = -89.9;
                }
                else
                {
                    LDirAngle = +89.9;
                }

                LDefaultDistriAngle = 45;

                // Calculate the magnitude of the uniform loads
                // first find the moments on the soil
                LYAtBottom = MStabDatafunctions.ZTopAtSurface(FXCoordinate, FSurfaceLine);
                LMoment = FWindForce*(FZCoordinate - LYAtBottom);

                // force = magnitude * 0.5 RootsWidth, Moment = force *  0.5 RootsWidth 
                LMagnitude = Math.Abs(4*LMoment/(FWidthOfRootZone*FWidthOfRootZone));

                //Create the uniform loads simulating the moment at soil by the roots}
                FUniformLoading = new TUniformLoad();

                FUniformUnLoading = new TUniformLoad();

                //Start and end of uniform loads}
                if (LMoment > 0)
                {
                    FUniformLoading.Xstart = FXCoordinate;
                    FUniformLoading.Xend = FXCoordinate + 0.5*FWidthOfRootZone;
                    FUniformUnLoading.Xstart = FXCoordinate - 0.5*FWidthOfRootZone;
                    FUniformUnLoading.Xend = FXCoordinate;
                }
                else
                {
                    FUniformUnLoading.Xstart = FXCoordinate;
                    FUniformUnLoading.Xend = FXCoordinate + 0.5*FWidthOfRootZone;
                    FUniformLoading.Xstart = FXCoordinate - 0.5*FWidthOfRootZone;
                    FUniformLoading.Xend = FXCoordinate;
                }

                //{magnitude
                FUniformLoading.Magnitude = LMagnitude;
                FUniformUnLoading.Magnitude = -LMagnitude;

                // name
                FUniformLoading.UniformLoadName = "Rootloading";
                FUniformUnLoading.UniformLoadName = "Rootunloading";

                // distribution angle
                FUniformLoading.DistributionAngle = FAngleOfDistribution;
                FUniformUnLoading.DistributionAngle = FAngleOfDistribution;

                //{Create the line load
                FLineLoad = new TLineLoad();
                ;
                FLineLoad.Magnitude = Math.Abs(FWindForce);
                FLineLoad.X = FXCoordinate;
                FLineLoad.Z = LYAtBottom;
                FLineLoad.DirectionAngle = LDirAngle;
                FLineLoad.DistributionAngle = LDefaultDistriAngle;
            }
        }
    }
}