<?php

class PlateauSquadro
{
    // Constantes pour les vitesses de déplacement
    const BLANC_V_ALLER = [0, 1, 3, 2, 3, 1, 0];
    const BLANC_V_RETOUR = [0, 3, 1, 2, 1, 3, 0];
    const NOIR_V_ALLER = [0, 3, 1, 2, 1, 3, 0];
    const NOIR_V_RETOUR = [0, 1, 3, 2, 3, 1, 0];

    // Variables d'instance
    private array $plateau; // Tableau de 7 ArrayPieceSquadro
    private array $lignesJouables; // Indices des lignes jouables
    private  array $colonnesJouables; // Indices des colonnes jouables

    public function __construct()
    {
        // Initialisation du plateau et des lignes/colonnes jouables
        $this->initCasesVides();
        $this->initCasesNeutres();
        $this->initCasesBlanches();
        $this->initCasesNoires();
        $this->lignesJouables = [1, 2, 3, 4, 5];
        $this->colonnesJouables = [1, 2, 3, 4, 5];
    }

    private function initCasesVides() :void
    {
        // Initialisation des cases du plateau comme vides
        $this->plateau = array_fill(0, 7, new ArrayPieceSquadro());
        for ($i = 0; $i < 7; $i++) {
            for ($j = 0; $j < 7; $j++) {
                $this->plateau[$i]->add(PieceSquadro::initVide());
            }
        }
    }

    private function initCasesNeutres() :void
    {
        // Initialisation des cases neutres sur le plateau
        foreach ([0, 6] as $i) {
            foreach ([0, 6] as $j) {
                $this->plateau[$i]->remove($j);
                $this->plateau[$i]->add(PieceSquadro::initNeutre(), $j);
            }
        }
    }

    private function initCasesBlanches() : void
    {
        // Placement des pièces blanches sur le côté ouest
        foreach ($this->lignesJouables as $i) {
            $this->plateau[$i]->remove(0);
            $this->plateau[$i]->add(PieceSquadro::initBlancOuest(), 0);
        }
    }

    private function initCasesNoires() : void
    {
        // Placement des pièces noires sur le côté sud
        foreach ($this->colonnesJouables as $j) {
            $this->plateau[6]->remove($j);
            $this->plateau[6]->add(PieceSquadro::initNoirSud(), $j);
        }
    }

    public function getPlateau() : array
    {
        // Retourne le plateau
        return $this->plateau;
    }

    public function getPiece(int $x, int $y): PieceSquadro
    {
        // Retourne la pièce aux coordonnées ($x, $y)
        return $this->plateau[$x][$y];
    }

    public function setPiece(PieceSquadro $piece, int $x, int $y): void
    {
        // Place une pièce aux coordonnées ($x, $y)
        $this->plateau[$x]->remove($y);
        $this->plateau[$x]->add($piece, $y);
    }

    public function getLignesJouables(): array
    {
        // Retourne les lignes jouables
        return $this->lignesJouables;
    }

    public function getColonnesJouables(): array
    {
        // Retourne les colonnes jouables
        return $this->colonnesJouables;
    }

    public function retireLigneJouable(int $index) : void
    {
        // Supprime un index de ligne des lignes jouables
        $this->lignesJouables = array_values(array_diff($this->lignesJouables, [$index]));
    }

    public function retireColonneJouable(int $index) : void
    {
        // Supprime un index de colonne des colonnes jouables
        $this->colonnesJouables = array_values(array_diff($this->colonnesJouables, [$index]));
    }

    public function getCoordDestination(int $x, int $y) : array
    {
        // Calcule les coordonnées de destination pour une pièce
        $piece = $this->getPiece($x, $y);
        $direction = $piece->getDirection();

        if ($piece->getCouleur() === PieceSquadro::BLANC) {
            // Détermine la vitesse en fonction de la direction pour les pièces blanches
            $vitesse = $direction === PieceSquadro::EST ? self::BLANC_V_ALLER[$x] : self::BLANC_V_RETOUR[$x];
            $newY = $direction === PieceSquadro::EST ? $y + $vitesse : $y - $vitesse;
            return [$x, max(0, min(6, $newY))];
        } elseif ($piece->getCouleur() === PieceSquadro::NOIR) {
            // Détermine la vitesse en fonction de la direction pour les pièces noires
            $vitesse = $direction === PieceSquadro::NORD ? self::NOIR_V_ALLER[$y] : self::NOIR_V_RETOUR[$y];
            $newX = $direction === PieceSquadro::NORD ? $x - $vitesse : $x + $vitesse;
            return [max(0, min(6, $newX)), $y];
        }

        return [$x, $y]; // Par défaut : pas de déplacement
    }

    public function getDestination(int $x, int $y): PieceSquadro
    {
        // Retourne la pièce aux coordonnées de destination
        [$newX, $newY] = $this->getCoordDestination($x, $y);
        return $this->getPiece($newX, $newY);
    }

    public function toJson(): string
    {
        // Sérialise le plateau en JSON
        return json_encode($this->plateau);
    }

    public static function fromJson(string $json): PlateauSquadro
    {
        // Désérialise un JSON en une instance de PlateauSquadro
        $data = json_decode($json, true);
        $plateau = new self();
        foreach ($data as $i => $row) {
            foreach ($row as $j => $pieceData) {
                $plateau->setPiece(PieceSquadro::fromJson(json_encode($pieceData)), $i, $j);
            }
        }
        return $plateau;
    }
}