// Copyright (C) Stichting Deltares 2017. All rights reserved.
//
// This file is part of the application DAM - UI.
//
// DAM - UI is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using Deltares.Geotechnics;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard.IO;
using Deltares.Standard.Language;
using LumenWorks.Framework.IO.Csv;

namespace Deltares.Dam.Data.CsvImporters
{
    public class CsvImporterCharacteristicPointsException : ApplicationException
    {
        public CsvImporterCharacteristicPointsException(string message)
            : base(message)
        {
        }
    }

    public class CsvImporterCharacteristicPoints
    {
        private List<CharacteristicPointsRecord> characteristicPointsRecords = new List<CharacteristicPointsRecord>();
        private List<string> errorMessages = new List<string>();

        public class CharPoint
        {
            public CharacteristicPointType Type { get; set; }
            public double X { get; set; }
            public double Y { get; set; }
            public double Z { get; set; }
        }

        public class CharacteristicPointsRecord
        {
            private IList<CharPoint> points = new List<CharPoint>();
            public string SurfaceLineId { get; set; }

            public IList<CharPoint> Points
            {
                get { return points; }
                set { points = value; }
            }

            public int Volgnummer { get; set; }
        }

        private void CheckColumn(int index, string fileName, string fieldName)
        {
            if (index < 0)
            {
                var csvHeaderFieldError = LocalizationManager.GetTranslatedText(this.GetType(), "csvHeaderFieldError");
                throw new CsvImporterCharacteristicPointsException(String.Format("{0} : {1} {2}", fileName, csvHeaderFieldError,
                                                                         fieldName));
            }
        }

        public CsvImporterCharacteristicPoints(string fileName)
        {
            const int minimalNumberOfColumns = 49; // Column 53 "volgnummer" is not mandatory; DTH removed
            errorMessages.Clear();
            ThrowHelper.ThrowIfStringArgumentNullOrEmpty(fileName, StringResourceNames.CsvFileNotValid);
            ThrowHelper.ThrowIfFileNotExist(fileName, StringResourceNames.CsvFileNotFound);

            var oldcur = Thread.CurrentThread.CurrentCulture;
            try
            {
                Thread.CurrentThread.CurrentCulture = CsvReaderUtilities.DetermineCultureForFile(fileName);
                using (CsvReader csv = new CsvReader(new StreamReader(fileName), true, ';'))
                {
                    string[] headers = CsvImporterHelper.GetFieldHeaders(this, csv);
                    if (headers.Count() < minimalNumberOfColumns)
                    {
                        var csvHeaderColumnCountError = String.Format(LocalizationManager.GetTranslatedText(this.GetType(), "csvHeaderColumnCountError"), minimalNumberOfColumns);
                        throw new CsvImporterCharacteristicPointsException(String.Format("{0} : {1}", fileName, csvHeaderColumnCountError));
                    }

                    int SurfaceLineIdCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.LocationId);
                    if (SurfaceLineIdCol < 0)
                    {
                        // colIndexSurfaceLineId can be defined with 2 identifiers (surfaceLineId is deprecated, locationId is the new one)
                        SurfaceLineIdCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                     CharacteristicPointCsvIdentifiers.SurfaceLineId);
                    }
                    CheckColumn(SurfaceLineIdCol, fileName, CharacteristicPointCsvIdentifiers.SurfaceLineId);

                    int XMaaiveldBinnenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                             CharacteristicPointCsvIdentifiers
                                                                                                 .SurfaceLevelInsideX);
                    CheckColumn(XMaaiveldBinnenwaartsCol, fileName,
                                CharacteristicPointCsvIdentifiers.SurfaceLevelInsideX);

                    int YMaaiveldBinnenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                             CharacteristicPointCsvIdentifiers
                                                                                                 .SurfaceLevelInsideY);
                    CheckColumn(YMaaiveldBinnenwaartsCol, fileName,
                                CharacteristicPointCsvIdentifiers.SurfaceLevelInsideY);

                    int ZMaaiveldBinnenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                             CharacteristicPointCsvIdentifiers
                                                                                                 .SurfaceLevelInsideZ);
                    CheckColumn(ZMaaiveldBinnenwaartsCol, fileName,
                                CharacteristicPointCsvIdentifiers.SurfaceLevelInsideZ);

                    int XInsteekSlootPolderzijdeCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                                CharacteristicPointCsvIdentifiers
                                                                                                    .DitchPolderSideX);
                    CheckColumn(XInsteekSlootPolderzijdeCol, fileName,
                                CharacteristicPointCsvIdentifiers.DitchPolderSideX);

                    int YInsteekSlootPolderzijdeCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                                CharacteristicPointCsvIdentifiers
                                                                                                    .DitchPolderSideY);
                    CheckColumn(YInsteekSlootPolderzijdeCol, fileName,
                                CharacteristicPointCsvIdentifiers.DitchPolderSideY);

                    int ZInsteekSlootPolderzijdeCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                                CharacteristicPointCsvIdentifiers
                                                                                                    .DitchPolderSideZ);
                    CheckColumn(ZInsteekSlootPolderzijdeCol, fileName,
                                CharacteristicPointCsvIdentifiers.DitchPolderSideZ);

                    int XSlootbodemPolderzijdeCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                              CharacteristicPointCsvIdentifiers
                                                                                                  .BottomDitchPolderSideX);
                    CheckColumn(XSlootbodemPolderzijdeCol, fileName,
                                CharacteristicPointCsvIdentifiers.BottomDitchPolderSideX);

                    int YSlootbodemPolderzijdeCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                              CharacteristicPointCsvIdentifiers
                                                                                                  .BottomDitchPolderSideY);
                    CheckColumn(YSlootbodemPolderzijdeCol, fileName,
                                CharacteristicPointCsvIdentifiers.BottomDitchPolderSideY);

                    int ZSlootbodemPolderzijdeCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                              CharacteristicPointCsvIdentifiers
                                                                                                  .BottomDitchPolderSideZ);
                    CheckColumn(ZSlootbodemPolderzijdeCol, fileName,
                                CharacteristicPointCsvIdentifiers.BottomDitchPolderSideZ);

                    int XSlootbodemDijkzijdeCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                            CharacteristicPointCsvIdentifiers
                                                                                                .BottomDitchDikeSideX);
                    CheckColumn(XSlootbodemDijkzijdeCol, fileName,
                                CharacteristicPointCsvIdentifiers.BottomDitchDikeSideX);

                    int YSlootbodemDijkzijdeCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                            CharacteristicPointCsvIdentifiers
                                                                                                .BottomDitchDikeSideY);
                    CheckColumn(YSlootbodemDijkzijdeCol, fileName,
                                CharacteristicPointCsvIdentifiers.BottomDitchDikeSideY);

                    int ZSlootbodemDijkzijdeCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                            CharacteristicPointCsvIdentifiers
                                                                                                .BottomDitchDikeSideZ);
                    CheckColumn(ZSlootbodemDijkzijdeCol, fileName,
                                CharacteristicPointCsvIdentifiers.BottomDitchDikeSideZ);

                    int XInsteekSlootDijkzijdeCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                              CharacteristicPointCsvIdentifiers
                                                                                                  .DitchDikeSideX);
                    CheckColumn(XInsteekSlootDijkzijdeCol, fileName, CharacteristicPointCsvIdentifiers.DitchDikeSideX);

                    int YInsteekSlootDijkzijdeCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                              CharacteristicPointCsvIdentifiers
                                                                                                  .DitchDikeSideY);
                    // 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.
                    if (YInsteekSlootDijkzijdeCol < 0)
                    {
                        const string fieldY_Insteekslootdijkzijde = "Y_Insteek_sloot dijkzijde";
                        YInsteekSlootDijkzijdeCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                              fieldY_Insteekslootdijkzijde);
                        CheckColumn(YInsteekSlootDijkzijdeCol, fileName, fieldY_Insteekslootdijkzijde);
                    }
                    else
                    {
                        CheckColumn(YInsteekSlootDijkzijdeCol, fileName,
                                    CharacteristicPointCsvIdentifiers.DitchDikeSideY);
                    }

                    int ZInsteekSlootDijkzijdeCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.DitchDikeSideZ);
                    CheckColumn(ZInsteekSlootDijkzijdeCol, fileName, CharacteristicPointCsvIdentifiers.DitchDikeSideZ);

                    int XTeenDijkBinnenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.DikeToeAtPolderX);
                    CheckColumn(XTeenDijkBinnenwaartsCol, fileName, CharacteristicPointCsvIdentifiers.DikeToeAtPolderX);

                    int YTeenDijkBinnenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.DikeToeAtPolderY);
                    CheckColumn(YTeenDijkBinnenwaartsCol, fileName, CharacteristicPointCsvIdentifiers.DikeToeAtPolderY);

                    int ZTeenDijkBinnenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.DikeToeAtPolderZ);
                    CheckColumn(ZTeenDijkBinnenwaartsCol, fileName, CharacteristicPointCsvIdentifiers.DikeToeAtPolderZ);

                    int XKruinBinnenbermCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.TopShoulderInsideX);
                    CheckColumn(XKruinBinnenbermCol, fileName, CharacteristicPointCsvIdentifiers.TopShoulderInsideX);

                    int YKruinBinnenbermCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.TopShoulderInsideY);
                    CheckColumn(YKruinBinnenbermCol, fileName, CharacteristicPointCsvIdentifiers.TopShoulderInsideY);

                    int ZKruinBinnenbermCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.TopShoulderInsideZ);
                    CheckColumn(ZKruinBinnenbermCol, fileName, CharacteristicPointCsvIdentifiers.TopShoulderInsideZ);

                    int XInsteekBinnenbermCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.InsteekShoulderInsideX);
                    CheckColumn(XInsteekBinnenbermCol, fileName, CharacteristicPointCsvIdentifiers.InsteekShoulderInsideX);

                    int YInsteekBinnenbermCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.InsteekShoulderInsideY);
                    CheckColumn(YInsteekBinnenbermCol, fileName, CharacteristicPointCsvIdentifiers.InsteekShoulderInsideY);

                    int ZInsteekBinnenbermCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.InsteekShoulderInsideZ);
                    CheckColumn(ZInsteekBinnenbermCol, fileName, CharacteristicPointCsvIdentifiers.InsteekShoulderInsideZ);

                    int XKruinBinnentaludCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.DikeTopAtPolderX);
                    CheckColumn(XKruinBinnentaludCol, fileName, CharacteristicPointCsvIdentifiers.DikeTopAtPolderX);

                    int YKruinBinnentaludCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.DikeTopAtPolderY);
                    CheckColumn(YKruinBinnentaludCol, fileName, CharacteristicPointCsvIdentifiers.DikeTopAtPolderY);

                    int ZKruinBinnentaludCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.DikeTopAtPolderZ);
                    CheckColumn(ZKruinBinnentaludCol, fileName, CharacteristicPointCsvIdentifiers.DikeTopAtPolderZ);

                    int XVerkeersbelastingKantBinnenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.TrafficLoadInsideX);
                    CheckColumn(XVerkeersbelastingKantBinnenwaartsCol, fileName, CharacteristicPointCsvIdentifiers.TrafficLoadInsideX);

                    int YVerkeersbelastingKantBinnenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.TrafficLoadInsideY);
                    CheckColumn(YVerkeersbelastingKantBinnenwaartsCol, fileName,
                                CharacteristicPointCsvIdentifiers.TrafficLoadInsideY);

                    int ZVerkeersbelastingKantBinnenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.TrafficLoadInsideZ);
                    CheckColumn(ZVerkeersbelastingKantBinnenwaartsCol, fileName, CharacteristicPointCsvIdentifiers.TrafficLoadInsideZ);

                    int XVerkeersbelastingKantBuitenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.TrafficLoadOutsideX);
                    CheckColumn(XVerkeersbelastingKantBuitenwaartsCol, fileName, CharacteristicPointCsvIdentifiers.TrafficLoadOutsideX);

                    int YVerkeersbelastingKantBuitenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.TrafficLoadOutsideY);
                    CheckColumn(YVerkeersbelastingKantBuitenwaartsCol, fileName, CharacteristicPointCsvIdentifiers.TrafficLoadOutsideY);

                    int ZVerkeersbelastingKantBuitenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.TrafficLoadOutsideZ);
                    CheckColumn(ZVerkeersbelastingKantBuitenwaartsCol, fileName, CharacteristicPointCsvIdentifiers.TrafficLoadOutsideZ);

                    int XKruinBuitentaludCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.DikeTopAtRiverX);
                    CheckColumn(XKruinBuitentaludCol, fileName, CharacteristicPointCsvIdentifiers.DikeTopAtRiverX);

                    int YKruinBuitentaludCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.DikeTopAtRiverY);
                    CheckColumn(YKruinBuitentaludCol, fileName, CharacteristicPointCsvIdentifiers.DikeTopAtRiverY);

                    int ZKruinBuitentaludCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.DikeTopAtRiverZ);
                    CheckColumn(ZKruinBuitentaludCol, fileName, CharacteristicPointCsvIdentifiers.DikeTopAtRiverZ);

                    int XInsteekBuitenbermCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.InsteekShoulderOutsideX);
                    CheckColumn(XInsteekBuitenbermCol, fileName, CharacteristicPointCsvIdentifiers.InsteekShoulderOutsideX);

                    int YInsteekBuitenbermCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.InsteekShoulderOutsideY);
                    CheckColumn(YInsteekBuitenbermCol, fileName, CharacteristicPointCsvIdentifiers.InsteekShoulderOutsideY);

                    int ZInsteekBuitenbermCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.InsteekShoulderOutsideZ);
                    CheckColumn(ZInsteekBuitenbermCol, fileName, CharacteristicPointCsvIdentifiers.InsteekShoulderOutsideZ);

                    int XKruinBuitenbermCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.TopShoulderOutsideX);
                    CheckColumn(XKruinBuitenbermCol, fileName, CharacteristicPointCsvIdentifiers.TopShoulderOutsideX);

                    int YKruinBuitenbermCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.TopShoulderOutsideY);
                    CheckColumn(YKruinBuitenbermCol, fileName, CharacteristicPointCsvIdentifiers.TopShoulderOutsideY);

                    int ZKruinBuitenbermCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.TopShoulderOutsideZ);
                    CheckColumn(ZKruinBuitenbermCol, fileName, CharacteristicPointCsvIdentifiers.TopShoulderOutsideZ);

                    int XTeenDijkBuitenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.DikeToeAtRiverX);
                    CheckColumn(XTeenDijkBuitenwaartsCol, fileName, CharacteristicPointCsvIdentifiers.DikeToeAtRiverX);

                    int YTeenDijkBuitenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.DikeToeAtRiverY);
                    CheckColumn(YTeenDijkBuitenwaartsCol, fileName, CharacteristicPointCsvIdentifiers.DikeToeAtRiverY);

                    int ZTeenDijkBuitenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.DikeToeAtRiverZ);
                    CheckColumn(ZTeenDijkBuitenwaartsCol, fileName, CharacteristicPointCsvIdentifiers.DikeToeAtRiverZ);

                    int XMaaiveldBuitenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.SurfaceLevelOutsideX);
                    CheckColumn(XMaaiveldBuitenwaartsCol, fileName,
                                CharacteristicPointCsvIdentifiers.SurfaceLevelOutsideX);

                    int YMaaiveldBuitenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.SurfaceLevelOutsideY);
                    CheckColumn(YMaaiveldBuitenwaartsCol, fileName,
                                CharacteristicPointCsvIdentifiers.SurfaceLevelOutsideY);

                    int ZMaaiveldBuitenwaartsCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.SurfaceLevelOutsideZ);
                    CheckColumn(ZMaaiveldBuitenwaartsCol, fileName,CharacteristicPointCsvIdentifiers.SurfaceLevelOutsideZ);

                    //optional, do not check
                    int XInsteekGeulCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.InsertRiverChannelX);
                    //optional, do not check
                    int YInsteekGeulCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.InsertRiverChannelY);
                    //optional, do not check
                    int ZInsteekGeulCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.InsertRiverChannelZ);

                    //optional, do not check
                    int XTeenGeulCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.BottomRiverChannelX);
                    //optional, do not check
                    int YTeenGeulCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.BottomRiverChannelY);
                    //optional, do not check
                    int ZTeenGeulCol = CsvReaderUtilities.GetHeaderIndexByString(headers, CharacteristicPointCsvIdentifiers.BottomRiverChannelZ);                    

                    // optional so do not check
                    const string fieldVolgnummer = "Volgnummer";
                    int VolgnummerCol = CsvReaderUtilities.GetHeaderIndexByString(headers, fieldVolgnummer);


                    while (csv.ReadNextRecord())
                    {
                        try
                        {
                            CharacteristicPointsRecord characteristicPoints = new CharacteristicPointsRecord();
                            characteristicPoints.SurfaceLineId = csv[SurfaceLineIdCol];
                            if (VolgnummerCol > -1)
                            {
                                characteristicPoints.Volgnummer = Convert.ToInt32(csv[VolgnummerCol]);
                            }

                            CharPoint mbi = new CharPoint();
                            mbi.Type = CharacteristicPointType.SurfaceLevelInside;
                            mbi.X = Convert.ToDouble(csv[XMaaiveldBinnenwaartsCol]);
                            mbi.Y = Convert.ToDouble(csv[YMaaiveldBinnenwaartsCol]);
                            mbi.Z = Convert.ToDouble(csv[ZMaaiveldBinnenwaartsCol]);
                            characteristicPoints.Points.Add(mbi);

                            CharPoint isp = new CharPoint();
                            isp.Type = CharacteristicPointType.DitchPolderSide;
                            isp.X = Convert.ToDouble(csv[XInsteekSlootPolderzijdeCol]);
                            isp.Y = Convert.ToDouble(csv[YInsteekSlootPolderzijdeCol]);
                            isp.Z = Convert.ToDouble(csv[ZInsteekSlootPolderzijdeCol]);
                            characteristicPoints.Points.Add(isp);

                            CharPoint sbp = new CharPoint();
                            sbp.Type = CharacteristicPointType.BottomDitchPolderSide;
                            sbp.X = Convert.ToDouble(csv[XSlootbodemPolderzijdeCol]);
                            sbp.Y = Convert.ToDouble(csv[YSlootbodemPolderzijdeCol]);
                            sbp.Z = Convert.ToDouble(csv[ZSlootbodemPolderzijdeCol]);
                            characteristicPoints.Points.Add(sbp);

                            CharPoint sbd = new CharPoint();
                            sbd.Type = CharacteristicPointType.BottomDitchDikeSide;
                            sbd.X = Convert.ToDouble(csv[XSlootbodemDijkzijdeCol]);
                            sbd.Y = Convert.ToDouble(csv[YSlootbodemDijkzijdeCol]);
                            sbd.Z = Convert.ToDouble(csv[ZSlootbodemDijkzijdeCol]);
                            characteristicPoints.Points.Add(sbd);

                            CharPoint isd = new CharPoint();
                            isd.Type = CharacteristicPointType.DitchDikeSide;
                            isd.X = Convert.ToDouble(csv[XInsteekSlootDijkzijdeCol]);
                            isd.Y = Convert.ToDouble(csv[YInsteekSlootDijkzijdeCol]);
                            isd.Z = Convert.ToDouble(csv[ZInsteekSlootDijkzijdeCol]);
                            characteristicPoints.Points.Add(isd);

                            CharPoint tdbi = new CharPoint();
                            tdbi.Type = CharacteristicPointType.DikeToeAtPolder;
                            tdbi.X = Convert.ToDouble(csv[XTeenDijkBinnenwaartsCol]);
                            tdbi.Y = Convert.ToDouble(csv[YTeenDijkBinnenwaartsCol]);
                            tdbi.Z = Convert.ToDouble(csv[ZTeenDijkBinnenwaartsCol]);
                            characteristicPoints.Points.Add(tdbi);

                            CharPoint kbb = new CharPoint();
                            kbb.Type = CharacteristicPointType.ShoulderTopInside;
                            kbb.X = Convert.ToDouble(csv[XKruinBinnenbermCol]);
                            kbb.Y = Convert.ToDouble(csv[YKruinBinnenbermCol]);
                            kbb.Z = Convert.ToDouble(csv[ZKruinBinnenbermCol]);
                            characteristicPoints.Points.Add(kbb);

                            CharPoint ibb = new CharPoint();
                            ibb.Type = CharacteristicPointType.ShoulderBaseInside;
                            ibb.X = Convert.ToDouble(csv[XInsteekBinnenbermCol]);
                            ibb.Y = Convert.ToDouble(csv[YInsteekBinnenbermCol]);
                            ibb.Z = Convert.ToDouble(csv[ZInsteekBinnenbermCol]);
                            characteristicPoints.Points.Add(ibb);

                            CharPoint kbt = new CharPoint();
                            kbt.Type = CharacteristicPointType.DikeTopAtPolder;
                            kbt.X = Convert.ToDouble(csv[XKruinBinnentaludCol]);
                            kbt.Y = Convert.ToDouble(csv[YKruinBinnentaludCol]);
                            kbt.Z = Convert.ToDouble(csv[ZKruinBinnentaludCol]);
                            characteristicPoints.Points.Add(kbt);

                            CharPoint vbbi = new CharPoint();
                            vbbi.Type = CharacteristicPointType.TrafficLoadInside;
                            vbbi.X = Convert.ToDouble(csv[XVerkeersbelastingKantBinnenwaartsCol]);
                            vbbi.Y = Convert.ToDouble(csv[YVerkeersbelastingKantBinnenwaartsCol]);
                            vbbi.Z = Convert.ToDouble(csv[ZVerkeersbelastingKantBinnenwaartsCol]);
                            characteristicPoints.Points.Add(vbbi);

                            CharPoint vbbu = new CharPoint();
                            vbbu.Type = CharacteristicPointType.TrafficLoadOutside;
                            vbbu.X = Convert.ToDouble(csv[XVerkeersbelastingKantBuitenwaartsCol]);
                            vbbu.Y = Convert.ToDouble(csv[YVerkeersbelastingKantBuitenwaartsCol]);
                            vbbu.Z = Convert.ToDouble(csv[ZVerkeersbelastingKantBuitenwaartsCol]);
                            characteristicPoints.Points.Add(vbbu);

                            CharPoint kbut = new CharPoint();
                            kbut.Type = CharacteristicPointType.DikeTopAtRiver;
                            kbut.X = Convert.ToDouble(csv[XKruinBuitentaludCol]);
                            kbut.Y = Convert.ToDouble(csv[YKruinBuitentaludCol]);
                            kbut.Z = Convert.ToDouble(csv[ZKruinBuitentaludCol]);
                            characteristicPoints.Points.Add(kbut);

                            CharPoint ibub = new CharPoint();
                            ibub.Type = CharacteristicPointType.ShoulderBaseOutside;
                            ibub.X = Convert.ToDouble(csv[XInsteekBuitenbermCol]);
                            ibub.Y = Convert.ToDouble(csv[YInsteekBuitenbermCol]);
                            ibub.Z = Convert.ToDouble(csv[ZInsteekBuitenbermCol]);
                            characteristicPoints.Points.Add(ibub);

                            CharPoint kbub = new CharPoint();
                            kbub.Type = CharacteristicPointType.ShoulderTopOutside;
                            kbub.X = Convert.ToDouble(csv[XKruinBuitenbermCol]);
                            kbub.Y = Convert.ToDouble(csv[YKruinBuitenbermCol]);
                            kbub.Z = Convert.ToDouble(csv[ZKruinBuitenbermCol]);
                            characteristicPoints.Points.Add(kbub);

                            CharPoint tdbu = new CharPoint();
                            tdbu.Type = CharacteristicPointType.DikeToeAtRiver;
                            tdbu.X = Convert.ToDouble(csv[XTeenDijkBuitenwaartsCol]);
                            tdbu.Y = Convert.ToDouble(csv[YTeenDijkBuitenwaartsCol]);
                            tdbu.Z = Convert.ToDouble(csv[ZTeenDijkBuitenwaartsCol]);
                            characteristicPoints.Points.Add(tdbu);

                            CharPoint mbu = new CharPoint();
                            mbu.Type = CharacteristicPointType.SurfaceLevelOutside;
                            mbu.X = Convert.ToDouble(csv[XMaaiveldBuitenwaartsCol]);
                            mbu.Y = Convert.ToDouble(csv[YMaaiveldBuitenwaartsCol]);
                            mbu.Z = Convert.ToDouble(csv[ZMaaiveldBuitenwaartsCol]);
                            characteristicPoints.Points.Add(mbu);

                            if (XTeenGeulCol > 0)
                            {
                                CharPoint brc = new CharPoint();
                                brc.Type = CharacteristicPointType.BottomRiverChannel;
                                brc.X = Convert.ToDouble(csv[XTeenGeulCol]);
                                brc.Y = Convert.ToDouble(csv[YTeenGeulCol]);
                                brc.Z = Convert.ToDouble(csv[ZTeenGeulCol]);
                                characteristicPoints.Points.Add(brc);
                            }

                            if (XInsteekGeulCol > 0)
                            {
                                CharPoint irc = new CharPoint();
                                irc.Type = CharacteristicPointType.InsertRiverChannel;
                                irc.X = Convert.ToDouble(csv[XInsteekGeulCol]);
                                irc.Y = Convert.ToDouble(csv[YInsteekGeulCol]);
                                irc.Z = Convert.ToDouble(csv[ZInsteekGeulCol]);
                                characteristicPoints.Points.Add(irc);
                            }

                            characteristicPointsRecords.Add(characteristicPoints);
                        }
                        catch (Exception e)
                        {
                            var csvCharacteristicPointError = LocalizationManager.GetTranslatedText(this.GetType(),
                                                                                                    "csvCharacteristicPointError");
                            errorMessages.Add(csvCharacteristicPointError + e.Message);
                        }
                    }
                }
            }
            finally
            {
                Thread.CurrentThread.CurrentCulture = oldcur;
            }
        }

        public List<CharacteristicPointsRecord> ImportedItems
        {
            get { return characteristicPointsRecords; }
        }

        public List<string> ErrorMessages
        {
            get { return errorMessages; }
            set { errorMessages = value; }
        }
    }
}