using System;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading;
using Deltares.Geometry;
using Deltares.Geotechnics.GeotechnicalGeometry;
using Deltares.Geotechnics.IO.Importers.Exception;
using Deltares.Standard;
using Deltares.Standard.EventPublisher;
using Deltares.Standard.IO;
using Deltares.Standard.Language;
using Deltares.Standard.Logging;
using LumenWorks.Framework.IO.Csv;

namespace Deltares.Geotechnics.IO.Importers
{
    public class CharacteristicPointsImporter : Importer
    {
        /// <summary>
        /// This was the original (public) read used by DAM
        /// </summary>
        /// <param name="fileName">Name of the file.</param>
        /// <param name="surfaceLines">The surface lines.</param>
        /// <remarks>Note: This method will remove entries from <paramref name="surfaceLines"/> if
        /// an error occurred while adding characteristic points to a particular entry.</remarks>
        public void Read(string fileName, List<SurfaceLine2> surfaceLines)
        {
            Type = typeof(SurfaceLine2);

            CultureInfo oldcur = Thread.CurrentThread.CurrentCulture;
            DataEventPublisher.InvokeWithoutPublishingEvents(() =>
                {
                    try
                    {
                        Thread.CurrentThread.CurrentCulture = CsvReaderUtilities.DetermineCultureForFile(fileName);

                        using (var csv = new CsvReader(new StreamReader(fileName), true, ';'))
                        {
                            var headers = GetCharacteristicPointsFileHeader(fileName, csv);

                            var indexes = GetHeaderIndexes(fileName, headers);

                            int recordCount = 0;

                            while (csv.ReadNextRecord())
                            {
                                SurfaceLine2 surfaceLine = null;
                                recordCount++;
                                // Used to keep track of characteristic points that are required to be specified but couldn't be added.
                                bool charCheck = true;
                                try
                                {
                                    surfaceLine = GetSurfacelineForDataRow(surfaceLines, csv, indexes);
                                    charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.MaaiveldBinnenwaarts, csv, CharacteristicPointType.SurfaceLevelInside);
                                    if (charCheck && indexes.InsteekSlootPolderzijde.X > 0)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.InsteekSlootPolderzijde, csv, CharacteristicPointType.DitchPolderSide);
                                    }
                                    if (charCheck && indexes.SlootbodemPolderzijde.X > 0)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.SlootbodemPolderzijde, csv, CharacteristicPointType.BottomDitchPolderSide);
                                    }
                                    if (charCheck && indexes.SlootbodemDijkzijde.X > 0)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.SlootbodemDijkzijde, csv, CharacteristicPointType.BottomDitchDikeSide);
                                    }
                                    if (charCheck && indexes.InsteekSlootDijkzijde.X > 0)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.InsteekSlootDijkzijde, csv, CharacteristicPointType.DitchDikeSide);
                                    }
                                    if (charCheck)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.TeenDijkBinnenwaarts, csv, CharacteristicPointType.DikeToeAtPolder);
                                    }
                                    if (charCheck && indexes.KruinBinnenberm.X > 0)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.KruinBinnenberm, csv, CharacteristicPointType.ShoulderTopInside);
                                    }
                                    if (charCheck && indexes.InsteekBinnenberm.X > 0)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.InsteekBinnenberm, csv, CharacteristicPointType.ShoulderBaseInside);
                                    }
                                    if (charCheck)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.KruinBinnentalud, csv, CharacteristicPointType.DikeTopAtPolder);
                                    }
                                    if (charCheck && indexes.VerkeersbelastingKantBinnenwaarts.X > 0)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.VerkeersbelastingKantBinnenwaarts, csv, CharacteristicPointType.TrafficLoadInside);
                                    }
                                    if (charCheck && indexes.VerkeersbelastingKantBuitenwaarts.X > 0)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.VerkeersbelastingKantBuitenwaarts, csv, CharacteristicPointType.TrafficLoadOutside);
                                    }
                                    if (charCheck)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.KruinBuitentalud, csv, CharacteristicPointType.DikeTopAtRiver);
                                    }
                                    if (charCheck && indexes.InsteekBuitenberm.X > 0)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.InsteekBuitenberm, csv, CharacteristicPointType.ShoulderBaseOutside);
                                    }
                                    if (charCheck && indexes.KruinBuitenberm.X > 0)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.KruinBuitenberm, csv, CharacteristicPointType.ShoulderTopOutside);
                                    }
                                    if (charCheck)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.TeenDijkBuitenwaarts, csv, CharacteristicPointType.DikeToeAtRiver);
                                    }
                                    if (charCheck)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.MaaiveldBuitenwaarts, csv, CharacteristicPointType.SurfaceLevelOutside);
                                    }
                                    if (charCheck && indexes.TeenGeul.X > 0)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.TeenGeul, csv, CharacteristicPointType.BottomRiverChannel);
                                    }
                                    if (charCheck && indexes.InsteekGeul.X > 0)
                                    {
                                        charCheck &= AddCharacteristicPointToSurfaceLine(surfaceLine, indexes.InsteekGeul, csv, CharacteristicPointType.InsertRiverChannel);
                                    }
                                }
                                catch (System.Exception e)
                                {
                                    string csvCharacteristicPointError = String.Format(
                                        LocalizationManager.GetTranslatedText(typeof(CharacteristicPointsImporter),
                                                                              "csvCharacteristicPointError"), surfaceLine.Name);
                                    ErrorMessages.Add(new LogMessage(LogMessageType.Error, FileName, csvCharacteristicPointError + e.Message));
                                    charCheck = false;
                                }

                                if (!charCheck)
                                {
                                    surfaceLines.Remove(surfaceLine);
                                }
                                else
                                {
                                    surfaceLine.SortPoints();
                                }
                            }
                            if (recordCount == 0)
                            {
                                var msg = String.Format(LocalizationManager.GetTranslatedText(this, "CharacteristicPointCsvFileEmptyWarning"), fileName);
                                ErrorMessages.Add(new LogMessage(LogMessageType.Warning, FileName, msg));
                            }
                        }
                    }
                    finally
                    {
                        Thread.CurrentThread.CurrentCulture = oldcur;
                    }
                });
        }

        /// <summary>
        ///     This is the unified Read to be used by the original <see cref="Read(string, List{SurfaceLine2})"/>
        ///         and the new Import() method of the superclass Importer class
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="factory"></param>
        /// <remarks>This one is used by Ringtoets </remarks>
        public void Read(string fileName, IDataFactory factory)
        {
            // If we use the factory we are not sure if the surfaceline is already available;
            // so we set isAddPointToSurfaceLineIfMissing to true: add the surfaceline if missing and add the characteristic points as points to the surface line
            // If we use available surfacelines then set isAddPointToSurfaceLineIfMissing to false: surfaceline must be available and characteristic points should
            // already be present as points in the surfaceline; a check is made on that
            bool isAddPointToSurfaceLineIfMissing = (factory != null);

            if (Type == null)
            {
                Type = typeof(SurfaceLine2);
            }

            CultureInfo oldcur = Thread.CurrentThread.CurrentCulture;
            try
            {
                DataEventPublisher.InvokeWithoutPublishingEvents(() =>
                    {
                        Thread.CurrentThread.CurrentCulture = CsvReaderUtilities.DetermineCultureForFile(fileName);
                        using (var csv = new CsvReader(new StreamReader(fileName), true, ';'))
                        {
                            var headers = GetCharacteristicPointsFileHeader(fileName, csv);

                            var indexes = GetHeaderIndexes(fileName, headers);

                            SurfaceLine2 surfaceLine = null;

                            string surfaceLineName = "";

                            while (csv.ReadNextRecord())
                            {
                                try
                                {
                                    surfaceLineName = csv[indexes.SurfaceLineId];
                                    surfaceLine = GetSurfaceLine(factory, csv[indexes.SurfaceLineId]);

                                    if (surfaceLine == null)
                                    {
                                        // warning if the physical surfaceline is undefined at this point
                                        string surfacelLineNotFoundError = LocalizationManager.GetTranslatedText(typeof(CharacteristicPointsImporter), "SurfaceLineNotFoundError");
                                        string logmessage = String.Format(surfacelLineNotFoundError, surfaceLineName);
                                        SendImportError(logmessage);
                                    }
                                    else
                                    {
                                        AddCharacteristicPoints(csv, indexes, surfaceLine, isAddPointToSurfaceLineIfMissing);
                                        surfaceLine.SortPoints();
                                    }
                                }
                                catch (System.Exception e)
                                {
                                    string csvCharacteristicPointError = String.Format(LocalizationManager.GetTranslatedText(typeof(CharacteristicPointsImporter),"csvCharacteristicPointError"), surfaceLineName);
                                    SendImportError(csvCharacteristicPointError + e.Message);
                                }
                            }
                        }
                    });
            }
            finally
            {
                Thread.CurrentThread.CurrentCulture = oldcur;
            }
        }

        private void SendImportError(string logmessage)
        {
            ErrorMessages.Add(new LogMessage(LogMessageType.Warning, FileName, logmessage));
        }

        private void AddCharacteristicPoints(CsvReader csv, CharacteristicPointsIndexes indexes, SurfaceLine2 surfaceLine, bool isAddPointToSurfaceLineIfMissing)
        {
            bool charCheck;
            double x = Convert.ToDouble(csv[indexes.MaaiveldBinnenwaarts.X]);
            double y = Convert.ToDouble(csv[indexes.MaaiveldBinnenwaarts.Y]);
            double z = Convert.ToDouble(csv[indexes.MaaiveldBinnenwaarts.Z]);
            var type = CharacteristicPointType.SurfaceLevelInside;
            charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type, isAddPointToSurfaceLineIfMissing);

            if (charCheck && indexes.InsteekSlootPolderzijde.X > 0)
            {
                type = CharacteristicPointType.DitchPolderSide;
                x = Convert.ToDouble(csv[indexes.InsteekSlootPolderzijde.X]);
                y = Convert.ToDouble(csv[indexes.InsteekSlootPolderzijde.Y]);
                z = Convert.ToDouble(csv[indexes.InsteekSlootPolderzijde.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }
            if (charCheck && indexes.SlootbodemPolderzijde.X > 0)
            {
                type = CharacteristicPointType.BottomDitchPolderSide;
                x = Convert.ToDouble(csv[indexes.SlootbodemPolderzijde.X]);
                y = Convert.ToDouble(csv[indexes.SlootbodemPolderzijde.Y]);
                z = Convert.ToDouble(csv[indexes.SlootbodemPolderzijde.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }

            if (charCheck && indexes.SlootbodemDijkzijde.X > 0)
            {
                type = CharacteristicPointType.BottomDitchDikeSide;
                x = Convert.ToDouble(csv[indexes.SlootbodemDijkzijde.X]);
                y = Convert.ToDouble(csv[indexes.SlootbodemDijkzijde.Y]);
                z = Convert.ToDouble(csv[indexes.SlootbodemDijkzijde.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }

            if (charCheck && indexes.InsteekSlootDijkzijde.X > 0)
            {
                type = CharacteristicPointType.DitchDikeSide;
                x = Convert.ToDouble(csv[indexes.InsteekSlootDijkzijde.X]);
                y = Convert.ToDouble(csv[indexes.InsteekSlootDijkzijde.Y]);
                z = Convert.ToDouble(csv[indexes.InsteekSlootDijkzijde.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }

            if (charCheck)
            {
                type = CharacteristicPointType.DikeToeAtPolder;
                x = Convert.ToDouble(csv[indexes.TeenDijkBinnenwaarts.X]);
                y = Convert.ToDouble(csv[indexes.TeenDijkBinnenwaarts.Y]);
                z = Convert.ToDouble(csv[indexes.TeenDijkBinnenwaarts.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }

            if (charCheck && indexes.KruinBinnenberm.X > 0)
            {
                type = CharacteristicPointType.ShoulderTopInside;
                x = Convert.ToDouble(csv[indexes.KruinBinnenberm.X]);
                y = Convert.ToDouble(csv[indexes.KruinBinnenberm.Y]);
                z = Convert.ToDouble(csv[indexes.KruinBinnenberm.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }

            if (charCheck & indexes.InsteekBinnenberm.X > 0)
            {
                type = CharacteristicPointType.ShoulderBaseInside;
                x = Convert.ToDouble(csv[indexes.InsteekBinnenberm.X]);
                y = Convert.ToDouble(csv[indexes.InsteekBinnenberm.Y]);
                z = Convert.ToDouble(csv[indexes.InsteekBinnenberm.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }

            if (charCheck)
            {
                type = CharacteristicPointType.DikeTopAtPolder;
                x = Convert.ToDouble(csv[indexes.KruinBinnentalud.X]);
                y = Convert.ToDouble(csv[indexes.KruinBinnentalud.Y]);
                z = Convert.ToDouble(csv[indexes.KruinBinnentalud.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }

            if (charCheck && indexes.VerkeersbelastingKantBinnenwaarts.X > 0)
            {
                type = CharacteristicPointType.TrafficLoadInside;
                x = Convert.ToDouble(csv[indexes.VerkeersbelastingKantBinnenwaarts.X]);
                y = Convert.ToDouble(csv[indexes.VerkeersbelastingKantBinnenwaarts.Y]);
                z = Convert.ToDouble(csv[indexes.VerkeersbelastingKantBinnenwaarts.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }

            if (charCheck && indexes.VerkeersbelastingKantBuitenwaarts.X > 0)
            {
                type = CharacteristicPointType.TrafficLoadOutside;
                x = Convert.ToDouble(csv[indexes.VerkeersbelastingKantBuitenwaarts.X]);
                y = Convert.ToDouble(csv[indexes.VerkeersbelastingKantBuitenwaarts.Y]);
                z = Convert.ToDouble(csv[indexes.VerkeersbelastingKantBuitenwaarts.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }

            if (charCheck)
            {
                type = CharacteristicPointType.DikeTopAtRiver;
                x = Convert.ToDouble(csv[indexes.KruinBuitentalud.X]);
                y = Convert.ToDouble(csv[indexes.KruinBuitentalud.Y]);
                z = Convert.ToDouble(csv[indexes.KruinBuitentalud.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }

            if (charCheck && indexes.InsteekBuitenberm.X > 0)
            {
                type = CharacteristicPointType.ShoulderBaseOutside;
                x = Convert.ToDouble(csv[indexes.InsteekBuitenberm.X]);
                y = Convert.ToDouble(csv[indexes.InsteekBuitenberm.Y]);
                z = Convert.ToDouble(csv[indexes.InsteekBuitenberm.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }

            if (charCheck && indexes.KruinBuitenberm.X > 0)
            {
                type = CharacteristicPointType.ShoulderTopOutside;
                x = Convert.ToDouble(csv[indexes.KruinBuitenberm.X]);
                y = Convert.ToDouble(csv[indexes.KruinBuitenberm.Y]);
                z = Convert.ToDouble(csv[indexes.KruinBuitenberm.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }

            if (charCheck)
            {
                type = CharacteristicPointType.DikeToeAtRiver;
                x = Convert.ToDouble(csv[indexes.TeenDijkBuitenwaarts.X]);
                y = Convert.ToDouble(csv[indexes.TeenDijkBuitenwaarts.Y]);
                z = Convert.ToDouble(csv[indexes.TeenDijkBuitenwaarts.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }

            if (charCheck)
            {
                type = CharacteristicPointType.SurfaceLevelOutside;
                x = Convert.ToDouble(csv[indexes.MaaiveldBuitenwaarts.X]);
                y = Convert.ToDouble(csv[indexes.MaaiveldBuitenwaarts.Y]);
                z = Convert.ToDouble(csv[indexes.MaaiveldBuitenwaarts.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }

            if (charCheck && indexes.TeenGeul.X > 0)
            {
                type = CharacteristicPointType.BottomRiverChannel;
                x = Convert.ToDouble(csv[indexes.TeenGeul.X]);
                y = Convert.ToDouble(csv[indexes.TeenGeul.Y]);
                z = Convert.ToDouble(csv[indexes.TeenGeul.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }

            if (charCheck && indexes.InsteekGeul.X > 0)
            {
                type = CharacteristicPointType.InsertRiverChannel;
                x = Convert.ToDouble(csv[indexes.InsteekGeul.X]);
                y = Convert.ToDouble(csv[indexes.InsteekGeul.Y]);
                z = Convert.ToDouble(csv[indexes.InsteekGeul.Z]);
                charCheck = AddCharacteristicPointToSurfaceLine(surfaceLine, x, y, z, type,
                    isAddPointToSurfaceLineIfMissing);
            }
        }

        public override void Import()
        {
            Read(FileName, Factory);
        }

        #region Nested Types: CharacteristicPointsIndexes, XYZ

        /// <summary>
        /// Keeps all header indexes for a characteristic point csv file.
        /// </summary>
        private class CharacteristicPointsIndexes
        {
            public readonly XYZ InsteekBinnenberm;
            public readonly XYZ InsteekBuitenberm;
            public readonly XYZ InsteekGeul;
            public readonly XYZ InsteekSlootDijkzijde;
            public readonly XYZ InsteekSlootPolderzijde;
            public readonly XYZ KruinBinnenberm;
            public readonly XYZ KruinBinnentalud;
            public readonly XYZ KruinBuitenberm;
            public readonly XYZ KruinBuitentalud;
            public readonly XYZ MaaiveldBinnenwaarts;
            public readonly XYZ MaaiveldBuitenwaarts;
            public readonly XYZ SlootbodemDijkzijde;
            public readonly XYZ SlootbodemPolderzijde;
            public readonly XYZ TeenDijkBinnenwaarts;
            public readonly XYZ TeenDijkBuitenwaarts;
            public readonly XYZ TeenGeul;
            public readonly XYZ VerkeersbelastingKantBinnenwaarts;
            public readonly XYZ VerkeersbelastingKantBuitenwaarts;
            public int SurfaceLineId;
            public int Volgnummer;

            public CharacteristicPointsIndexes()
            {
                SurfaceLineId = -1;
                MaaiveldBinnenwaarts = new XYZ();
                InsteekSlootPolderzijde = new XYZ();
                SlootbodemPolderzijde = new XYZ();
                SlootbodemDijkzijde = new XYZ();
                InsteekSlootDijkzijde = new XYZ();
                TeenDijkBinnenwaarts = new XYZ();
                KruinBinnenberm = new XYZ();
                InsteekBinnenberm = new XYZ();
                KruinBinnentalud = new XYZ();
                VerkeersbelastingKantBinnenwaarts = new XYZ();
                VerkeersbelastingKantBuitenwaarts = new XYZ();
                KruinBuitentalud = new XYZ();
                InsteekBuitenberm = new XYZ();
                KruinBuitenberm = new XYZ();
                TeenDijkBuitenwaarts = new XYZ();
                MaaiveldBuitenwaarts = new XYZ();
                InsteekGeul = new XYZ();
                TeenGeul = new XYZ();
            }
        }

        /// <summary>
        /// Keeps the X, Y and Z coordinate values of a characteristic point.
        /// </summary>
        private class XYZ
        {
            public int X;
            public int Y;
            public int Z;

            public XYZ()
            {
                X = -1;
                Y = -1;
                Z = -1;
            }
        }

        #endregion

        /// <summary>
        ///     Adds the characteristic point to the surface line.
        /// </summary>
        /// <param name="surfaceLine">The surface line.</param>
        /// <param name="xGlobal">The x co-ordinate.</param>
        /// <param name="yGlobal">The y co-ordinate.</param>
        /// <param name="zGlobal">The z co-ordinate.</param>
        /// <param name="type">The type.</param>
        /// <param name="isAddPointToSurfaceLineIfMissing">if set to <c>true</c> [is add point to surface line if missing].</param>
        /// <returns></returns>
        protected bool AddCharacteristicPointToSurfaceLine(SurfaceLine2 surfaceLine, double xGlobal, double yGlobal, double zGlobal,
                                                           CharacteristicPointType type, bool isAddPointToSurfaceLineIfMissing)
        {
            bool charCheck = true;

            if (xGlobal == -1 && yGlobal == -1 && zGlobal == -1)
            {
                return true; //already exist or error situation ?????
            }
            GeometryPoint tppoint = surfaceLine.Geometry.GetPointAt(xGlobal, yGlobal, zGlobal);

            if (surfaceLine.CharacteristicPoints.GeometryMustContainPoint)
            {
                if (tppoint != null)
                {
                    surfaceLine.AddCharacteristicPoint(tppoint, type);
                }
                else
                {
                    // Point is missing
                    if (isAddPointToSurfaceLineIfMissing)
                    {
                        // If point is missing add it to the surfaceline
                        surfaceLine.EnsurePointOfType(xGlobal, yGlobal, zGlobal, type);
                    }
                    else
                    {
                        // If point is missing log error message
                        string charPointNotFoundInSurfaceError = LocalizationManager.GetTranslatedText(typeof(CharacteristicPointsImporter), "charPointNotFoundInSurfaceError");
                        string logmessage = String.Format("{0} : {1} {2}", surfaceLine.Name, charPointNotFoundInSurfaceError, type);
                        ErrorMessages.Add(new LogMessage(LogMessageType.Error, FileName, logmessage));
                        charCheck = false;
                    }
                }
            }
            else
            {
                var globalPoint = new GeometryPoint(xGlobal, yGlobal, zGlobal);
                var localPoint = surfaceLine.Geometry.GetLocalPoint(globalPoint);
                surfaceLine.AddCharacteristicPoint(localPoint ?? globalPoint, type);
            }
            return charCheck;
        }

        /// <summary>
        /// Retrieves the headers of the characteristic points csv file.
        /// </summary>
        /// <param name="fileName">File being read.</param>
        /// <param name="csv">Opened csv file reader.</param>
        /// <returns>The headers.</returns>
        /// <exception cref="CharacteristicPointsImporterException">When the number of header
        /// entries is lower then expected.</exception>
        private static string[] GetCharacteristicPointsFileHeader(string fileName, CsvReader csv)
        {
            string[] headers = csv.GetFieldHeaders();
            if (headers.Length < 53)
            {
                string csvHeaderError = LocalizationManager.GetTranslatedText(typeof(CharacteristicPointsImporter),
                                                                              "csvHeaderError");
                throw new CharacteristicPointsImporterException(String.Format("{0} : {1}", fileName, csvHeaderError));
            }
            return headers;
        }

        private static CharacteristicPointsIndexes GetHeaderIndexes(string fileName, string[] headers)
        {
            var indexes = new CharacteristicPointsIndexes();

            indexes.SurfaceLineId = GetRequiredIndex(fileName, headers,
                                                     CharacteristicPointCsvIdentifiers.SurfaceLineId, CharacteristicPointCsvIdentifiers.LocationId);

            GetRequiredXYZ(indexes.MaaiveldBinnenwaarts, fileName, headers,
                           new[]
                               {
                                   CharacteristicPointCsvIdentifiers.SurfaceLevelInsideX
                               },
                           new[]
                               {
                                   CharacteristicPointCsvIdentifiers.SurfaceLevelInsideY
                               },
                           new[]
                               {
                                   CharacteristicPointCsvIdentifiers.SurfaceLevelInsideZ
                               });

            GetXYZ(indexes.InsteekSlootPolderzijde, headers,
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.DitchPolderSideX
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.DitchPolderSideY
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.DitchPolderSideZ
                       });

            GetXYZ(indexes.SlootbodemPolderzijde, headers,
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.BottomDitchPolderSideX
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.BottomDitchPolderSideY
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.BottomDitchPolderSideZ
                       });

            GetXYZ(indexes.SlootbodemDijkzijde, headers,
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.BottomDitchDikeSideX
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.BottomDitchDikeSideY
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.BottomDitchDikeSideZ
                       });

            GetXYZ(indexes.InsteekSlootDijkzijde, headers,
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.DitchDikeSideX
                       },
                   // The click program by Erik Vastenburg now delivers "Y_Insteek_sloot dijkzijde" instead of the correct above definition
                   // Erik will change this in his program but for now, this wrong tag should also be recognized.
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.DitchDikeSideY, "Y_Insteek_sloot dijkzijde"
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.DitchDikeSideZ
                       });

            GetRequiredXYZ(indexes.TeenDijkBinnenwaarts, fileName, headers,
                           new[]
                               {
                                   CharacteristicPointCsvIdentifiers.DikeToeAtPolderX
                               },
                           new[]
                               {
                                   CharacteristicPointCsvIdentifiers.DikeToeAtPolderY
                               },
                           new[]
                               {
                                   CharacteristicPointCsvIdentifiers.DikeToeAtPolderZ
                               });

            GetXYZ(indexes.KruinBinnenberm, headers,
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.TopShoulderInsideX
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.TopShoulderInsideY
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.TopShoulderInsideZ
                       });

            GetXYZ(indexes.InsteekBinnenberm, headers,
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.InsteekShoulderInsideX
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.InsteekShoulderInsideY
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.InsteekShoulderInsideZ
                       });

            GetXYZ(indexes.KruinBinnentalud, headers,
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.DikeTopAtPolderX
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.DikeTopAtPolderY
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.DikeTopAtPolderZ
                       });

            GetXYZ(indexes.VerkeersbelastingKantBinnenwaarts, headers,
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.TrafficLoadInsideX
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.TrafficLoadInsideY
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.TrafficLoadInsideZ
                       });

            GetXYZ(indexes.VerkeersbelastingKantBuitenwaarts, headers,
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.TrafficLoadOutsideX
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.TrafficLoadOutsideY
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.TrafficLoadOutsideZ
                       });

            GetRequiredXYZ(indexes.KruinBuitentalud, fileName, headers,
                           new[]
                               {
                                   CharacteristicPointCsvIdentifiers.DikeTopAtRiverX
                               },
                           new[]
                               {
                                   CharacteristicPointCsvIdentifiers.DikeTopAtRiverY
                               },
                           new[]
                               {
                                   CharacteristicPointCsvIdentifiers.DikeTopAtRiverZ
                               });

            GetXYZ(indexes.InsteekBuitenberm, headers,
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.InsteekShoulderOutsideX
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.InsteekShoulderOutsideY
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.InsteekShoulderOutsideZ
                       });

            GetXYZ(indexes.KruinBuitenberm, headers,
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.TopShoulderOutsideX
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.TopShoulderOutsideY
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.TopShoulderOutsideZ
                       });

            GetRequiredXYZ(indexes.TeenDijkBuitenwaarts, fileName, headers,
                           new[]
                               {
                                   CharacteristicPointCsvIdentifiers.DikeToeAtRiverX
                               },
                           new[]
                               {
                                   CharacteristicPointCsvIdentifiers.DikeToeAtRiverY
                               },
                           new[]
                               {
                                   CharacteristicPointCsvIdentifiers.DikeToeAtRiverZ
                               });

            GetRequiredXYZ(indexes.MaaiveldBuitenwaarts, fileName, headers,
                           new[]
                               {
                                   CharacteristicPointCsvIdentifiers.SurfaceLevelOutsideX
                               },
                           new[]
                               {
                                   CharacteristicPointCsvIdentifiers.SurfaceLevelOutsideY
                               },
                           new[]
                               {
                                   CharacteristicPointCsvIdentifiers.SurfaceLevelOutsideZ
                               });

            GetXYZ(indexes.InsteekGeul, headers,
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.InsertRiverChannelX
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.InsertRiverChannelY
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.InsertRiverChannelZ
                       });

            GetXYZ(indexes.TeenGeul, headers,
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.BottomRiverChannelX
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.BottomRiverChannelY
                       },
                   new[]
                       {
                           CharacteristicPointCsvIdentifiers.BottomRiverChannelZ
                       });

            indexes.Volgnummer = GetIndex(headers, "Volgnummer");

            return indexes;
        }

        private static void GetXYZ(XYZ xyzIndexes, string[] headers, string[] xHeaderText, string[] yHeaderText, string[] zHeaderText)
        {
            xyzIndexes.X = GetIndex(headers, xHeaderText);
            xyzIndexes.Y = GetIndex(headers, yHeaderText);
            xyzIndexes.Z = GetIndex(headers, zHeaderText);
        }

        private static void GetRequiredXYZ(XYZ xyzIndexes, string fileName, string[] headers, string[] xHeaderText, string[] yHeaderText, string[] zHeaderText)
        {
            xyzIndexes.X = GetRequiredIndex(fileName, headers, xHeaderText);
            xyzIndexes.Y = GetRequiredIndex(fileName, headers, yHeaderText);
            xyzIndexes.Z = GetRequiredIndex(fileName, headers, zHeaderText);
        }

        /// <summary>
        /// Finds the index of a required header item.
        /// </summary>
        /// <param name="headers">All headers in the csv file.</param>
        /// <param name="headerText">The headers, mapping to a particular data item.</param>
        /// <returns>An integer greater the 0, being the index of the header in the csv file,
        /// when a match is found; -1 when no match has been found.</returns>
        private static int GetIndex(string[] headers, params string[] headerText)
        {
            Contract.Requires(headerText != null && headerText.Length > 0);

            int index = -1;
            foreach (var header in headerText)
            {
                index = CsvReaderUtilities.GetHeaderIndexByString(headers, header);
                if (index != -1)
                {
                    break;
                }
            }
            return index;
        }

        /// <summary>
        /// Finds the index of a required header item, or throws an exception in case none can be found.
        /// </summary>
        /// <param name="fileName">Name of the file being read (for error messages).</param>
        /// <param name="headers">All headers in the csv file.</param>
        /// <param name="headerText">The required headers, mapping to a particular data item.</param>
        /// <returns>An integer greater the 0, being the index of the header in the csv file.</returns>
        /// <exception cref="CharacteristicPointsImporterException">When no match from <paramref name="headerText"/>
        /// could be found in <paramref name="headers"/>.</exception>
        private static int GetRequiredIndex(string fileName, string[] headers, params string[] headerText)
        {
            Contract.Ensures(Contract.Result<int>() > 0);

            var index = GetIndex(headers, headerText);
            if (index < 0)
            {
                string csvHeaderFieldError = LocalizationManager.GetTranslatedText(typeof(CharacteristicPointsImporter),
                                                                                   "csvHeaderFieldError");
                throw new CharacteristicPointsImporterException(String.Format("{0} : {1} {2}", fileName, csvHeaderFieldError, String.Join(" / ", headerText)));
            }
            return index;
        }

        private SurfaceLine2 GetSurfacelineForDataRow(IEnumerable<SurfaceLine2> surfaceLines, CsvReader csv, CharacteristicPointsIndexes indexes)
        {
            Contract.Ensures(Contract.Result<SurfaceLine2>() != null);

            SurfaceLine2 surfaceLine = surfaceLines.FirstOrDefault(sl => sl.Name == csv[indexes.SurfaceLineId]);
            if (surfaceLine == null)
            {
                surfaceLine = new SurfaceLine2
                    {
                        Name = csv[indexes.SurfaceLineId]
                    };

                ErrorMessages.Add(new LogMessage(LogMessageType.Error, FileName, String.Format(this.Translate("SurfaceLineNotFoundError"), surfaceLine.Name)));
            }
            return surfaceLine;
        }

        /// <summary>
        ///     Use the factory to create a new <see cref="SurfaceLine2"/>
        /// </summary>
        /// <param name="factory"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        private SurfaceLine2 GetSurfaceLine(IDataFactory factory, string name)
        {
            SurfaceLine2 surfaceLine = null;

            var geometry = factory.GetExistingObject<LocalizedGeometryPointString>(name, null);
            if (geometry != null)
            {
                surfaceLine = factory.GetObject<SurfaceLine2>(name, null);
                // To prevent a full synch when GeometryMustContainPoint is already false
                if (surfaceLine.CharacteristicPoints.GeometryMustContainPoint)
                {
                    surfaceLine.CharacteristicPoints.GeometryMustContainPoint = false;
                }
                surfaceLine.Name = name;
                surfaceLine.Geometry = geometry;
            }

            return surfaceLine;
        }

        private bool AddCharacteristicPointToSurfaceLine(SurfaceLine2 surfaceLine, XYZ xyzIndexes,
                                                         CsvReader csv, CharacteristicPointType type)
        {
            double x = Convert.ToDouble(csv[xyzIndexes.X]);
            double y = Convert.ToDouble(csv[xyzIndexes.Y]);
            double z = Convert.ToDouble(csv[xyzIndexes.Z]);

            if (x == -1 && y == -1 && z == -1)
            {
                return true; //already exist or error situation ?????
            }

            var globalPoint = new GeometryPoint(x, y, z);
            var localPoint = surfaceLine.Geometry.GetLocalPoint(globalPoint);
            var addedPoint = localPoint ?? globalPoint;

            if (surfaceLine.CharacteristicPoints.GeometryMustContainPoint)
            {
                GeometryPoint geometryPoint = surfaceLine.Geometry.GetPointAt(addedPoint.X, addedPoint.Y, addedPoint.Z);
                if (geometryPoint == null)
                {
                    string charPointNotFoundInSurfaceError = LocalizationManager.GetTranslatedText(typeof(CharacteristicPointsImporter), "charPointNotFoundInSurfaceError");
                    string logmessage = String.Format("{0} : {1} {2}", surfaceLine.Name, charPointNotFoundInSurfaceError, type);
                    ErrorMessages.Add(new LogMessage(LogMessageType.Warning, FileName, logmessage));

                    return false;
                }
                surfaceLine.EnsurePointOfType(addedPoint.X, addedPoint.Y, addedPoint.Z, type);
            }
            else
            {
                surfaceLine.AddCharacteristicPoint(addedPoint, type);
            }
            return true;
        }
    }
}