package fr.iut_fbleau.Avalam;

import javax.swing.*;
import java.awt.*;

/**
* La classe <code>BoardView</code>
*
* Représente la vue principale du plateau Avalam.
* Elle gère :
* - l’affichage des tours (PieceLayer)
* - l’affichage des coups possibles (HighlightLayer)
* - l’affichage du fond graphique
* - les clics via InteractionController
*
* Cette classe ne contient aucune logique de règles du jeu.
*
* @version 1.0
* Date :
* Licence :
*/
public class BoardView extends JLayeredPane {

    //Attributs

    /** Référence au moteur Avalam. */
    private AvalamBoard board;

    /** Couche d’affichage du fond. */
    private BackgroundLayer backgroundLayer;

    /** Couche d’affichage des coups possibles. */
    private HighlightLayer highlightLayer;

    /** Couche d’affichage des pièces. */
    private PieceLayer pieceLayer;

    /** Contrôleur des interactions. */
    private InteractionController controller;

    /** Taille d’un pion en pixels. */
    private final int size = 50;

    /** Espacement entre les cases. */
    private final int spacing = 70;

    /** Décalage horizontal du plateau. */
    private final int xBase = 60;

    /** Décalage vertical du plateau. */
    private final int yBase = 60;

    /** Callback vers AvalamWindow pour mise à jour (score, tour, fin). */
    private Runnable boardUpdateCallback;

    //Constructeur

    /**
    * Construit la vue du plateau.
    *
    * @param board moteur du jeu
    * @param boardUpdateCallback callback à appeler après un coup
    */
    public BoardView(AvalamBoard board, Runnable boardUpdateCallback) {
        this.board = board;
        this.boardUpdateCallback = boardUpdateCallback;

        setLayout(null);

        // Contrôleur
        this.controller = new InteractionController(board, this);

        // Couche fond
        backgroundLayer = new BackgroundLayer("fr/iut_fbleau/Res/BackgroundAvalam.png");
        backgroundLayer.setBounds(0, 0, 725, 725);
        add(backgroundLayer, JLayeredPane.FRAME_CONTENT_LAYER);

        // Couche highlight
        highlightLayer = new HighlightLayer(xBase, yBase, spacing, size);
        add(highlightLayer, JLayeredPane.DEFAULT_LAYER);

        // Couche pièces
        pieceLayer = new PieceLayer();
        add(pieceLayer, JLayeredPane.PALETTE_LAYER);

        setPreferredSize(new Dimension(725, 725));

        refresh();
    }

    //Méthodes

    /**
    * Retourne le contrôleur d'interactions (utile pour simuler les clics du bot).
    *
    * @return contrôleur
    */
    public InteractionController getController() {
        return controller;
    }

    /**
    * Active/désactive les interactions utilisateur sur le plateau.
    * Utile pendant l'animation du bot pour éviter des clics concurrents.
    *
    * @param enabled true pour activer, false pour désactiver
    */
    public void setInteractionEnabled(boolean enabled) {
        // Désactive la couche des pièces (boutons) principalement
        pieceLayer.setEnabled(enabled);
        for (Component c : pieceLayer.getComponents()) {
            c.setEnabled(enabled);
        }
    }

    /**
    * Appelé par le contrôleur après un coup.
    */
    public void onBoardUpdated() {
        if (boardUpdateCallback != null) {
            boardUpdateCallback.run();
        }
    }

    /**
    * Rafraîchit les couches visuelles.
    */
    public void refresh() {

        pieceLayer.displayGrid(
                boardGrid(),
                xBase, yBase, spacing, size,
                (r, c) -> controller.onPieceClicked(r, c)
        );

        highlightLayer.setLegalMoves(controller.getLegalMoves());

        backgroundLayer.repaint();
        highlightLayer.repaint();
        pieceLayer.repaint();
        repaint();
    }

    /**
    * Récupère la grille depuis le moteur.
    *
    * @return grille 9x9 de tours
    */
    private Tower[][] boardGrid() {
        Tower[][] grid = new Tower[AvalamBoard.SIZE][AvalamBoard.SIZE];

        for (int r = 0; r < AvalamBoard.SIZE; r++) {
            for (int c = 0; c < AvalamBoard.SIZE; c++) {
                grid[r][c] = board.getTowerAt(r, c);
            }
        }
        return grid;
    }

    //Affichage

    /**
    * Composant affichant l’image de fond.
    */
    private static class BackgroundLayer extends JComponent {
        private Image img;

        /**
        * Construit une couche de fond.
        *
        * @param resourcePath chemin de l'image de fond
        */
        public BackgroundLayer(String resourcePath) {
            img = Toolkit.getDefaultToolkit().getImage(
                    getClass().getClassLoader().getResource(resourcePath)
            );
        }

        /**
        * Dessine l'image de fond.
        *
        * @param g contexte graphique
        */
        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            if (img != null) {
                g.drawImage(img, 0, 0, getWidth(), getHeight(), this);
            }
        }
    }
}