using System;
using System.Linq;

namespace Logof_Client;

public static class AddressCreator
{
    //+++ Aufbau +++
    //  
    // Von unten anfangen, max. 7 Zeilen
    //  
    // + Wenn Land nicht Deutschland Abbildung von Land (Fettgedruckt)
    //  
    // Alternative A (wenn PPLZ + Ort ausgefüllt):
    // + Abbildung PPLZ + Ort - Ort ggf. Abschneiden, wenn länger als eine Zeile … das längste was ich finden konnte: „Giugliano in Campania-Lago Patra“ (passt exakt auf eine Zeile)
    // + Abbildung Postfach – wenn leer, dann Straße
    // + Abbildung Wenn Anredezusatz nicht leer, Anredezusatz, sonst Anrede + Titel + Vorname + Adel + Name + Namenszusatz in Klammern
    // + Abbildung Name 1 + Name 2 + Name 3 + Name 4 + Name 5 + Abteilung (insgesamt max. 7 Zeilen)
    //  
    // ansonsten
    //  
    // + Abbildung PLZ + Ort - Ort ggf. Abschneiden, wenn länger als eine Zeile … das längste was ich finden konnte: „Giugliano in Campania-Lago Patra“ (passt exakt auf eine Zeile)
    // + Abbildung Straße – wenn Straße leer, dann Postfach
    // + Abbildung Wenn Anredezusatz nicht leer, Anredezusatz, sonst Anrede + Titel + Vorname + Adel + Name + Namenszusatz in Klammern
    // + Abbildung Name 1 + Name 2 + Name 3 + Name 4 + Name 5 + Abteilung (insgesamt max. 7 Zeilen)
    //  
    // Auswurf Fehler-Datei
    //  
    // + wenn keine PLZ und/oder kein Ort -> Fehler
    // + wenn kein Name 1-5 und/oder Name -> Fehler
    //  
    // Auswurf CSV-Datei (Komma/TAB, UTF-8, ISO…)
    //  
    // Auswurf PDF mit normalen Absender
    //  
    // Auswurf PDF mit PvSt.

    /// <summary>
    ///     Creates max-seven-lines-long Markdown address-string. Analyzes the KasPerson-Instance to find the best result.
    /// </summary>
    /// <param name="refsid">KasPerson-ID</param>
    /// <returns>A Markdown string with the address that is maximum seven lines long</returns>
    public static string? CreateFinalMarkdownString(int refsid)
    {
        // Maximum seven lines of information

        // find the address
        KasPerson? address = null;
        var string_address = "";
        var address_line_count = 0;
        foreach (var set in Settings._instance.addressSets.addresses)
        {
            var temp = set.KasPersons.FirstOrDefault(obj => obj.refsid == refsid);
            if (temp != null)
            {
                address = temp;
                break;
            }
        }

        // no address found
        if (address == null) return null;

        // let's get started: we start from the bottom
        // if the country is not Germany, set it; try to map via Global countries alternatives -> translation
        var trimmedLand = (address.land ?? "").Trim();
        var trimmedLowerLand = trimmedLand.ToLower();
        var isGermany = trimmedLowerLand == "germany" || trimmedLowerLand == "ger" ||
                        trimmedLowerLand == "" || trimmedLowerLand == "de" ||
                        trimmedLowerLand == "deutschland";

        if (!isGermany)
        {
            var countryToShow = trimmedLand; // default: use raw land value

            if (!string.IsNullOrEmpty(trimmedLand))
                // search for matching country via alternatives using for-loops
                for (var ci = 0; ci < Global._instance.countries.Count; ci++)
                {
                    var country = Global._instance.countries[ci];
                    for (var ai = 0; ai < country.alternatives.Count; ai++)
                        try
                        {
                            var alt = (country.alternatives[ai] ?? "").Trim();
                            if (string.Equals(alt, trimmedLand, StringComparison.OrdinalIgnoreCase))
                            {
                                countryToShow = string.IsNullOrWhiteSpace(country.translation)
                                    ? country.name
                                    : country.translation;
                                goto CountryFound;
                            }
                        }
                        catch
                        {
                            // ignore malformed alternative
                        }
                }

            CountryFound:
            string_address = "**" + countryToShow + "**"; // Needs to be bold
            address_line_count++;
        }

        // Alternative A: pplz valid and city existing
        if (!string.IsNullOrEmpty(address.ort) && CheckPLZ(address.pplz, address.land))
        {
            string_address = address.pplz + " " + address.ort + "\n" + string_address;
            address_line_count++;
            if (!string.IsNullOrWhiteSpace(address.postfach))
            {
                string_address = "Postfach " + address.postfach.Trim() + "\n" + string_address;
                address_line_count++;
            }
            else if (!string.IsNullOrWhiteSpace(address.strasse.Trim()))
            {
                string_address = address.strasse.Trim() + "\n" + string_address;
                address_line_count++;
            }

            var nameline = CreateNameLine(address.anredzus, address.anrede, address.titel, address.vorname,
                address.adel, address.name, address.namezus);

            if (!string.IsNullOrWhiteSpace(nameline))
            {
                string_address = nameline + "\n" + string_address;
                address_line_count++;
            }

            // REIHENFOLGE
            var nameattribs = new[]
                { address.name1, address.name2, address.name3, address.name4, address.name5, address.abteilung };

            var names = "";
            for (var i = 0; i < nameattribs.Length; i++)
                try
                {
                    if (address_line_count >= 7) break;
                    if (!string.IsNullOrWhiteSpace(nameattribs[i]))
                    {
                        names += "\n" + nameattribs[i];
                        address_line_count++;
                    }
                }
                catch
                {
                    Console.WriteLine("ERROR 15821");
                }

            string_address = names + "\n" + string_address;
        } // Alternative B: plz valid and city existing 
        else if (!string.IsNullOrEmpty(address.ort) && CheckPLZ(address.plz, address.land))
        {
            string_address = address.plz + " " + address.ort + "\n" + string_address;
            address_line_count++;
            if (!string.IsNullOrWhiteSpace(address.strasse))
            {
                string_address = address.strasse.Trim() + "\n" + string_address;
                address_line_count++;
            }
            else if (!string.IsNullOrWhiteSpace(address.postfach.Trim()))
            {
                string_address = "Postfach " + address.postfach.Trim() + "\n" + string_address;
                address_line_count++;
            }

            var nameline = CreateNameLine(address.anredzus, address.anrede, address.titel, address.vorname,
                address.adel, address.name, address.namezus);

            if (!string.IsNullOrWhiteSpace(nameline))
            {
                string_address = nameline + "\n" + string_address;
                address_line_count++;
            }

            var nameattribs = new[]
                { address.name1, address.name2, address.name3, address.name4, address.name5, address.abteilung };

            var names = "";
            for (var i = 0; i < nameattribs.Length; i++)
                try
                {
                    if (address_line_count >= 7) break;
                    if (!string.IsNullOrWhiteSpace(nameattribs[i]))
                    {
                        names += "\n" + nameattribs[i];
                        address_line_count++;
                    }
                }
                catch
                {
                    Console.WriteLine("ERROR 15821");
                }

            string_address = names + "\n" + string_address;
        } // Error-Handling?

        if (address_line_count > 1) return string_address;
        return null;
    }

    public static string CreateNameLine(string anredezus, string anrede, string titel, string vorname, string adel,
        string name, string namezus)
    {
        if (!string.IsNullOrWhiteSpace(anredezus))
            return string.Join(" ",
                       new[] { anredezus, titel, vorname, adel, name }
                           .Where(s => !string.IsNullOrWhiteSpace(s))
                   )
                   + (string.IsNullOrWhiteSpace(namezus) ? "" : $" ({namezus.Trim()})");

        // else 
        return string.Join(" ",
                   new[] { anrede, titel, vorname, adel, name }
                       .Where(s => !string.IsNullOrWhiteSpace(s))
               )
               + (string.IsNullOrWhiteSpace(namezus) ? "" : $" ({namezus.Trim()})");
    }

    /// <summary>
    ///     Returns true if a plz (or pplz) is valid
    /// </summary>
    /// <param name="plz">the plz itself</param>
    /// <param name="land">country, to check the plz</param>
    /// <returns>true or faslse, depending on result :+1:</returns>
    public static bool CheckPLZ(string plz, string land)
    {
        if (string.IsNullOrWhiteSpace(plz)) return false;

        var trimmedPlz = plz.Trim();
        var trimmedLand = land.ToLower().Trim();

        // Check if it's a German country code
        var isGermany = trimmedLand == "germany" || trimmedLand == "ger" || trimmedLand == "de" ||
                        trimmedLand == "deutschland" || trimmedLand == "";

        if (isGermany)
            // For Germany (including empty land), accept numeric postal codes with 5 digits
            try
            {
                var iplz = Convert.ToInt32(trimmedPlz);
                if (trimmedPlz.Length == 5) return true;
                return false;
            }
            catch
            {
                return false;
            }

        // For non-German countries, accept any non-empty postal code
        return true;
    }
}