package fr.iut_fbleau.Avalam;

import fr.iut_fbleau.GameAPI.Player;
import fr.iut_fbleau.GameAPI.Result;

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

/**
* La classe <code>AvalamWindow</code>
*
* Fenêtre principale (interface graphique) du jeu Avalam.
* Elle contient :
* - le plateau (BoardView)
* - l'affichage du score (ScoreView)
* - l'affichage du joueur courant (TurnView)
*
* Elle pilote un objet <code>AvalamBoard</code> (moteur du jeu).
*/
public class AvalamWindow extends JFrame {

    //Attributs

    /** Moteur du jeu (état + règles). */
    private AvalamBoard board;

    /** Vue affichant le score des deux couleurs. */
    private ScoreView scoreView;

    /** Vue affichant le joueur dont c'est le tour. */
    private TurnView turnView;

    /** Vue affichant le plateau et gérant les interactions de jeu. */
    private BoardView boardView;

    //Constructeur

    /**
    * Construit la fenêtre et initialise l’interface :
    * - charge le plateau initial depuis Plateau.txt
    * - construit les vues (score, tour, plateau)
    * - affiche la fenêtre
    */
    public AvalamWindow() {
        super("Avalam");

        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new BorderLayout());

        // Chargement du plateau initial depuis Plateau.txt
        Tower[][] initialGrid = BoardLoader.loadFromFile("fr/iut_fbleau/Res/Plateau.txt");

        // Initialisation du moteur (PLAYER1 commence)
        board = new AvalamBoard(initialGrid);

        // Création du panneau supérieur (score + tour)
        JPanel topPanel = new JPanel(new GridLayout(2, 1));
        topPanel.setBackground(new java.awt.Color(200, 200, 200));

        scoreView = new ScoreView(
                computeScore(Color.YELLOW),
                computeScore(Color.RED)
        );

        turnView = new TurnView(turnMessage());

        topPanel.add(scoreView);
        topPanel.add(turnView);

        add(topPanel, BorderLayout.NORTH);

        // Création de la vue plateau (avec callback de mise à jour)
        boardView = new BoardView(board, this::onBoardUpdated);
        add(boardView, BorderLayout.CENTER);

        pack();
        setResizable(false);
        setLocationRelativeTo(null);
        setVisible(true);
    }

    //Méthodes

    /**
    * Méthode appelée automatiquement après chaque coup (via BoardView).
    * Elle rafraîchit :
    * - les scores
    * - le joueur courant
    * et affiche un message si la partie est terminée.
    */
    public void onBoardUpdated() {

        // Mise à jour du score
        scoreView.updateScores(
                computeScore(Color.YELLOW),
                computeScore(Color.RED)
        );

        // Mise à jour du joueur courant
        turnView.setTurn(turnMessage());

        // Détection de fin de partie
        if (board.isGameOver()) {
            Result res = board.getResult();

            String msg;

            // Correction : ajout des "break" pour éviter le fall-through.
            switch (res) {
                case WIN:
                    msg = "Le joueur jaune a gagné !";
                    break;
                case LOSS:
                    msg = "Le joueur rouge a gagné !";
                    break;
                case DRAW:
                    msg = "Égalité !";
                    break;
                default:
                    msg = "Fin de partie.";
                    break;
            }

            JOptionPane.showMessageDialog(
                    this,
                    msg,
                    "Partie terminée",
                    JOptionPane.INFORMATION_MESSAGE
            );
        }
    }

    /**
    * Calcule le score d'une couleur : nombre de tours contrôlées (sommet de la tour).
    *
    * @param c couleur à compter
    * @return nombre de tours appartenant à la couleur c
    */
    private int computeScore(Color c) {
        int score = 0;
        for (int r = 0; r < AvalamBoard.SIZE; r++) {
            for (int col = 0; col < AvalamBoard.SIZE; col++) {
                Tower t = board.getTowerAt(r, col);
                if (t != null && t.getColor() == c) {
                    score++;
                }
            }
        }
        return score;
    }

    /**
    * Retourne le message correspondant au joueur dont c'est le tour.
    *
    * @return message d’affichage du tour
    */
    private String turnMessage() {
        return "Tour du joueur : " +
                (board.getCurrentPlayer() == Player.PLAYER1 ? "Jaune" : "Rouge");
    }
}