package QualifierTeil2;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

public class Parkhaus {
    private List<PKW> parkendePkws;
    int kapazitaetVerfuegbar;
    int belegt;
    int maxKapazitaet;

    public Parkhaus() {
        this.parkendePkws = new ArrayList<>();
        this.maxKapazitaet = randomAnzahlParkplätze();
        this.kapazitaetVerfuegbar = maxKapazitaet;
        this.belegt = 0;
    }


    // Methode zum Einfahren eines PKWs
    public void einfahren(String kennzeichen, Date einfahrtZeit) {
        PKW existierenderPKW = null;

        // Überprüfen, ob das Auto mit demselben Kennzeichen bereits existiert
        for (PKW pkw : parkendePkws) {
            if (pkw.getKennzeichen().equals(kennzeichen)) {
                existierenderPKW = pkw;
                break;
            }
        }

        // Falls angegebenen PKW sich schon im Parkhaus befindet oder schonmal da war und Schulden hat
        if (existierenderPKW != null) {
            System.out.println("Der PKW mit dem Kennzeichen " + kennzeichen + " hat noch Schulden in Höhe von " + existierenderPKW.getGebuehrenkonto() + " Cent.");
            this.kapazitaetVerfuegbar--;
            this.belegt++;
        } else {
            // Neuen PKW erstellen und Schulden übernehmen, falls vorhanden
            PKW neuerPKW = new PKW(kennzeichen, einfahrtZeit);
            double schulden = sucheSchulden(kennzeichen);  // Funktion, die die alten Schulden findet (falls vorhanden)
            neuerPKW.setGebuehrenkonto(schulden);  // Vorherige Schulden hinzufügen
            parkendePkws.add(neuerPKW);
            this.kapazitaetVerfuegbar--;
            this.belegt++;
            System.out.println("Neuer PKW mit Kennzeichen " + kennzeichen + " eingefahren. Schulden: " + schulden + " Cent.");
        }

    }


    // Methode zum Ausfahren eines PKWs anhand des Kennzeichens
    public void ausfahren(String kennzeichen) {
        PKW zuEntfernen = null; //PKW, der rausfahren will

        // Überprüfen, ob das Auto mit demselben Kennzeichen bereits existiert und setze das als zuEntfernen
        for (PKW pkw : parkendePkws) {
            if (pkw.getKennzeichen().equals(kennzeichen)) {
                zuEntfernen = pkw;
                break;
            }
        }

        // Falls Auto zum Entfernen gibt
        if (zuEntfernen != null) {
            // Berechnung der Gebühren
            SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy, HH:mm");
            Date ausfahrtZeit;

            Scanner scanner = new Scanner(System.in);
            System.out.println("Bitte geben Sie die Ausfahrtszeit ein (leer lassen für aktuelle Zeit, Format: dd.MM.yyyy, HH:mm): ");
            String ausfahrtInput = scanner.nextLine();

            if (ausfahrtInput.isEmpty()){
                ausfahrtZeit = new Date();//Aktuelle Zeit nehmen
                System.out.println("Ausfahrtszeit: " + sdf.format(ausfahrtZeit));
            } else {
                try {
                    ausfahrtZeit = sdf.parse(ausfahrtInput);  // Manuelle Eingabe verarbeiten
                    System.out.println("Ausfahrtszeit: " + sdf.format(ausfahrtZeit));
                } catch (ParseException e) {
                    System.out.println("Ungültiges Datum, benutze aktuelle Zeit.");
                    ausfahrtZeit = new Date();
                    System.out.println("Ausfahrtszeit: " + sdf.format(ausfahrtZeit));
                }
            }

            double aktuelleGebuehren = berechneGebuehren(kennzeichen, ausfahrtZeit);
            double gesamtGebuehren = zuEntfernen.getGebuehrenkonto() + aktuelleGebuehren;  // Summe der Schulden + aktuelle Gebühren


            // Gebührenkonto aktualisieren
            zuEntfernen.setGebuehrenkonto(aktuelleGebuehren); // Schulden für unbezahlte Gebühren hinzufügen

            // Falls Gebühren vorhanden sind
            if (gesamtGebuehren > 0) {

                System.out.println("Parkdauer in Minuten: " + berechneParkdauer(kennzeichen, ausfahrtZeit));
                System.out.println("Parkgebühren in Cent: " + zuEntfernen.getGebuehrenkonto());

                // Kreditkartenvalidierung vor Ausfahrt

                System.out.println("Bitte geben Sie Ihre 16-stellige VISA-Kreditkartennummer ein:");
                String kreditkartenNummer = scanner.nextLine();

                if (pruefeKreditkarte(kreditkartenNummer)) {
                    System.out.println("Zahlung erfolgreich. Sie dürfen ausfahren.");
                    zuEntfernen.setGebuehrenkonto(0);  // Gebühren auf 0 setzen
                    System.out.println("Bezahlte Summe: " + zuEntfernen.getGebuehrenkonto());
                    // PKW aus der Liste entfernen
                    parkendePkws.remove(zuEntfernen);  // Hier wird der PKW endgültig entfernt
                    System.out.println("PKW mit Kennzeichen " + kennzeichen + " hat die Gebühren bezahlt und darf rausfahren.\n");
                } else {
                    System.out.println("Ungültige Kreditkartennummer. Zahlung fehlgeschlagen.");
                    System.out.println("Offenes Gebührenkonto: " + zuEntfernen.getGebuehrenkonto());
                }
            } else {
                // Gebührenfrei (unter 15 Minuten oder andere Ausnahme)

                System.out.println("Parkdauer in Minuten: " + berechneParkdauer(kennzeichen, ausfahrtZeit));
                System.out.println("Parkgebühren in Cent: " + zuEntfernen.getGebuehrenkonto());
                System.out.println("PKW mit Kennzeichen " + kennzeichen + " darf gebührenfrei ausfahren.");
            }

            // PKW aus der Liste nicht entfernen und Kapazität aktualisieren
            this.kapazitaetVerfuegbar++;
            this.belegt--;
            System.out.println("PKW mit Kennzeichen " + kennzeichen + " hat die Ausfahrt durchgeführt.\n");

        } else {
            System.out.println("Kein PKW mit diesem Kennzeichen gefunden.\n");
        }
    }


    public long berechneParkdauer(String kennzeichen, Date ausfahrt) {
        long minDiff = 0;

        // Überprüfen, ob das Auto mit dem angegebenen Kennzeichen existiert
        for (PKW pkw : parkendePkws) {
            if (pkw.getKennzeichen().equals(kennzeichen)) {
                Date einfahrt = pkw.getEinfahrt();


                // Parkdauer in Minuten berechnen (Differenz zwischen Ausfahrt und Einfahrt)
                minDiff = (ausfahrt.getTime() - einfahrt.getTime() ) / 60000;
                break;
            }
        }

        return minDiff;
    }

    public double berechneGebuehren(String kennzeichen, Date ausfahrt) {
        long parkdauer = berechneParkdauer(kennzeichen, ausfahrt);
        double gebuehr = 0;

        // Falls die Parkdauer 15 Minuten oder weniger beträgt, ist das Parken kostenlos
        if (parkdauer <= 15) {
            parkdauer = 0;
            gebuehr = 0;
        }

        // Parkdauer nach den 15 Minuten
        long parkdauerOhneFreiminuten = parkdauer - 15;

        // Tageslimit: Maximal 15 Euro pro Tag
        if (parkdauerOhneFreiminuten == 1440) {
            gebuehr = 1500;
            parkdauerOhneFreiminuten = 0;
        }

        // 1 Euro pro angefangene Stunde
        if (parkdauerOhneFreiminuten > 0 && parkdauerOhneFreiminuten < 1440) {
            while (parkdauerOhneFreiminuten > 0) {
                gebuehr += 100;
                parkdauerOhneFreiminuten -= 60;
            }
        }

        // Maximale Gebühren in der Nacht von 20 Uhr bis 6 Uhr
        gebuehr = berechneNachttarif(kennzeichen, gebuehr, ausfahrt);

        // Prüfe, ob es sich um ein E-Auto handelt (Kennzeichen endet mit "E")
        if (kennzeichen.endsWith("E")) {
            gebuehr *= 0.8; // 20% Rabatt für E-Autos
        }
        return gebuehr;
    }

    // Methode zur Überprüfung der Kreditkartennummer mit dem Luhn-Algorithmus
    public boolean pruefeKreditkarte(String kreditkartenNummer) {
        if (kreditkartenNummer.length() != 16 || !kreditkartenNummer.startsWith("4")) {
            return false;  // Ungültige Karte
        }

        //Luhn-Algorithmus
        int sum = 0;
        boolean alternate = false;
        for (int i = kreditkartenNummer.length() - 1; i >= 0; i--) {
            int n = Integer.parseInt(kreditkartenNummer.substring(i, i + 1));
            if (alternate) {
                n *= 2;
                if (n > 9) {
                    n = (n % 10) + 1;
                }
            }
            sum += n;
            alternate = !alternate;
        }
        return (sum % 10 == 0);
    }

    //-------------------------------Hilfsmethoden-------------------------------------------

    // Methode zum Generieren einer zufälligen Zahl für die Anzahl der Parkplätze
    private static int randomAnzahlParkplätze() {
        return (int) (Math.random() * 200) + 1;
    }

    // Methode zum Durchsuchen der Liste nach alten Schulden
    private double sucheSchulden(String kennzeichen) {

        // Beispiel: Wenn der PKW schon einmal ausgefahren ist, seine Schulden zurückgeben
        for (PKW pkw : parkendePkws) {
            if (pkw.getKennzeichen().equals(kennzeichen)) {
                return pkw.getGebuehrenkonto();  // Alte Schulden finden
            }
        }
        return 0.0;  // Keine Schulden gefunden
    }


    // Methode zum Prüfen, ob das Parkhaus voll ist
    public boolean istVoll() {
        return parkendePkws.size() >= this.maxKapazitaet;
    }

    // Methode zur Berechnung der Sonderregel für in der Nacht von 20 Uhr bis 6 Uhr
    private double berechneNachttarif(String kennzeichen, double gebuehr, Date ausfahrt) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(ausfahrt);

        //Debugging
        /*SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy, HH:mm");
        Date einfahrtszeit = null;
        try {
            // Beispiel für manuelle Eingabe, kann angepasst werden
            einfahrtszeit = sdf.parse("01.10.2024, 20:00");
            ausfahrt = sdf.parse("02.10.2024, 02:00");
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }*/

        // Bestimme die Einfahrtszeit des Fahrzeugs
        Date einfahrt = findeEinfahrtZeit(kennzeichen); // =einfahrt für Debugging // Methode zum Finden der Einfahrtszeit
        Calendar einfahrtsCal = Calendar.getInstance();
        einfahrtsCal.setTime(einfahrt);

        // Prüfe, ob sich ein Teil der Parkdauer im Zeitraum von 20:00 bis 6:00 Uhr befindet
        while (einfahrtsCal.before(cal)) {
            int stunde = einfahrtsCal.get(Calendar.HOUR_OF_DAY);
            if (stunde >= 20 || stunde < 6) {
                // Die Gebühren für jede angefangene Stunde in diesem Zeitraum dürfen maximal 5 Euro sein
                if (gebuehr > 500) {
                    gebuehr = 500;  // Maximal 5 Euro während der Nachtzeit
                }
            }

            // Erhöhe die Zeit um eine Stunde, um jede Stunde zu prüfen
            einfahrtsCal.add(Calendar.HOUR_OF_DAY, 1);
        }
        return gebuehr;
    }

    // Methode zum Finden der Einfahrtszeit des PKWs nach Kennzeichen
    private Date findeEinfahrtZeit(String kennzeichen) {
        for (PKW pkw : parkendePkws) {
            if (pkw.getKennzeichen().equals(kennzeichen)) {
                return pkw.getEinfahrt();
            }
        }
        return new Date();  // Falls kein PKW gefunden wurde, aktuelles Datum als Fallback
    }


    // Methode zum Generieren eines zufälligen Kennzeichens
    public String generiereKennzeichen() {
        Random random = new Random();

        // 2 bis 3 Buchstaben für Stadt/Region
        String stadtRegion = randomString(random, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", random.nextInt(2) + 2);

        // 1 bis 2 Buchstaben für Fahrzeugklasse
        String fahrzeugKlasse = randomString(random, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", random.nextInt(2) + 1);

        // 1 bis 4 Ziffern für die Nummer
        String nummer = randomString(random, "0123456789", random.nextInt(4) + 1);

        // Optional ein "E" für Elektrofahrzeuge
        String elektro = random.nextBoolean() ? "E" : "";

        // Zusammenfügen des Kennzeichens
        return stadtRegion + "-" + fahrzeugKlasse + " " + nummer + elektro;
    }


    // Hilfsmethode zur Erzeugung einer zufälligen Zeichenkette
    private static String randomString(Random random, String zeichen, int laenge) {
        StringBuilder sb = new StringBuilder(laenge);
        for (int i = 0; i < laenge; i++) {
            sb.append(zeichen.charAt(random.nextInt(zeichen.length())));
        }
        return sb.toString();
    }
}