//Imports
import Card from "./cards/Card.js";
import ChooseColor from "./cards/special/ChooseColor.js";
import Skip from "./cards/special/Skip.js";
import PlusAmount from "./cards/special/PlusAmount.js";
import Reverse from "./cards/special/Reverse.js";
import Player from "./Player.js";
import {CARD_COLORS} from "./uno.js";
import Style from "./Style.js";

//Um generatePool zu exportieren, muss es in eine Klasse konvertiert werden
export default class Game {

    //Erstellt ein Spiel mit SpielerAnzahl und Array mit Regeln, initialisiert dann das Spiel
    constructor(playerAmount, rules) {

        this._cardOnDeck = null; //Karte die auf dem Tisch liegt
        this._currentPlayer = -1; //Aktueller Spieler Index im Player Array
        this._direction = 1; //Spielrichtung
        this._players = []; //Array mit allen Spielern drin
        this._cardPool = []; //Pool aus Karten

        this._playerAmount = playerAmount; //Anzahl der Spieler
        this._rules = rules; //Array mit Regeln für das Spiel

        this._stack = 0; //Für PlusAmountKarten

        //Für HTML
        this._style = new Style(this);

    }

    //Richtet das Spiel ein
    initGame() {

        //CardPool wird generiert
        this.cardPool = this.generatePool();

        //Spieler werden erstellt
        this.createPlayers(this._playerAmount);

    }

    //Startet das Spiel
    start() {
        if (this.currentPlayer !== -1) return;

        //Wenn das Spiel noch nicht initialisiert wurde, initialisiere es
        if (this.cardPool.length === 0 || this.players.length === 0) this.initGame();


        let firstCardIndex = 0;
        let boolFirstSpecial = false;

        if (this.rules !== null) {
            if ('startCards' in this.rules) for (let i = 0; i < this.players.length; i++) this.players[i].drawCard(this.rules.startCards, false, false);

            if ('firstPlaySpecial' in this.rules) boolFirstSpecial = this.rules.firstPlaySpecial;


        }

        if (!boolFirstSpecial) {
            for (let i = 0; i < this.cardPool.length; i++) {
                if (!(this.cardPool[i].name === 'R' || this.cardPool[i].name === 'S' || this.cardPool[i].name === 'CC' || this.cardPool[i].name === '+2' || this.cardPool[i].name === '+4')) {
                    firstCardIndex = i;
                    break;
                }
            }
        }

        //Die Erste Karte wird auf den Tisch gelegt
        this.cardOnDeck = this.cardPool[firstCardIndex];
        this.cardPool.splice(firstCardIndex, 1);

        //Karten Funktion der Karte auf dem Deck ausführen
        this.cardOnDeck.putSelf();


        //HTML

        this.style.refreshHtml();
    }

    //Gibt ein Array zurück mit allen Karten, die in einem Uno Spiel sind
    generatePool() {

        //Array wird erstellt, welches später zurückgegeben wird und alle Karten beinhaltet
        let pool = [];

        //Pool aus Karten generieren
        for (let k = 0; k < 2; k++) {

            //Special Karten werden hinzugefügt
            for (let j = 1; j < (CARD_COLORS.length); j++) {

                pool.push(new Reverse(CARD_COLORS[j], this)); // 8x Reverse
                pool.push(new PlusAmount(this, CARD_COLORS[j])); // 8x +2
                pool.push(new Skip(CARD_COLORS[j], this)); // 8x Skip

                if (k === 0) {

                    pool.push(new ChooseColor(this)); // 4x ChooseColor
                    pool.push(new PlusAmount(this)); // 4x +4

                }

                //Normale Karten werden hinzugefügt
                for (let i = 0; i <= 9; i++) {

                    if (k === 1 && i === 0) continue;
                    pool.push(new Card(i, CARD_COLORS[j], this)); // 76x (2x 4x 1-9 + 4x 0)

                }

            }

        }

        //Mischt das Array
        pool.sort(() => Math.random() - 0.5);

        //Array mit Karten wird zurückgegeben
        return pool;
    }

    //Fügt die Spieler hinzu
    createPlayers(playerAmount) {

        //Erstelle so viele Spieler, wie bei Erstellung des Spiels übergeben wurden
        for (let i = 0; i < playerAmount; i++) {
            this.players.push(new Player("Player" + (i + 1), this));
        }

    }

    //Beendet den Zug des aktuellen Spielers und beginnt den Zug des nächsten Spielers
    nextTurn() {

        let delay = 0;

        //Testet, ob Spiel Gewonnen
        for (let i = 0; i < this.players.length; i++) {
            if (this.players[i].hand.length <= 0) {

                //Breche den Loop ab
                return;
            }
        }


        //Wenn Zug nicht der Erste vom ganzen Spiel
        if (this.currentPlayer !== -1) {

            if (this.currentPlayerInstanz.mustSayUno === true) {
                this.currentPlayerInstanz.drawCard(2, false, true);
                delay += 1500;
                this.currentPlayerInstanz.mustSayUno = false;
            }

            //Aktuellen Spieler kann, darf nicht mehr Spielen
            this.players[this.currentPlayer].canPlay = false;
            this.players[this.currentPlayer].turn = false;

        }

        this.style.hideUnoButton();

        setTimeout(() => {


            //nächster Spieler wird gesetzt
            this.currentPlayer = this.nextPlayer();

            this.players[this.currentPlayer].turn = true;

            //Aktualisiere das Deck des aktuellen Spielers, welche Karten er legen kann
            this.refreshCanPutCard();

            //HTML
            this.style.refreshHtml();

            //PlusAmount
            let cardName = (this.cardOnDeck.name === "+4" || this.cardOnDeck.name === '+2') ? '+' : null;
            if (cardName === '+') {
                for (let i = 0; i < this.currentPlayerInstanz.hand.length; i++) {
                    if (this.currentPlayerInstanz.hand[i].name === this.cardOnDeck.name) {
                        return;
                    }
                }
            }


            if (this.stack !== 0) {
                setTimeout(() => {

                    this.currentPlayerInstanz.drawCard(this.stack, false, true);
                    this.stack = 0;

                }, 600);

            }

        }, delay)

    }

    //Testet alle Karten des aktuellen Spielers in seiner Hand, ob er sie legen kann
    refreshCanPutCard() {
        //Deck des aktuellen Spielers
        let currentPlayerCards = this.currentPlayerInstanz.hand;

        //Gehe alle Karten vom Deck durch
        for (let i = 0; i < currentPlayerCards.length; i++) {
            if (this.stack !== 0) {
                if (this.cardOnDeck.name === '+4' || this.cardOnDeck.name === '+2') {

                    for (let j = 0; j < currentPlayerCards.length; j++) {
                        if (currentPlayerCards[j].name.toString() === this.cardOnDeck.name.toString()) {
                            this.players[this.currentPlayer].hand[j].canPut = true;
                            this.players[this.currentPlayer].canPlay = true;
                        } else this.players[this.currentPlayer].hand[j].canPut = false;
                    }
                    break;
                }
            }

            //Wenn Farbe oder Zahl gleich oder eine Karte, die keine Farbe hat
            if (this.cardOnDeck.name.toString() === currentPlayerCards[i].name.toString()
                || this.cardOnDeck.color === currentPlayerCards[i].color
                || currentPlayerCards[i].color === CARD_COLORS[0]
                || this.cardOnDeck.color === CARD_COLORS[0]) {

                //Aktualisiere den Wert der Karte, sodass sie gelegt werden kann
                this.players[this.currentPlayer].hand[i].canPut = true;

                //Der Spieler kann nun Karten legen
                this.players[this.currentPlayer].canPlay = true;

            } else {

                //Sonst setze den Wert der Karte so, dass sie nicht gelegt werden kann
                this.players[this.currentPlayer].hand[i].canPut = false;

            }

        }

        //Uno sagen testen

        if (this.currentPlayerInstanz.hand.length === 2 && this.currentPlayerInstanz.canPlay){
            this.currentPlayerInstanz.mustSayUno = true;
            this.style.showUnoButton();
        }

    }

    //Errechne, wer der nächste Spieler ist
    nextPlayer() {
        if (this.currentPlayer === -1) return 0;

        //Anhand der Spielrichtung errechnen
        if (this._direction === 1) return (this._currentPlayer === this._players.length - 1) ? 0 : this._currentPlayer + 1; //bei normaler Richtung
        else return (this._currentPlayer === 0) ? this._players.length - 1 : this._currentPlayer - 1; //bei Invertierter Richtung

    }

    //Gib den Pool mit allen UnoKarten zurück
    get cardPool() {
        return this._cardPool;
    }

    set cardPool(pool) {
        this._cardPool = pool;
    }

    //Gibt das Array mit allen Spielern des Spiels zurück
    get players() {
        return this._players;
    }

    //Gibt die aktuelle Karte auf dem Tisch zurück
    get cardOnDeck() {
        return this._cardOnDeck;
    }

    //Setzt die aktuelle Karte auf dem Tisch
    set cardOnDeck(card) {
        this._cardOnDeck = card;
    }

    //Gibt den Index des aktuellen Spielers im players Array zurück
    get currentPlayer() {
        return this._currentPlayer;
    }

    //Gibt das Objekt des aktuellen Spielers zurück
    get currentPlayerInstanz() {
        return this._players[this.currentPlayer];
    }

    set currentPlayer(player) {
        this._currentPlayer = player
    }

    //Gibt die aktuelle Ricktung zurück 1 = normal 2 = Invertiert
    get direction() {
        return this._direction;
    }

    set direction(direction) {
        this._direction = direction;
    }

    get rules() {
        return this._rules;
    }

    get style() {
        return this._style;
    }

    get stack() {
        return this._stack;
    }

    set stack(stack) {
        this._stack = stack;
    }

}