using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;

namespace Logof_Client;

public class DataImport
{
    public static (bool, KasAddressList) ImportKasAddressList(Uri pathToCsv, AddressPatch patch = null,
        char separator = ',')
    {
        if (patch == null)
            return ImportKasAddressListWithoutPatch(pathToCsv, separator);
        return ImportKasAddressListWithPatch(pathToCsv, patch, separator);
    }

    private static (bool, KasAddressList) ImportKasAddressListWithoutPatch(Uri pathToCsv, char separator)
    {
        if (!File.Exists(pathToCsv.LocalPath))
        {
            Console.WriteLine($"File not found: {pathToCsv}");
            return (false, null);
        }

        using var reader = new StreamReader(pathToCsv.LocalPath);
        var headerLine = reader.ReadLine();
        if (headerLine == null)
        {
            Console.WriteLine("File is empty.");
            return (false, null);
        }

        var imported = new KasAddressList(KasAddressList.GenerateName(Path.GetFileNameWithoutExtension(pathToCsv.LocalPath)));

        while (!reader.EndOfStream)
        {
            var line = reader.ReadLine();
            if (string.IsNullOrWhiteSpace(line))
                continue;

            var parts = line.Split(separator).Select(p => p.Trim()).ToArray();

            if (parts.Length < 24)
            {
                Console.WriteLine($"Not enough columns in line: {line}");
                continue;
            }

            try
            {
                var person = new KasPerson(
                    ParseInt(parts[0]),
                    parts[1],
                    parts[2],
                    parts[3],
                    parts[4],
                    parts[5],
                    parts[6],
                    parts[7],
                    parts[8],
                    parts[9],
                    ParseInt(parts[10]),
                    parts[11],
                    parts[12],
                    ParseInt(parts[13]),
                    parts[14],
                    parts[15],
                    parts[16],
                    parts[17],
                    parts[18],
                    parts[19],
                    parts[20],
                    parts[21],
                    parts[22],
                    parts[23]
                );
                imported.KasPersons.Add(person);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error while parsing line: {line} - {ex.Message}");
                Console.WriteLine(ex.StackTrace);
                return (false, null);
            }
        }

        return (true, imported);
    }

    private static (bool, KasAddressList) ImportKasAddressListWithPatch(Uri pathToCsv, AddressPatch patch,
        char separator)
    {
        if (!File.Exists(pathToCsv.LocalPath))
        {
            Console.WriteLine($"File not found: {pathToCsv}");
            return (false, null);
        }

        using var reader = new StreamReader(pathToCsv.LocalPath);
        var headerLine = reader.ReadLine();
        if (headerLine == null)
        {
            Console.WriteLine("File is empty.");
            return (false, null);
        }

        var headers = headerLine.Split(separator).Select(h => h.Trim()).ToArray();

        var imported = new KasAddressList(KasAddressList.GenerateName(Path.GetFileNameWithoutExtension(pathToCsv.LocalPath)));
        var patchType = typeof(AddressPatch);
        var binding = BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase;

        var hasProperties = patchType.GetProperties(binding)
            .Where(p => p.PropertyType == typeof(bool) && p.Name.StartsWith("has_", StringComparison.OrdinalIgnoreCase))
            .ToArray();

        var last_refsid = 1000000;

        while (!reader.EndOfStream)
        {
            var line = reader.ReadLine();
            if (string.IsNullOrWhiteSpace(line))
                continue;

            var parts = line.Split(separator).Select(p => p.Trim()).ToArray();

            var fieldValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

            var refsid_existing = false;

            foreach (var hasProp in hasProperties)
            {
                var fieldName = hasProp.Name.Substring(4);
                

                var hasObj = hasProp.GetValue(patch);
                var has = hasObj is bool b && b;

                var patchProp = patchType.GetProperty(fieldName + "_is", binding);

                string desiredHeader = null;
                if (has && patchProp != null)
                    desiredHeader = patchProp.GetValue(patch)?.ToString();
                else
                    desiredHeader = fieldName;

                var resolvedValue = "";

                if (!string.IsNullOrEmpty(desiredHeader))
                {
                    var idx = Array.FindIndex(headers,
                        h => string.Equals(h, desiredHeader, StringComparison.OrdinalIgnoreCase));
                    if (idx >= 0 && idx < parts.Length)
                    {
                        resolvedValue = parts[idx];
                    }
                    else
                    {
                        var altIdx = Array.FindIndex(headers, h =>
                            string.Equals(h, fieldName, StringComparison.OrdinalIgnoreCase) ||
                            string.Equals(h, fieldName + "_is", StringComparison.OrdinalIgnoreCase));
                        
                        if (altIdx >= 0 && altIdx < parts.Length)
                            resolvedValue = parts[altIdx];
                        else
                            resolvedValue = "";
                    }
                }

                fieldValues[fieldName] = resolvedValue ?? "";
            }

            string GetField(string name)
            {
                return fieldValues.TryGetValue(name, out var v) ? v : "";
            }

            var new_refsid = last_refsid;
            if (!patch.has_refsid)
                new_refsid = GenerateNewRefsid();
            else
                new_refsid = ParseInt(GetField("refsid"));

            try
            {
                var person = new KasPerson(
                    new_refsid,
                    GetField("anrede"),
                    GetField("titel"),
                    GetField("vorname"),
                    GetField("adel"),
                    GetField("name"),
                    GetField("namezus"),
                    GetField("anredzus"),
                    GetField("strasse"),
                    GetField("strasse2"),
                    ParseInt(GetField("plz")),
                    GetField("ort"),
                    GetField("land"),
                    ParseInt(GetField("pplz")),
                    GetField("postfach"),
                    GetField("name1"),
                    GetField("name2"),
                    GetField("name3"),
                    GetField("name4"),
                    GetField("name5"),
                    GetField("funktion"),
                    GetField("funktion2"),
                    GetField("abteilung"),
                    GetField("funktionad")
                );

                imported.KasPersons.Add(person);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error while parsing line: {line} - {ex.Message}");
                Console.WriteLine(ex.StackTrace);
                return (false, null);
            }
        }

        return (true, imported);

        int GenerateNewRefsid()
        {

            int biggest = last_refsid;
            foreach (var set in Settings._instance.addressSets.addresses)
            {
                foreach (var address in set.KasPersons)
                {
                    if (biggest < address.refsid)
                    {
                        biggest = address.refsid+1;
                    }
                }
            }
            last_refsid = biggest+1;
            return last_refsid;
        }
    }


    private static int ParseInt(string input)
    {
        return int.TryParse(input, out var result) ? result : 0;
    }
}