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

namespace Deltares.Soilbase.CSVImporter
{
    public class CsvSoilsImporter
    {
        private const string SoilName = "SoilName";
        private readonly Dictionary<string, int> availableColumns = new Dictionary<string, int>();

        public SoilList ImportFromFile(string fileName)
        {
            if (String.IsNullOrEmpty(fileName))
            {
                var csvSoilsImporterFileNameIsEmpty = LocalizationManager.GetTranslatedText(GetType(), "csvSoilsImporterFileNameIsEmpty");
                throw new CsvSoilsImporterException(String.Format("{0} : {1}", fileName, csvSoilsImporterFileNameIsEmpty));
            }
            if (!File.Exists(fileName))
            {
                var csvSoilsImporterFileDoesNotExist = LocalizationManager.GetTranslatedText(GetType(), "csvSoilsImporterFileDoesNotExist");
                throw new CsvSoilsImporterException(String.Format("{0} : {1}", fileName, csvSoilsImporterFileDoesNotExist));
            }
            return ImportFile(fileName);
        }

        private SoilList ImportFile(string fileName)
        {
            var soilList = new SoilList();
            soilList.AquiferDictionary = new Dictionary<Soil, bool>();
            var oldcur = Thread.CurrentThread.CurrentCulture;
            try
            {
                Thread.CurrentThread.CurrentCulture = CsvReaderUtilities.DetermineCultureForFile(fileName);
                using (var csv = new CsvReader(new StreamReader(fileName), true, ';'))
                {
                    DetermineContentCsvFromHeaders(fileName, csv);

                    RetrieveSoilListFromCsvData(fileName, csv, soilList);
                }
            }
            finally
            {
                Thread.CurrentThread.CurrentCulture = oldcur;
            }
            return soilList;
        }

        private void RetrieveSoilListFromCsvData(string fileName, CsvReader csv, SoilList soilList)
        {
            while (csv.ReadNextRecord())
            {
                try
                {
                    var newSoil = new Soil();

                    foreach (var availablecolumn in availableColumns)
                    {
                        if (availablecolumn.Value > -1)
                        {
                            if (availablecolumn.Key == SoilName)
                            {
                                newSoil.Name = csv[availableColumns[SoilName]];
                            }
                            else
                            {
                                // Skip empty fields
                                var valueAsString = csv[availablecolumn.Key];
                                if (valueAsString != "")
                                {
                                    SoilUtils.SetParameterFromNameValuePair(newSoil, availablecolumn.Key, csv[availablecolumn.Key]);
                                    if (availablecolumn.Key == "SoilIsAquifer")
                                    {
                                        if (valueAsString.ToLower() == "true")
                                        {
                                            soilList.AquiferDictionary.Add(newSoil, true);
                                        }
                                        else
                                        {
                                            soilList.AquiferDictionary.Add(newSoil, false);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    soilList.Soils.Add(newSoil);
                }
                catch (Exception e)
                {
                    var csvSoilsImportError = LocalizationManager.GetTranslatedText(GetType(), "csvSoilsImportError") + ": " + e.Message;
                    throw new CsvSoilsImporterException(String.Format("{0} : {1}", fileName, csvSoilsImportError));
                }
            }
        }

        private void DetermineContentCsvFromHeaders(string fileName, CsvReader csv)
        {
            availableColumns.Clear();
            const int minimalNumberOfColumns = 2;
            string[] headers = csv.GetFieldHeaders();
            // there must be at least two columns
            if (headers.Count() < minimalNumberOfColumns)
            {
                var csvHeaderColumnCountError = String.Format(LocalizationManager.GetTranslatedText(GetType(), "csvHeaderColumnCountError"), minimalNumberOfColumns);
                throw new CsvSoilsImporterException(String.Format("{0} : {1}", fileName, csvHeaderColumnCountError));
            }
            // get column number for SoilName, it must be there so check it
            availableColumns.Add(SoilName, CsvReaderUtilities.GetHeaderIndexByString(headers, SoilName));
            if (availableColumns[SoilName] < 0)
            {
                var csvHeaderColumnSoilNameError = LocalizationManager.GetTranslatedText(GetType(), "csvHeaderColumnSoilNameError");
                throw new CsvSoilsImporterException(String.Format("{0} : {1}", fileName, csvHeaderColumnSoilNameError));
            }
            // get column numbers for all parameters, these are all optional 
            foreach (var parameterName in SoilParameterNames.ParameterNames)
            {
                availableColumns.Add(parameterName, CsvReaderUtilities.GetHeaderIndexByString(headers, parameterName));
            }
        }
    }
}