using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.Serialization;

namespace Deltares.MStab.IO.Classic
{
    [Serializable]
    public class ClassicGeometryException : 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 ClassicGeometryException() {}

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

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

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

    /// <summary>
    /// Access parameters from Classic Input files with help of DGSSerializer.dll
    /// </summary>
    internal static class GetClassicGeometry
    {
        public static void GetClassicGeometryPoints(int handle, ref List<ClassicGeometryFunctionDefinitions.GeometryPoint> aGeometryPoints)
        {
            try
            {
                if (aGeometryPoints == null)
                {
                    aGeometryPoints = new List<ClassicGeometryFunctionDefinitions.GeometryPoint>();
                }

                aGeometryPoints.Clear();
                int index = 0;
                bool bContinue = true;

                var geopoint = new ClassicGeometryFunctionDefinitions.GeometryPoint();
                while (bContinue)
                {
                    index++;
                    bContinue = ClassicGeometryFunctionDefinitions.ClassicGetGeoPoint(handle, index, ref geopoint);
                    aGeometryPoints.Add(geopoint);
                }
            }
            catch (Exception e)
            {
                Debug.Assert(false, e.ToString());
            }
        }

        public static void GetClassicGeometryCurves(int handle, ref List<ClassicGeometryFunctionDefinitions.GeometryCurve> aGeometryCurves)
        {
            try
            {
                if (aGeometryCurves == null)
                {
                    aGeometryCurves = new List<ClassicGeometryFunctionDefinitions.GeometryCurve>();
                }

                int index = 0;
                bool bContinue = true;

                var geocurve = new ClassicGeometryFunctionDefinitions.GeometryCurve();
                while (bContinue)
                {
                    index++;
                    bContinue = ClassicGeometryFunctionDefinitions.ClassicGetGeoCurves(handle, index, ref geocurve);
                    aGeometryCurves.Add(geocurve);
                }
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public static void GetClassicGeometryBoundaries(int handle, ref ClassicGeometryFunctionDefinitions.GeometryBoundaries aGeometryBoundaries)
        {
            try
            {
                if (aGeometryBoundaries == null)
                {
                    aGeometryBoundaries = new ClassicGeometryFunctionDefinitions.GeometryBoundaries();
                }

                if (!ClassicGeometryFunctionDefinitions.ClassicGetGeoBoundaries(handle, ref aGeometryBoundaries))
                {
                    throw new ClassicGeometryException("Could not get classic geometry boundaries");
                }
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public static void GetClassicGeometryPiezoLines(int handle, ref ClassicGeometryFunctionDefinitions.GeometryPiezoLines aGeometryPiezoLines)
        {
            try
            {
                if (aGeometryPiezoLines == null)
                {
                    aGeometryPiezoLines = new ClassicGeometryFunctionDefinitions.GeometryPiezoLines();
                }
                if (!ClassicGeometryFunctionDefinitions.ClassicGetGeoPiezoLines(handle, ref aGeometryPiezoLines))
                {
                    throw new ClassicGeometryException("Could not get classic geometry piezo lines");
                }
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public static void GetClassicGeometryLayers(int handle, ref ClassicGeometryFunctionDefinitions.GeometryLayers aGeometryLayers)
        {
            try
            {
                var Buffer = new char[1024];
                if (aGeometryLayers == null)
                {
                    aGeometryLayers = new ClassicGeometryFunctionDefinitions.GeometryLayers();
                    aGeometryLayers.layers = new ClassicGeometryFunctionDefinitions.GeoLayer[ClassicGeometryFunctionDefinitions.GeometryConstants.maxLayers];

                    for (int layer = 0; layer < ClassicGeometryFunctionDefinitions.GeometryConstants.maxLayers; layer++)
                    {
                        aGeometryLayers.layers[layer].materialOfLayer = new string(Buffer);
                    }
                }

                if (!ClassicGeometryFunctionDefinitions.ClassicGetGeoLayers(handle, ref aGeometryLayers))
                {
                    throw new ClassicGeometryException("Could not get classic geometry layers");
                }
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public static void GetClassicGeometryConstants(int handle, ref ClassicGeometryFunctionDefinitions.GeometryParam aGeometryParam)
        {
            try
            {
                if (aGeometryParam == null)
                {
                    aGeometryParam = new ClassicGeometryFunctionDefinitions.GeometryParam();
                }
                if (!ClassicGeometryFunctionDefinitions.ClassicGetGeoConstants(handle, ref aGeometryParam))
                {
                    throw new ClassicGeometryException("Could not get classic geometry parameters");
                }
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public static void GetClassicPiezoLines(int handle, ref ClassicGeometryFunctionDefinitions.GeometryPiezoLines aPiezoLines)
        {
            try
            {
                if (aPiezoLines == null)
                {
                    aPiezoLines = new ClassicGeometryFunctionDefinitions.GeometryPiezoLines();
                }
                if (!ClassicGeometryFunctionDefinitions.ClassicGetGeoPiezoLines(handle, ref aPiezoLines))
                {
                    throw new ClassicGeometryException("Could not get classic geometry parameters");
                }
            }
            catch (Exception e)
            {
                throw e;
            }
        }
    }
}