<?php
require_once 'ActionSquadro.php';
require_once 'PieceSquadro.php';
require_once 'ArrayPieceSquadro.php';

/**
 * Classe PlateauSquadro
 *
 * Cette classe représente le plateau de jeu pour Squadro.
 */
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

    /**
     * Constructeur de la classe PlateauSquadro.
     *
     * Initialise le plateau de jeu et les lignes/colonnes jouables.
     */
    public function __construct()
    {
        $this->lignesJouables = [1, 2, 3, 4, 5];
        $this->colonnesJouables = [1, 2, 3, 4, 5];
        $this->initCasesVides();
        $this->initCasesNeutres();
        $this->initCasesBlanches();
        $this->initCasesNoires();
    }

    /**
     * Initialise les cases du plateau comme vides.
     */
    private function initCasesVides(): void
    {
        $this->plateau = [];
        for ($i = 0; $i < 7; $i++) {
            $this->plateau[$i] = new ArrayPieceSquadro();
            for ($j = 0; $j < 7; $j++) {
                $this->plateau[$i][$j] = PieceSquadro::initVide();
            }
        }
    }

    /**
     * Initialise les cases neutres sur le plateau.
     */
    private function initCasesNeutres(): void
    {
        $this->plateau[0][0] = PieceSquadro::initNeutre();
        $this->plateau[0][6] = PieceSquadro::initNeutre();
        $this->plateau[6][0] = PieceSquadro::initNeutre();
        $this->plateau[6][6] = PieceSquadro::initNeutre();
    }

    /**
     * Place les pièces blanches sur le côté ouest.
     */
    private function initCasesBlanches(): void
    {
        foreach ($this->lignesJouables as $i) {
            $this->plateau[$i][0] = PieceSquadro::initBlancEst();
        }
    }

    /**
     * Place les pièces noires sur le côté sud.
     */
    private function initCasesNoires(): void
    {
        foreach ($this->colonnesJouables as $j) {
            $this->plateau[6][$j] = PieceSquadro::initNoirNord();
        }
    }

    /**
     * Retourne le plateau de jeu.
     *
     * @return array Le plateau de jeu.
     */
    public function getPlateau(): array
    {
        return $this->plateau;
    }

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

    /**
     * Place une pièce aux coordonnées données.
     *
     * @param PieceSquadro $piece La pièce à placer.
     * @param int $x La coordonnée x.
     * @param int $y La coordonnée y.
     */
    public function setPiece(PieceSquadro $piece, int $x, int $y): void
    {
        $this->plateau[$x][$y] = $piece;
    }

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

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

    /**
     * Supprime un index de ligne des lignes jouables.
     *
     * @param int $index L'index de la ligne à supprimer.
     */
    public function retireLigneJouable(int $index): void
    {
        $this->lignesJouables = array_values(array_diff($this->lignesJouables, [$index]));
    }

    /**
     * Supprime un index de colonne des colonnes jouables.
     *
     * @param int $index L'index de la colonne à supprimer.
     */
    public function retireColonneJouable(int $index): void
    {
        $this->colonnesJouables = array_values(array_diff($this->colonnesJouables, [$index]));
    }

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

        if ($piece->getCouleur() === PieceSquadro::BLANC) {
            $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) {
            $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
    }

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

    /**
     * Sérialise le plateau en JSON.
     *
     * @return string La représentation JSON du plateau.
     */
    public function toJson(): string
    {
        return json_encode($this->plateau);
    }

    /**
     * Désérialise un JSON en une instance de PlateauSquadro.
     *
     * @param string $json Le JSON à désérialiser.
     * @return PlateauSquadro L'instance désérialisée de PlateauSquadro.
     */
    public static function fromJson(string $json): 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;
    }
}