using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

using System.Data;

using System.ComponentModel.DataAnnotations;

using System.Globalization;

using System.Reflection;

using System.Collections.ObjectModel;

​

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

​

using CsvHelper;

using CsvHelper.Configuration;

using CsvHelper.Configuration.Attributes;

using CsvHelper.Expressions;

using CsvHelper.TypeConversion;

​

using Newtonsoft.Json;

​

//https://stackoverflow.com/questions/66984134/compare-csv-header-to-map-class

​

    public class ValidatingCsvReader : CsvReader

    {

        public ValidatingCsvReader(TextReader reader, CultureInfo culture, bool leaveOpen = false) : this(new CsvParser(reader, culture, leaveOpen)) { }

        public ValidatingCsvReader(TextReader reader, CsvConfiguration configuration) : this(new CsvParser(reader, configuration)) { }

        public ValidatingCsvReader(IParser parser) : base(parser) { }

​

        public Action<CsvContext, List<string>> OnUnmappedCsvHeaders { get; set; }

​

        public override void ValidateHeader(Type type)

        {

            base.ValidateHeader(type);

            var headerRecord = HeaderRecord;

            var mapped = new BitArray(headerRecord.Length);

            var map = Context.Maps[type];

            FlagMappedHeaders(map, mapped);

            var unmappedHeaders = Enumerable.Range(0, headerRecord.Length).Where(i => !mapped[i]).Select(i => headerRecord[i]).ToList();

            if (unmappedHeaders.Count > 0)

            {

                OnUnmappedCsvHeaders?.Invoke(Context, unmappedHeaders);

            }

        }

​

        protected virtual void FlagMappedHeaders(ClassMap map, BitArray mapped)

        {

            // Logic adapted from https://github.com/JoshClose/CsvHelper/blob/0d753ff09294b425e4bc5ab346145702eeeb1b6f/src/CsvHelper/CsvReader.cs#L157

            // By https://github.com/JoshClose

            foreach (var parameter in map.ParameterMaps)

            {

                if (parameter.Data.Ignore)

                    continue;

                if (parameter.Data.IsConstantSet)

                    // If ConvertUsing and Constant don't require a header.

                    continue;

                if (parameter.Data.IsIndexSet && !parameter.Data.IsNameSet)

                    // If there is only an index set, we don't want to validate the header name.

                    continue;

​

                if (parameter.ConstructorTypeMap != null)

                {

                    FlagMappedHeaders(parameter.ConstructorTypeMap, mapped);

                }

                else if (parameter.ReferenceMap != null)

                {

                    FlagMappedHeaders(parameter.ReferenceMap.Data.Mapping, mapped);

                }

                else

                {

                    var index = GetFieldIndex(parameter.Data.Names.ToArray(), parameter.Data.NameIndex, true);

                    if (index >= 0)

                        mapped.Set(index, true);

                }

            }

​

            foreach (var memberMap in map.MemberMaps)

            {

                if (memberMap.Data.Ignore || !CanRead(memberMap))

                    continue;

                if (memberMap.Data.ReadingConvertExpression != null || memberMap.Data.IsConstantSet)

                    // If ConvertUsing and Constant don't require a header.

                    continue;

                if (memberMap.Data.IsIndexSet && !memberMap.Data.IsNameSet)

                    // If there is only an index set, we don't want to validate the header name.

                    continue;

​

                var index = GetFieldIndex(memberMap.Data.Names.ToArray(), memberMap.Data.NameIndex, true);

                if (index >= 0)

                    mapped.Set(index, true);

            }

​

            foreach (var referenceMap in map.ReferenceMaps)

            {

                if (!CanRead(referenceMap))

                    continue;

                FlagMappedHeaders(referenceMap.Data.Mapping, mapped);

            }

        }

    }

​

    public class VisitExport

    {

        public int? Count { get; set; }

        public string CustomerName { get; set; }

        public string CustomerAddress { get; set; }

    }

​

    class TestClass

    {

        public static void Test()

        {

            var inputList = new List<VisitExport>

            {

                new VisitExport { Count = 101, CustomerName = "name 101", CustomerAddress = "customer address 101" },

                new VisitExport { Count = null, CustomerName = "name 1", CustomerAddress = "customer address 1" },

                new VisitExport { Count = 202, CustomerName = "name 202", CustomerAddress = "customer address 202" },

            };

​

            var json0 = JsonConvert.SerializeObject(inputList);

            var csv1 = TestOutput(inputList, null);

            Console.WriteLine("CSV export for model:");

            Console.WriteLine(csv1);

            var csv1Lower = csv1.ToLowerInvariant();

            var newList1 = TestInput(csv1, null);

            var newList11 = TestInput(csv1Lower, null, (args) => args.Header.ToLowerInvariant());

            Console.WriteLine("Caught expected exception reading CSV with unknown column: {0}",

                              Assert.Throws<CsvHelperException>(() =>

                                                                {

                                                                    TestInput(GetUnknownColumnCsv(), null);

                                                                }, "Did not catch CsvHelperException")?.Message);

​

            Console.WriteLine("Caught expected exception reading lowercase CSV with unknown column: {0}",

                              Assert.Throws<CsvHelperException>(() =>

                                                                {

                                                                    TestInput(GetUnknownColumnCsv().ToLowerInvariant(), null, (args) => args.Header.ToLowerInvariant());

                                                                }, "Did not catch CsvHelperException for lower case")?.Message);

​

            Console.WriteLine("Caught expected exception: {0}",

                              Assert.Throws<HeaderValidationException>(() =>

                                                                       {

                                                                           TestInput(GetMissingColumnCsv(), null, (args) => args.Header.ToLowerInvariant());

                                                                       })?.Message);

            var json1 = JsonConvert.SerializeObject(newList1);

            var json11 = JsonConvert.SerializeObject(newList11);

            Assert.AreEqual(json0, json1);

            Assert.AreEqual(json0, json11);     

        }   

        public static List<VisitExport> TestInput(string csv, ClassMap<VisitExport> map, PrepareHeaderForMatch prepareHeaderForMatch = default)

        {

            var culture = CultureInfo.GetCultureInfo("en-GB");

            var config = new CsvConfiguration (culture);

            if (prepareHeaderForMatch != null)

                config.PrepareHeaderForMatch = prepareHeaderForMatch;

            using (var reader  = new StringReader(csv))

            using (var readCsv  = new ValidatingCsvReader(reader, config)

                   {

                       OnUnmappedCsvHeaders = (context, headers) => throw new CsvHelperException(context, string.Format("Unmapped CSV headers: \"{0}\"", string.Join(",", headers))),

                   })

            {

                if (map != null)

                    readCsv.Context.RegisterClassMap(map);

                var fileContent = readCsv.GetRecords<VisitExport>();

                return fileContent.ToList();

            }

        }

        public static string TestOutput(List<VisitExport> inputList, ClassMap<VisitExport> map)

        {

            var culture = CultureInfo.GetCultureInfo("en-GB");

            var config = new CsvConfiguration (culture);

            var sb = new StringBuilder();

            using (var textWriter = new StringWriter(sb))

            using (var csvWriter = new CsvWriter(textWriter, config))

            {

                if (map != null)

                    csvWriter.Context.RegisterClassMap(map);

                csvWriter.WriteRecords(inputList);

            }

            return sb.ToString();

        }   

        static string GetUnknownColumnCsv() => @"Count,CustomerName,CustomerAddress,Foo

101,name 101,customer address 101,

,name 1,customer address 1,foo

202,name 202,customer address 202,

";

        static string GetMissingColumnCsv() => @"CustomerName,Count

name 1,

name 101,101

name 202,202

";

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , GetNetCoreVersion());

            Console.WriteLine("CsvHelper: " + typeof(CsvConfiguration).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

        public static string GetNetCoreVersion()

        {

            //https://techblog.dorogin.com/how-to-detect-net-core-version-in-runtime-ecd65ad695be

            //

            var assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;

            var assemblyPath = assembly.Location.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);

            int netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");

            if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)

                return assemblyPath[netCoreAppIndex + 1];

            return null;

        }

    }

​