using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using Deltares.Geometry;
using Deltares.Geotechnics;
using Deltares.MStab;
using Deltares.Stability.Calculation.Inner;
#if DELPHI
using InterfaceData;
using MStabDataTypes;
#else

#endif

namespace Deltares.Stability.Calculation
{
    [Serializable]
    public class WaternetException : Exception
    {
        //
        // For guidelines regarding the creation of new exception types, see
        //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
        // and
        //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
        //

        public WaternetException() {}

        public WaternetException(string message)
            : base(message) {}

        public WaternetException(string message, Exception inner)
            : base(message, inner) {}

        protected WaternetException(
            SerializationInfo info,
            StreamingContext context)
            : base(info, context) {}
    }

    public static partial class LoadObjects
    {
        public static void LoadWaternet(MStabProject project, ref TInterfaceData aStabilityObjects)
        {
            if (project == null)
            {
                throw new WaternetException("Empty project");
            }

            if (project.Geotechnics == null)
            {
                throw new WaternetException("Empty Waternet");
            }

            if ((project.Geotechnics.Waternets.Count > 0) && project.Geotechnics.CurrentWaternet == null)
            {
                project.Geotechnics.CurrentWaternet = project.Geotechnics.Waternets[0];
            }

            bool multipleWaternets = project.Geotechnics.UseWaterData && project.Stability.IsReliability;

            if (multipleWaternets)
            {
                aStabilityObjects.Waternets = new TWaternet[project.Geotechnics.Waternets.Count];
            }
            else
            {
                aStabilityObjects.Waternets = new TWaternet[1];
            }

            for (int w = 0; w < project.Geotechnics.Waternets.Count; w++)
            {
                Waternet waternet = project.Geotechnics.Waternets[w];

                if (multipleWaternets || waternet == project.Geotechnics.CurrentWaternet)
                {
                    int index = multipleWaternets ? w : 0;

                    aStabilityObjects.Waternets[index].PhreaticLineNumber = -1;
                    aStabilityObjects.Waternets[index].GammaWater = waternet.UnitWeight;
                    aStabilityObjects.Waternets[index].ExternalWaterLevel = waternet.ExternalWaterLevel;
                    aStabilityObjects.Waternets[index].WaternetName = waternet.Name;

                    List<GeometryPointString> headlines = waternet.SelectableHeadlines;

                    aStabilityObjects.Waternets[index].PLLines = new TPoints[headlines.Count][];
                    for (int i = 0; i < headlines.Count; i++)
                    {
                        aStabilityObjects.Waternets[index].PLLines[i] = new TPoints[headlines[i].Points.Count];
                        if (headlines[i] == waternet.PhreaticLine)
                        {
                            aStabilityObjects.Waternets[index].PhreaticLineNumber = i;
                        }

                        for (int j = 0; j < headlines[i].Points.Count; j++)
                        {
                            aStabilityObjects.Waternets[index].PLLines[i][j].XCoor = headlines[i].Points[j].X;
                            aStabilityObjects.Waternets[index].PLLines[i][j].ZCoor = headlines[i].Points[j].Z;
                        }
                    }

                    aStabilityObjects.Waternets[index].Waterlines =
                        new TWaterLineRecord[waternet.WaternetLineList.Count];
                    for (int k = 0; k < waternet.WaternetLineList.Count; k++)
                    {
                        WaternetLine waternetLine = waternet.WaternetLineList[k];

                        if (waternetLine.HeadLine == null)
                        {
                            aStabilityObjects.Waternets[index].Waterlines[k].PLLineNumber = -1;
                        }
                        else
                        {
                            aStabilityObjects.Waternets[index].Waterlines[k].PLLineNumber =
                                headlines.IndexOf(waternetLine.HeadLine);
                        }

                        var tempXCoords = new List<Double>();
                        var tempZCoords = new List<Double>();

                        aStabilityObjects.Waternets[index].Waterlines[k].Waterline =
                            new TPoints[waternet.WaternetLineList[k].Points.Count];
                        for (int p = 0; p < waternet.WaternetLineList[k].Points.Count; p++)
                        {
                            aStabilityObjects.Waternets[index].Waterlines[k].Waterline[p].XCoor =
                                waternet.WaternetLineList[k].Points[p].X;
                            aStabilityObjects.Waternets[index].Waterlines[k].Waterline[p].ZCoor =
                                waternet.WaternetLineList[k].Points[p].Z;
                        }
                    }

                    if (waternet == project.Geotechnics.CurrentWaternet)
                    {
                        aStabilityObjects.CurrentWaternet = aStabilityObjects.Waternets[index];
                    }
                }
            }

            var externalLevelFrequency = new TExternalLevelFrequency();

            externalLevelFrequency.DesignLevel = project.Geotechnics.DesignLevel;
            externalLevelFrequency.DecimationHeigth = project.Geotechnics.DecimateHeight;

            switch (project.Geotechnics.ExceedingFrequency)
            {
                case ExeedingFrequency.OneByTenThousand:
                    externalLevelFrequency.ExceedingFrequency = TExceedingFrequencySet.efTenThousand;
                    break;
                case ExeedingFrequency.OneByFourThousand:
                    externalLevelFrequency.ExceedingFrequency = TExceedingFrequencySet.efFourThousand;
                    break;
                case ExeedingFrequency.OneByTwoThousand:
                    externalLevelFrequency.ExceedingFrequency = TExceedingFrequencySet.efTwoThousend;
                    break;
                case ExeedingFrequency.OneByThousandTwoFifty:
                    externalLevelFrequency.ExceedingFrequency = TExceedingFrequencySet.efTwelveFifty;
                    break;
            }

            aStabilityObjects.ExternallevelFrequency = externalLevelFrequency;
        }
    }
}