/*
============================================================
This is the "Spiel" file from Author: Philipp Kotte
written on: 05 / 10 / 2023 at: 23:25 
============================================================
*/
package Facade;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Scanner;

import Domain.Kartenstapel;
import Domain.Spieler;
import Domain.Stich;
import Domain.Block.Block;
import Domain.Enums.Geschlecht;
import Domain.Enums.Kartenfarbe;
import Domain.Exceptions.EmptyListException;
import Domain.Exceptions.MagierTrumpfException;
import Domain.Exceptions.NarrenTrumpfException;
import Domain.Exceptions.SpielerNotFoundException;
import Domain.Karten.Karte;
import Domain.Karten.Magierkarte;
import Domain.Karten.Narrenkarte;
import Domain.Karten.Zahlenkarte;

public class Spiel implements Serializable {

    /*--------------------------------------------------------*/
    // statische Konstanten
    /*--------------------------------------------------------*/

    private static final String ANSI_RESET = "\u001B[0m";
    private static final String ANSI_GREEN = "\u001B[32m";
    private static final String ANSI_RED = "\u001B[31m";
    public static final String ANSI_BLUE = "\u001B[34m";

    /*--------------------------------------------------------*/
    // statische Attribute(zB. zähler)
    /*--------------------------------------------------------*/

    /*--------------------------------------------------------*/
    // Attribute jedes Objektes
    /*--------------------------------------------------------*/

    private boolean istGestartet;
    private boolean istBeendet;
    private Spieler spielerAmZug;
    private int runde;
    private ArrayList<Spieler> spieler = new ArrayList<>();
    private ArrayList<Stich> stiche = new ArrayList<>();
    private boolean[] id_check = { false, false, false, false, false, false };
    private Kartenstapel kartenstapel;
    private Block block;

    /*--------------------------------------------------------*/
    // Konstruktoren (default und spezifische)
    /*--------------------------------------------------------*/

    public Spiel() {
        this.istGestartet = false;
        this.istBeendet = false;
        this.spielerAmZug = null;
        this.runde = 1;
        this.kartenstapel = new Kartenstapel();
    };
    /*--------------------------------------------------------
     statische Methoden
    --------------------------------------------------------*/
    /*--------------------------------------------------------
    Getter und Setter
    --------------------------------------------------------*/

    public void setSpielGestartet(boolean gestarted) {
        this.istGestartet = gestarted;
    }

    public void setSpielBeendet(boolean beendet) {
        this.istBeendet = beendet;
    }

    public void setRunde(int runde) {
        this.runde = runde;
    }

    public void setSpielerAmZug(Spieler spieler) {
        this.spielerAmZug = spieler;
    }

    /*--------------------------------------------------------
    @Overrides
    --------------------------------------------------------*/

    @Override
    public String toString() {
        String text = "\n";
        String header = "Systemausgabe--------------------------------\n";
        String footer = "---------------------------------------------\n";
        text += header;
        text += "Runde: " + getRunde() + "\n";
        text += "Gestartet : " + (istSpielGestartet() ? "Ja " : "Nein ") + "\n";
        text += "Beendet: " + (istSpielBeendet() ? "Ja" : "Nein") + "\n";
        text += "Spieler am Zug: "
                + (this.spielerAmZug == null ? "Noch keine Spieler vorhanden" : this.spielerAmZug.getName()) + "\n";
        if (this.spieler.size() == 0) {
            text += "Noch keine Spieler vorhanden \n";
        } else {
            for (Spieler s : this.spieler) {
                text += "[" + s.getId() + "] " + s.getName() + " ("
                        + s.getGeschlecht() + ")" + "\n";

            }
        }
        for (int i = 0; i < this.id_check.length; i++) {
            if (this.id_check[i]) {
                text += "idcheck" + ANSI_BLUE + " [" + i + "] " + ANSI_GREEN + this.id_check[i] + ANSI_RESET + " \n";
            } else {
                text += "idcheck" + ANSI_BLUE + " [" + i + "] " + ANSI_RED + this.id_check[i] + ANSI_RESET + " \n";
            }

        }
        text += footer;
        return text;
    }

    /*--------------------------------------------------------
    öffentliche Methodes
    --------------------------------------------------------*/

    public void addSpieler(String name, Geschlecht geschlecht) {
        int id = 1;
        while (id_check[id - 1]) {
            id++;
        }
        id_check[id - 1] = true;
        Spieler temp = new Spieler(id, name, geschlecht);
        this.spieler.add(temp);
        updateSpielerAmZug();
    }

    public void removeSpieler(int index) throws SpielerNotFoundException, EmptyListException, RuntimeException {
        if (this.spieler.size() >= index) {
            this.spieler.remove(index);
            this.id_check[index - 1] = false;
        } else if (this.spieler.size() < index) {
            throw new SpielerNotFoundException("Dieser Spieler existiert nicht");
        } else if (this.spieler.size() == 0) {
            throw new EmptyListException("Dise Liste ist Leer.");
        } else {
            throw new RuntimeException("Unkown Error");
        }
        updateSpielerAmZug();
    }

    public String[] getAlleSpieler() {
        String[] spieler_text = new String[this.spieler.size()];
        int zähler = 0;
        for (Spieler s : this.spieler) {
            spieler_text[zähler] = s.toString();
            zähler++;
        }
        return spieler_text;
    }

    public void starteSpiel() throws MagierTrumpfException, NarrenTrumpfException {
        // sing genügend Spieler angelegt?
        if (this.spieler.size() >= 3 && this.spieler.size() <= 6) {
            this.istGestartet = true;
            erstelleStiche(this.runde);
            austeilen();
            // Karte k = this.kartenstapel.getObersteKarte();
            Karte k = new Magierkarte(0);
            if (k instanceof Magierkarte) {
                throw new MagierTrumpfException("Es wurde ein Magier als Trumpf gezogen");
            } else if (k instanceof Narrenkarte) {
                setTrumpf(null);
                throw new NarrenTrumpfException("Es wurde ein Narr als Trumpf gezogen");
            } else {
                Zahlenkarte zk = (Zahlenkarte) k;
                setTrumpf(zk.getFarbe());
            }
            // While loop mit der länge der anzahl Stiche für die jeweilige Runde

            // Für jeden Durchgang des Loops wird der Stich ermittelt

            // Wer gewonnen hat wird dann der Stich zugeordnet

            // prüfen ob das Spiel zuende ist

            // Der Spieler der jetzt am Zug ist, ist der der den letzten Stich gewonne hat

            // Runde erhöhen

        } else {
            System.out.println("Es fehlen " + (3 - this.spieler.size()) + " spieler");
        }

    }

    /**
     * Gibt den Spieler zurück, der am Zug ist.
     * 
     * @return String[] -> name, id, geschlecht, vorhersage
     */
    public String[] getSpielerAmZug() {
        Spieler s = this.spielerAmZug;
        String[] temp = { s.getName(), "" + s.getId(), s.getGeschlecht().toString(), "" + s.getVorhersage() };
        return temp;
    }

    public boolean istSpielGestartet() {
        return this.istGestartet;
    }

    public void setTrumpf(Kartenfarbe kf) {
        Stich s = (Stich) this.stiche.get(0);
        s.setTurmpfFarbe(kf);
    }

    public boolean istSpielBeendet() {
        return this.istBeendet;
    }

    public String[][] getBlock() {
        return new String[0][0];
    }

    public String getGewinner() {
        return "";
    }

    public int getRunde() {
        return this.runde;
    }

    public void austeilen() {
        this.kartenstapel.mischen();
        for (int i = 0; i < this.runde; i++) {
            for (Spieler s : this.spieler) {
                Karte k = this.kartenstapel.getObersteKarte();
                if (k instanceof Magierkarte) {
                    s.addKarte(((Magierkarte) k));
                } else if (k instanceof Zahlenkarte) {
                    s.addKarte(((Zahlenkarte) k));
                } else {
                    s.addKarte((Narrenkarte) k);
                }

            }
        }

    }

    public void ausspielen(int idKarte) {

    }

    public void vorhersagen(int stiche) {

    }

    /*--------------------------------------------------------*/
    // Hilfsmethoden (privat)
    /*--------------------------------------------------------*/

    private void erstelleStiche(int runde) {
        for (int i = 0; i < runde; i++) {
            this.stiche.add(new Stich(this.spieler.size()));
        }
    }

    /*
     * private void ermittleGewinner(Stich stich) {
     * stich.getKarten();
     * }
     */

    private void updateSpielerAmZug() {
        if (this.spieler.size() >= 1) {
            this.spielerAmZug = this.spieler.get(0);
        } else {
            this.spielerAmZug = null;
        }
    }

    private void updateSpielerList(Spieler gewinner) {
        ArrayList<Spieler> temp = new ArrayList<>(this.spieler.size());
        int start = 0;
        for (int i = 0; i < this.spieler.size(); i++) {
            if (this.spieler.get(i) == gewinner) {
                start = i;
            }
        }

        for (int i = start; i < this.spieler.size(); i++) {
            temp.add(this.spieler.get(i));
        }
        for (int i = 0; i < start; i++) {
            temp.add(this.spieler.get(i));
        }

        this.spieler = temp;
        this.spielerAmZug = temp.get(0);
    }

}