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

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

    public class CsvImporterSegments
    {
        private List<SegmentRecord> segmentRecords = new List<SegmentRecord>();
        private List<string> errorMessages = new List<string>();

        public class SegmentRecord
        {
            public int SegmentRecordId { get; set; }
            public string SegmentId { get; set; }
            public string SoilProfileId { get; set; }
            public double Probability { get; set; }
            public FailureMechanismSystemType SegmentFailureMechanismType { get; set; }
            public string SoilGeometry2DName { get; set; }
        }

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

        public CsvImporterSegments(string fileName)
        {
            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() != 4)
                    {
                        var csvHeaderError = LocalizationManager.GetTranslatedText(this.GetType(), "csvHeaderError");
                        throw new CsvImporterSegmentsException(String.Format("{0} : {1}", fileName, csvHeaderError));                        
                    }
                    
                    const string fieldsement_id = "segment_id";
                    int colIndexSegmentId = CsvReaderUtilities.GetHeaderIndexByString(headers, fieldsement_id);
                    CheckColumn(colIndexSegmentId, fileName, fieldsement_id);
                    
                    const string fieldsoilprofile_id = "soilprofile_id";
                    int colIndexSoilProfileId = CsvReaderUtilities.GetHeaderIndexByString(headers, fieldsoilprofile_id);
                    const string fieldsoilgeometry2D_name = "soilgeometry2D_name";
                    int colIndexGeometry2dName = CsvReaderUtilities.GetHeaderIndexByString(headers, fieldsoilgeometry2D_name);
                    // soil profile and geometry2D are in bothe optional but at least one has to be there.
                    if ((colIndexSoilProfileId < 0) && (colIndexGeometry2dName < 0))
                    {
                        var csvHeaderFieldError = LocalizationManager.GetTranslatedText(this.GetType(), "csvHeaderFieldError");
                        throw new CsvImporterSoilProfilesException(String.Format("{0} : {1} {2} / {3}", fileName, csvHeaderFieldError, fieldsoilprofile_id, fieldsoilgeometry2D_name));
                    }
                    const string fieldprobability = "probability";
                    int colIndexProbability = CsvReaderUtilities.GetHeaderIndexByString(headers, fieldprobability);
                    CheckColumn(colIndexProbability, fileName, fieldprobability);
                    
                    const string fieldcalculation_type = "calculation_type";
                    int colIndexCalculationType = CsvReaderUtilities.GetHeaderIndexByString(headers, fieldcalculation_type);
                    CheckColumn(colIndexCalculationType, fileName, fieldcalculation_type);
                    var index = 1;
                    while (csv.ReadNextRecord())
                    {
                        SegmentRecord segment = new SegmentRecord();
                        int colIndex = -1;  // Keep track of column for error message
                        try
                        {
                            segment.SegmentId = csv[colIndexSegmentId];
                            segment.SegmentRecordId = index;
                            index++;
                            if (colIndexSoilProfileId > -1)
                            {
                                colIndex = colIndexSoilProfileId;
                                segment.SoilProfileId = csv[colIndexSoilProfileId];
                            }
                            if (colIndexGeometry2dName > -1)
                            {
                                colIndex = colIndexGeometry2dName;
                                segment.SoilGeometry2DName = csv[colIndexGeometry2dName];
                            }
                            segment.Probability = Convert.ToDouble(csv[colIndexProbability]);
                            var typeAsString = csv[colIndexCalculationType];
                            if (typeAsString == "Stability")
                            {
                                segment.SegmentFailureMechanismType = FailureMechanismSystemType.StabilityInside;
                            }
                            else if (typeAsString == "Piping")
                            {
                                segment.SegmentFailureMechanismType = FailureMechanismSystemType.Piping;
                            }
                            else
                            {
                                var csvSegmentCalculationTypeError = LocalizationManager.GetTranslatedText(this.GetType(), "csvSegmentCalculationTypeError");
                                errorMessages.Add(String.Format("{0} : {1} {2}", fileName, segment.SegmentId, csvSegmentCalculationTypeError));
                            }
                            
                            segmentRecords.Add(segment);
                        }
                        catch (Exception e)
                        {
                            var csvSegmentError = String.Format(LocalizationManager.GetTranslatedText(this.GetType(), "csvSegmentError"), segment.SegmentId, colIndex + 1);
                            errorMessages.Add(csvSegmentError + e.Message);
                        }
                        
                    }
                }
            }
            finally
            {
                Thread.CurrentThread.CurrentCulture = oldcur;
            }
        }

        public List<SegmentRecord> ImportedItems
        {
            get { return segmentRecords; }
        }

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