using System.Collections.Generic;
using System.Xml.Serialization;
using Deltares.Geometry;
using Deltares.Geotechnics;
using Deltares.Standard;
using Deltares.Standard.Attributes;
using Deltares.Standard.Data;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.Extensions;

namespace Deltares.Stability
{
    public enum StressMode
    {
        CriticalCircle,
        TotalStress,
        EffectiveStress,
        ShearStress,
        HydrostaticPorePressure,
        PiezometricPorePressure,
        TotalPorePressure,
        DegreeOfConsolidationPorePressure
    }

    public class SlidingCurve : GeometryObject
    {
        private static StressMode currentStressMode = StressMode.EffectiveStress;
        private readonly DelegatedList<Slice> slices = new DelegatedList<Slice>();
        private List<GeotextileResults> geotextileResults = new List<GeotextileResults>();
        private GeometryPoint leftPoint = null;
        private double maximumSliceWidth;
        private GeometryPoint rightPoint = null;
        private double safetyFactor = 0;

        public SlidingCurve()
        {
            slices.AddMethod = AddSlice;
        }

        [XmlIgnore]
        public static StressMode CurrentStressMode
        {
            get
            {
                return currentStressMode;
            }
            set
            {
                currentStressMode = value;
            }
        }

        [Label("Safety factor")]
        [Format("F3")]
        public double SafetyFactor
        {
            get
            {
                return safetyFactor;
            }
            set
            {
                safetyFactor = value;
            }
        }

        public IList<Slice> Slices
        {
            get
            {
                return slices;
            }
        }

        public List<GeotextileResults> GeotextileResults
        {
            get
            {
                return geotextileResults;
            }
        }

        public GeometryPoint LeftPoint
        {
            get
            {
                return leftPoint;
            }
            set
            {
                leftPoint = value;
            }
        }

        public GeometryPoint RightPoint
        {
            get
            {
                return rightPoint;
            }
            set
            {
                rightPoint = value;
            }
        }

        public double MaximumSliceWidth
        {
            get
            {
                return maximumSliceWidth;
            }
            set
            {
                DataEventPublisher.BeforeChange(this, "MaximumSliceWidth");
                maximumSliceWidth = value;
                DataEventPublisher.AfterChange(this, "MaximumSliceWidth");
            }
        }

        public void SetSliceIndices()
        {
            Slices.Sort();
            for (int i = 0; i < Slices.Count; i++)
            {
                Slices[i].Index = i;
            }
        }

        public void UpdatePhiInSlices(double ANewmValue, List<int> SliceIndexes)
        {
            for (int i = 0; i < SliceIndexes.Count; i++)
            {
                if (!(Slices[i] == null))
                {
                    Slices[i].Phi = ANewmValue;
                }
            }
        }

        public void UpdateCohesioniInSlices(double ANewmValue, List<int> SliceIndexes)
        {
            for (int i = 0; i < SliceIndexes.Count; i++)
            {
                if (!(Slices[i] == null))
                {
                    Slices[i].Cohesion = ANewmValue;
                }
            }
        }

        private void AddSlice(Slice slice)
        {
            slice.SlidingCurve = this;
        }
    }
}