// Copyright (C) Stichting Deltares 2020. All rights reserved.
//
// This file is part of the LayerOnSlopeTool
//
// The LayerOnSlopeTool is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero 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.IO;
using System.Linq;
using System.Threading;
using LumenWorks.Framework.IO.Csv;

namespace Deltares.LayerOnSlopeTool.Data.CsvImporters
{
    /// <summary>
    /// Holds the importer for the characteristic points from csv files
    /// </summary>
    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 = "In de header ontbreekt veld:";
                throw new ArgumentException(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();
            if (fileName == "")
            {
                throw new ArgumentException("De filenaam voor de CharacteristicPoints csv is leeg.");
            }

            if (!File.Exists(fileName))
            {
                throw new ArgumentException(string.Format("De CharacteristicPoints csv file met naam {0} bestaat niet.", fileName));
            }

            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("Miminum aantal kolommen in csv bestand is {0}", minimalNumberOfColumns);
                        throw new ArgumentException(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 fieldYInsteekslootdijkzijde = "Y_Insteek_sloot dijkzijde";
                        yInsteekSlootDijkzijdeCol = CsvReaderUtilities.GetHeaderIndexByString(headers,
                                                                                              fieldYInsteekslootdijkzijde);
                        CheckColumn(yInsteekSlootDijkzijdeCol, fileName, fieldYInsteekslootdijkzijde);
                    }
                    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 =
                                "Tijdens het lezen van karakteristieke punten in locatie {0} in kolom {1} uit de csv trad de volgende fout op: ";
                            errorMessages.Add(csvCharacteristicPointError + e.Message);
                        }
                    }
                }
            }
            finally
            {
                Thread.CurrentThread.CurrentCulture = oldcur;
            }
        }

        /// <summary>
        /// Gets the imported items.
        /// </summary>
        /// <value>
        /// The imported items.
        /// </value>
        public List<CharacteristicPointsRecord> ImportedItems
        {
            get { return characteristicPointsRecords; }
        }

        /// <summary>
        /// Gets the error messages.
        /// </summary>
        /// <value>
        /// The error messages.
        /// </value>
        public List<string> ErrorMessages
        {
            get { return errorMessages; }
            set { errorMessages = value; }
        }

    }
}