using System;
using System.Collections.Generic;

// =======================================================================================================================
// Class name:
//
// Description:
//
// Copyright (c) 2008 Deltares
//
// Date        ID   Modification
// 2008-04-17  Best Created
// =======================================================================================================================

namespace Deltares.Stability.Calculation.Inner
{
    public class TCentrePoint
    {
        private string FCentrePointMessage = String.Empty;
        private List<TSingleResultData> FCircles = new List<TSingleResultData>();
        private int FMinCircelNumber = 0;
        private double FMinFactor = 0;
        // Minimum  stability factor from center point
        private double FRadMinFactor = 0;
        private double FXMid = 0;
        private double FZMid = 0;

        public TCentrePoint() : base()
        {
            FCentrePointMessage = "";
        }

        //Constructor  CreateandCopy( ACentrePoint)
        public TCentrePoint(TCentrePoint ACentrePoint) : base()
        {
            if ((ACentrePoint != null))
            {
                FCentrePointMessage = ACentrePoint.CentrePointMessage;
                FXMid = ACentrePoint.XMid;
                FZMid = ACentrePoint.ZMid;
                FMinFactor = ACentrePoint.MinFactor;
                FRadMinFactor = ACentrePoint.RadMinFactor;
                FCircles.AddRange(ACentrePoint.circles);
                FMinCircelNumber = ACentrePoint.MinCircelNumber;
            }
        }

        public string CentrePointMessage
        {
            get
            {
                return FCentrePointMessage;
            }
            set
            {
                FCentrePointMessage = value;
            }
        }

        public double XMid
        {
            get
            {
                return FXMid;
            }
            set
            {
                FXMid = value;
            }
        }

        public double ZMid
        {
            get
            {
                return FZMid;
            }
            set
            {
                FZMid = value;
            }
        }

        public double MinFactor
        {
            get
            {
                return FMinFactor;
            }
            set
            {
                FMinFactor = value;
            }
        }

        public double RadMinFactor
        {
            get
            {
                return FRadMinFactor;
            }
            set
            {
                FRadMinFactor = value;
            }
        }

        public List<TSingleResultData> circles
        {
            get
            {
                return FCircles;
            }
        }

        public int MinCircelNumber
        {
            get
            {
                return FMinCircelNumber;
            }
            set
            {
                FMinCircelNumber = value;
            }
        }

        // Private Declarations

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-04-17  Best Created
        // =======================================================================================================================
        public void Addcircle(double AZTangent)
        {
            FCircles.Add(new TSingleResultData());
            FCircles[FCircles.Count - 1].ZTangent = AZTangent;
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-04-17  Best Created
        // =======================================================================================================================
        public void AddCalculatedcircles(TSingleResultData[] AHulpcircles)
        {
            int i;
            int j;
            bool LFound;
            for (i = 0; i < FCircles.Count; i ++)
            {
                LFound = false;
                circles[i].CircleMessage = "";
                j = 0;
                while (!LFound)
                {
                    if ((Math.Abs(circles[i].ZTangent - AHulpcircles[j].ZTangent) < Constants.CGeoAccu))
                    {
                        if ((Math.Abs(circles[i].XLeft - AHulpcircles[j].XLeft) < Constants.CGeoAccu) && (Math.Abs(circles[i].XRight - AHulpcircles[j].XRight) < Constants.CGeoAccu))
                        {
                            LFound = true;
                            circles[i].FStability = AHulpcircles[j].FStability;
                            circles[i].FReliability = AHulpcircles[j].FReliability;
                            circles[i].CircleMessage = AHulpcircles[j].CircleMessage;
                        }
                    }
                    j ++;
                }
            }
        }

        // =======================================================================================================================
        // Date        ID   Modification
        // 2008-12-03  Best Created
        // =======================================================================================================================
        public void DetermineMinimumSafetyFactor()
        {
            int i;
            FMinCircelNumber = 0;
            FMinFactor = Constants.CFMinStart;
            for (i = 0; i < FCircles.Count; i ++)
            {
                if ((circles[i].CircleMessage == Constants.cSucces))
                {
                    if ((circles[i].FStability < FMinFactor))
                    {
                        FMinFactor = circles[i].FStability;
                        FRadMinFactor = FZMid - circles[i].ZTangent;
                        FMinCircelNumber = i;
                    }
                }
            }
        }
    }

    // end TCentrePoint
}