// Copyright (C) Stichting Deltares 2020. All rights reserved.
//
// This file is part of the Layer On Slope Tool.
//
// The Layer On Slope Tool 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 Deltares.LayerOnSlopeTool.Data.CsvImporters;
using LumenWorks.Framework.IO.Csv;

namespace Deltares.LayerOnSlopeTool.Importer
{
    /// <summary>
    /// Holds the importer for the locations from csv files
    /// </summary>
    public class CsvImporterLocations
    {
        private readonly List<LocationRecord> locationRecords = new List<LocationRecord>();
        private readonly List<string> errorMessages = new List<string>();

        /// <summary>
        /// Record used for importing the items from the locations csv file.
        /// </summary>
        public class LocationRecord
        {
            /// <summary>
            /// Gets or sets the location record identifier.
            /// </summary>
            /// <value>
            /// The location record identifier.
            /// </value>
            public int LocationRecordId { get; set; }

            /// <summary>
            /// Gets or sets the location identifier.
            /// </summary>
            /// <value>
            /// The location identifier.
            /// </value>
            public string LocationId { get; set; }

            /// <summary>
            /// Gets or sets the surface line identifier.
            /// </summary>
            /// <value>
            /// The surface line identifier.
            /// </value>
            public string SurfaceLineId { get; set; }

            /// <summary>
            /// Gets or sets the x offset.
            /// This is the offset needed to combine with the surface line correctly when both do not line up. 
            /// </summary>
            /// <value>
            /// The x offset.
            /// </value>
            public double? XOffset { get; set; } // Only optional item

            /// <summary>
            /// Gets or sets the dike embankment material. This is to be used as filling material for surface between the original 2D sti profile and the surface line.
            /// </summary>
            /// <value>
            /// The dike embankment material.
            /// </value>
            public string DikeEmbankmentMaterial { get; set; }  // Now required, not optional

            /// <summary>
            /// Gets or sets the name of the soil geometry.
            /// </summary>
            /// <value>
            /// The name of the soil geometry.
            /// </value>
            public string SoilGeometryName { get; set; } //NEW

            /// <summary>
            /// Gets or sets the layer material.
            /// </summary>
            /// <value>
            /// The layer material.
            /// </value>
            public string LayerMaterial { get; set; } //NEW

            /// <summary>
            /// Gets or sets the layer thickness.
            /// </summary>
            /// <value>
            /// The layer thickness.
            /// </value>
            public double LayerThickness { get; set; } //NEW
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CsvImporterLocations"/> class, filling the records from the csv.
        /// </summary>
        /// <param name="fileName">Name of the file.</param>
        /// <exception cref="System.ArgumentException">
        /// De filenaam voor de locations csv is leeg.
        /// or
        /// or
        /// </exception>
        public CsvImporterLocations(string fileName)
        {
            errorMessages.Clear();
            if (fileName == "")
            {
                throw new ArgumentException("The file name for the Locations csv is empty.");
            }

            if (!File.Exists(fileName))
            {
                throw new ArgumentException(string.Format("The Locations csv file with name {0} could not be found.", fileName));
            }


            var oldcur = Thread.CurrentThread.CurrentCulture;
            try
            {
                 Thread.CurrentThread.CurrentCulture = CsvReaderUtilities.DetermineCultureForFile(fileName);
                 using (var csv = new CsvReader(new StreamReader(fileName), true, ';'))
                 {
                     string[] headers = CsvImporterHelper.GetFieldHeaders(this, csv);
                     if (headers.Count() < 3)
                     {
                         var csvHeaderError = "The header of the csv file is wrong.";
                         throw new ArgumentException(string.Format("{0} : {1}", fileName, csvHeaderError));
                     }
                
                     int colIndexLocationId = CsvReaderUtilities.GetHeaderIndexByString(headers, CsvColumnNames.LocationColumnName);
                     CheckColumn(colIndexLocationId, fileName, CsvColumnNames.LocationColumnName);
                     int colIndexSurfaceLineId = CsvReaderUtilities.GetHeaderIndexByString(headers, CsvColumnNames.SurfaceLineColumnName);
                     CheckColumn(colIndexSurfaceLineId, fileName, CsvColumnNames.SurfaceLineColumnName);
                     int colIndexXOffset = CsvReaderUtilities.GetHeaderIndexByString(headers, CsvColumnNames.XOffsetColumnName);
                     int colIndexDikeEmbankmentMaterial = CsvReaderUtilities.GetHeaderIndexByString(headers, CsvColumnNames.DikeEmbankmentMaterialColumnName);
                     CheckColumn(colIndexDikeEmbankmentMaterial, fileName, CsvColumnNames.DikeEmbankmentMaterialColumnName);
                     int colSoilGeometryName = CsvReaderUtilities.GetHeaderIndexByString(headers, CsvColumnNames.SoilGeometryNameColumnName);
                     CheckColumn(colSoilGeometryName, fileName, CsvColumnNames.SoilGeometryNameColumnName);
                     int colLayerMaterial = CsvReaderUtilities.GetHeaderIndexByString(headers, CsvColumnNames.LayerMaterialColumnName);
                     CheckColumn(colLayerMaterial, fileName, CsvColumnNames.LayerMaterialColumnName);
                     int colLayerThickness = CsvReaderUtilities.GetHeaderIndexByString(headers, CsvColumnNames.LayerThicknessColumnName);
                     CheckColumn(colLayerThickness, fileName, CsvColumnNames.LayerThicknessColumnName);

                     var index = 1;
                     while (csv.ReadNextRecord())
                     {
                         var locationRecord = new LocationRecord();
                         var colIndex = -1;  // Keep track of column for error message
                         try
                         {
                             locationRecord.LocationRecordId = index++;

                             /*
                             * Required columns
                             */
                             locationRecord.LocationId = csv[colIndexLocationId];
                             locationRecord.SurfaceLineId = csv[colIndexSurfaceLineId];
                             locationRecord.DikeEmbankmentMaterial = csv[colIndexDikeEmbankmentMaterial];
                             locationRecord.SoilGeometryName = csv[colSoilGeometryName];
                             locationRecord.LayerMaterial = csv[colLayerMaterial];
                             locationRecord.LayerThickness = Convert.ToDouble(csv[colLayerThickness]);

                             /*
                             * Optional column
                             */
                             if (colIndexXOffset > -1)
                             {
                                colIndex = colIndexXOffset;
                                locationRecord.XOffset = Convert.ToDouble(csv[colIndexXOffset]);
                             }
                             locationRecords.Add(locationRecord);
                         }
                         catch (Exception e)
                         {
                             var csvLocationError = String.Format("Next error occured whilst reading location {0} column {1} from csv: ", 
                                 locationRecord.LocationId, colIndex + 1);
                             errorMessages.Add(csvLocationError + e.Message);
                         }
                     }
                 }
            }
            finally
            {
                Thread.CurrentThread.CurrentCulture = oldcur;
            }
        }

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

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

        private void CheckColumn(int index, string fileName, string fieldName)
        {
            if (index < 0)
            {
                var csvHeaderFieldError = "The header misses the field: ";
                throw new ArgumentException(string.Format("{0} : {1} {2} at index {3}.", fileName, csvHeaderFieldError, fieldName, index));
            }
        }
    }
}