package fr.iut_fbleau.Avalam.ui;

import fr.iut_fbleau.Avalam.Tower;
import fr.iut_fbleau.Avalam.logic.GameState;

import java.awt.*;
import java.util.ArrayList;
import java.util.List;

/**
 * La classe <code>InteractionController</code> gère entièrement
 * la logique d'interaction de l'utilisateur :
 *
 * <ul>
 *     <li>Sélection d'un pion</li>
 *     <li>Annulation de la sélection</li>
 *     <li>Calcul des cases de déplacement légales</li>
 * </ul>
 *
 * Aucun affichage n'est réalisé ici ; la vue (BoardView) récupère
 * simplement les données calculées pour les afficher.
 *
 * @author
 * @version 1.0
 */
public class InteractionController {

    private GameState state;

    /** Position du pion sélectionné (ou -1 s'il n'y en a pas). */
    private int selectedRow = -1, selectedCol = -1;

    /** Liste des déplacements possibles depuis la sélection. */
    private List<Point> legalMoves = new ArrayList<>();

    /**
     * Constructeur.
     *
     * @param state état du jeu à manipuler
     */
    public InteractionController(GameState state) {
        this.state = state;
    }

    /**
     * Retourne les cases jouables calculées.
     */
    public List<Point> getLegalMoves() {
        return legalMoves;
    }

    /**
     * Gère le clic sur un pion donné.
     *
     * @param r ligne de la case cliquée
     * @param c colonne de la case cliquée
     */
    public void onPieceClicked(int r, int c) {

        Tower t = state.get(r, c);
        if (t == null) return;

        // Annulation si on reclique la sélection
        if (r == selectedRow && c == selectedCol) {
            selectedRow = -1;
            selectedCol = -1;
            legalMoves.clear();
            return;
        }

        // Interdiction de jouer le pion adverse
        if (t.getColor() != state.getCurrentPlayer()) {
            selectedRow = -1;
            selectedCol = -1;
            legalMoves.clear();
            return;
        }

        selectedRow = r;
        selectedCol = c;

        computeLegalMoves();
    }

    /**
     * Calcule toutes les cases accessibles à partir du pion sélectionné.
     */
    private void computeLegalMoves() {

        legalMoves.clear();

        Tower[][] grid = state.getGrid();
        Tower src = grid[selectedRow][selectedCol];
        int h = src.getHeight();

        int[] d = {-1, 0, 1};

        for (int dr : d) {
            for (int dc : d) {

                if (dr == 0 && dc == 0) continue;

                int nr = selectedRow + dr;
                int nc = selectedCol + dc;

                if (!state.isInside(nr, nc)) continue;

                Tower dest = grid[nr][nc];
                if (dest == null) continue;
                if (h + dest.getHeight() > 5) continue;

                legalMoves.add(new Point(nr, nc));
            }
        }
    }
}