package sudoku;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Scanner;

import sudoku.core.Console;
import sudoku.core.GenerateurCouleur;

/**
 * Classe Grille permettant de créer une grille de sudoku.
 */
public class Grille {
    private final int taille;
    private final Case[][] cases;
    private final ArrayList<Bloc> blocs;
    private ArrayList<Symbole> symbolesPossibles;
    private final Sudoku sudoku; // Référence à Sudoku
    private Multidoku multidoku; // Référence à Multidoku
    private List<String> generatedColors;

    /**
     * Constructeur permettant d'initialiser une grille grace aux paramètres
     * suivants :
     * 
     * @param taille : taille de la grille
     * @param sudoku : sudoku
     */
    public Grille(int taille, Sudoku sudoku) {
        this.taille = taille;
        this.cases = new Case[taille][taille];
        this.blocs = new ArrayList<>();
        this.symbolesPossibles = new ArrayList<>();
        this.sudoku = sudoku;
        initColors();

        // Initialiser les cases
        for (int i = 0; i < taille; i++) {
            for (int j = 0; j < taille; j++) {
                cases[i][j] = new Case(i, j, null);
            }
        }
    }

    /**
     * Méthode permettant de mettre à jour la référence au multidoku
     * 
     * @param multidoku : multidoku
     * @see Multidoku
     */
    public void setMultidoku(Multidoku multidoku) {
        this.multidoku = multidoku;
    }

    /**
     * Génère une palette de couleurs en fonction du nombre de blocs attendus.
     * Pour un sudoku classique, la grille est de taille n², et il y a n² blocs,
     * on génère donc 'taille' couleurs.
     */
    private void initColors() {
        // nombre de couleurs = nombre de blocs (pour sudoku classique)
        List<GenerateurCouleur.Couleur> colors = GenerateurCouleur.paletteCouleurEtendue(taille);
        generatedColors = new ArrayList<>();
        for (GenerateurCouleur.Couleur color : colors) {
            generatedColors.add(convertToAnsi(color));
        }
    }

    /**
     * Convertit une couleur en format ANSI pour l'affichage en console.
     * 
     * @param color : couleur à convertir
     * @return couleur convertie
     */
    private String convertToAnsi(GenerateurCouleur.Couleur color) {
        int r = Math.round(color.r * 255);
        int g = Math.round(color.g * 255);
        int b = Math.round(color.b * 255);
        return String.format("\u001B[38;2;%d;%d;%dm", r, g, b);
    }

    /**
     * Méthode permettant de définir un symbole dans une case en fonction de sa
     * ligne, de sa colonne et du symbole
     * 
     * @param ligne   : coordonnée de la ligne
     * @param colonne : coordonnée de la colonne
     * @param symbole : symbole à placer
     */
    public void setCase(int ligne, int colonne, Symbole symbole) {
        try {
            if (symbole != null && !symbolesPossibles.contains(symbole)) {
                throw new IllegalArgumentException("Symbole non autorisé : " + symbole);
            }

            Case currentCase = cases[ligne][colonne];
            Symbole ancienSymbole = currentCase.getSymbole();
            currentCase.setSymbole(symbole);

            if (!sudoku.verifierToutesContraintes() ||
                    (multidoku != null && !multidoku.verifierContraintesPartagees())) {
                currentCase.setSymbole(ancienSymbole);
                throw new IllegalArgumentException(
                        "Les contraintes ne sont pas respectées pour la case (" + ligne + ", " + colonne + ")");
            }
        } catch (Exception e) {
            Console.errorln(e.getMessage());
        }
    }

    /**
     * Méthode permettant de retourner une case en fonction de sa ligne et de sa
     * colonne
     * 
     * @param ligne   : coordonnée de la ligne
     * @param colonne : coordonnée de la colonne
     * @return Case
     */
    public Case getCase(int ligne, int colonne) {
        return cases[ligne][colonne];
    }

    /**
     * Méthode permettant de créer un bloc personnalisé en fonction des positions
     * passées en paramètre <br />
     * <br />
     *
     * Exemple de positions pour un sudoku 9x9 : <br />
     * sudoku.getGrille().creerBlocPersonnalise(Arrays.asList( <br />
     * new int[] { 0, 0 }, <br />
     * new int[] { 0, 1 }, <br />
     * new int[] { 0, 2 }, <br />
     * new int[] { 1, 0 }, <br />
     * new int[] { 1, 1 }, <br />
     * new int[] { 1, 2 }, <br />
     * new int[] { 2, 0 }, <br />
     * new int[] { 2, 1 }, <br />
     * new int[] { 2, 2 } <br />
     * );
     *
     * @param positions : liste de positions pour le bloc personnalisé <br />
     */
    public void creerBlocPersonnalise(List<int[]> positions) {
        try {
            // Validation des positions
            for (int[] pos : positions) {
                if (pos[0] < 0 || pos[0] >= taille || pos[1] < 0 || pos[1] >= taille) {
                    throw new IllegalArgumentException("Position invalide : (" + pos[0] + ", " + pos[1] + ")");
                }
            }

            // Choisir la couleur suivante en fonction du nombre de blocs déjà créés
            setCouleurBloc(positions);

        } catch (IllegalArgumentException e) {
            Console.errorln(e.getMessage());
        }
    }

    private void setCouleurBloc(List<int[]> positions) {
        int couleurIndex = blocs.size() % generatedColors.size();
        Bloc bloc = new Bloc(generatedColors.get(couleurIndex), couleurIndex);

        for (int[] pos : positions) {
            bloc.ajouterCase(cases[pos[0]][pos[1]]);
        }
        blocs.add(bloc);
    }

    /**
     * Crée des blocs carrés (par exemple pour un sudoku classique).
     */
    public void creerBlocCarre() {
        int blocSize = (int) Math.sqrt(taille);
        if (blocSize * blocSize != taille) {
            throw new IllegalArgumentException("La taille de la grille doit être un carré parfait.");
        }

        // Création des blocs en motif (par exemple 3x3 pour un sudoku 9x9)
        for (int blocRow = 0; blocRow < blocSize; blocRow++) {
            for (int blocCol = 0; blocCol < blocSize; blocCol++) {
                List<int[]> positions = new ArrayList<>();

                // Ajouter toutes les positions pour le bloc courant
                for (int i = 0; i < blocSize; i++) {
                    for (int j = 0; j < blocSize; j++) {
                        positions.add(new int[] {
                                blocRow * blocSize + i,
                                blocCol * blocSize + j
                        });
                    }
                }

                setCouleurBloc(positions);
            }
        }
    }

    /**
     * Crée des blocs rectangulaires.
     * 
     * @param blocHeight : hauteur du bloc
     * @param blocWidth  : largeur du bloc
     */
    public void creerBlocRectangulaire(int blocHeight, int blocWidth) {
        if (taille % blocHeight != 0 || taille % blocWidth != 0) {
            throw new IllegalArgumentException(
                    "La taille de la grille doit être divisible par les dimensions des blocs.");
        }

        int blocsParLigne = taille / blocWidth;
        int blocsParColonne = taille / blocHeight;

        // Création des blocs en motif rectangulaire
        for (int blocRow = 0; blocRow < blocsParColonne; blocRow++) {
            for (int blocCol = 0; blocCol < blocsParLigne; blocCol++) {
                List<int[]> positions = new ArrayList<>();

                // Ajouter toutes les positions pour le bloc courant
                for (int i = 0; i < blocHeight; i++) {
                    for (int j = 0; j < blocWidth; j++) {
                        positions.add(new int[] {
                                blocRow * blocHeight + i,
                                blocCol * blocWidth + j
                        });
                    }
                }

                setCouleurBloc(positions);
            }
        }
    }

    /**
     * Méthode permettant d'afficher les blocs de la grille à l'aide de la méthode
     * toString de la classe Bloc.
     */
    public void printBlocs() {
        for (Bloc bloc : blocs) {
            System.out.println(bloc.toString());
        }
    }

    /**
     * Méthode utilisée pour le menu princial.
     * Méthode permettant de choisir le type de symbole à utiliser pour la grille
     * 
     * @param scanner : scanner pour lire l'entrée utilisateur
     * @return int : choix de l'utilisateur
     */
    public static int choisirTypeSymbole(Scanner scanner) {
        while (true) {
            System.out.println("Choisissez le type de symbole :");
            System.out.println("1 : Entiers");
            System.out.println("2 : Lettres");
            System.out.println("3 : Chaînes de caractères / Emoji");

            String input = scanner.nextLine();
            try {
                int choix = Integer.parseInt(input);
                if (choix >= 1 && choix <= 3) {
                    return choix;
                } else {
                    System.out.println("Choix invalide. Veuillez entrer 1, 2 ou 3.");
                }
            } catch (NumberFormatException e) {
                System.out.println("Entrée invalide. Veuillez entrer un nombre.");
            }
        }
    }

    /**
     * Méthode utilisée pour le menu principal.
     * Méthode permettant de demander à l'utilisateur de saisir les symboles
     * possibles pour la grille.
     * 
     * @param choix   : choix de l'utilisateur
     * @param scanner : scanner pour lire l'entrée utilisateur
     */
    public void askSetSymbolesPossibles(int choix, Scanner scanner) {
        try {
            for (int i = 0; i < taille; i++) {
                System.out.println("Entrez le symbole " + (i + 1) + "/" + taille + " :");
                String input = scanner.nextLine();

                switch (choix) {
                    case 1: // Nombres
                        try {
                            Symbole intTemp = Symbole.of(Integer.parseInt(input));
                            if (symbolesPossibles.contains(intTemp)) {
                                Console.errorln("Ce symbole existe déjà, veuillez entrer un autre symbole");
                                i--;
                            } else {
                                symbolesPossibles.add(intTemp);
                            }
                        } catch (NumberFormatException e) {
                            Console.errorln("Veuillez entrer un nombre valide");
                            i--;
                        }
                        break;

                    case 2: // Lettres
                        if (input.length() == 1 && Symbole.of(input.charAt(0)).isLetter()) {
                            Symbole charTemp = Symbole.of(input.charAt(0));
                            if (symbolesPossibles.contains(charTemp)) {
                                Console.errorln("Ce symbole existe déjà, veuillez entrer un autre symbole");
                                i--;
                            } else {
                                symbolesPossibles.add(charTemp);
                            }
                        } else {
                            Console.errorln("Veuillez entrer une lettre valide");
                            i--;
                        }
                        break;

                    case 3: // Texte/Emoji
                        Symbole stringTemp = Symbole.of(input);
                        if (symbolesPossibles.contains(stringTemp)) {
                            Console.errorln("Ce symbole existe déjà, veuillez entrer un autre symbole");
                            i--;
                        } else if (Objects.equals(input, "ESC")) {
                            Console.errorln("Ce symbole est interdit, veuillez entrer un autre symbole");
                            i--;
                        } else {
                            symbolesPossibles.add(stringTemp);
                        }
                        break;

                    default:
                        Console.errorln("Type non supporté");
                        return;
                }
            }
        } catch (Exception e) {
            Console.errorln("Une erreur est survenue : " + e.getMessage());
            Console.errorln("Une erreur est survenue : " + e.getMessage());
        }
    }

    /**
     * Méthode permettant de retourner la liste des symboles possible.
     * Cela dépend de ce que saisit l'utilisateur dans la méthode
     * askSetSymbolesPossibles
     * 
     * @return List la liste des symboles possibles
     * @see Symbole
     */
    public List<Symbole> getSymbolesPossibles() {
        return symbolesPossibles;
    }

    /**
     * Méthode permettant d'ajouter un symbole à la liste des symboles possibles
     * 
     * @param symbolesPossibles : liste des symboles possibles
     */
    public void setSymbolesPossibles(ArrayList<Symbole> symbolesPossibles) {
        this.symbolesPossibles = symbolesPossibles;
    }

    /**
     * Méthode permettant d'afficher la liste des symboles possibles
     */
    public void printSymbolesPossibles() {
        StringBuilder sb = new StringBuilder();
        for (Symbole symbole : symbolesPossibles) {
            sb.append(symbole.toString()).append(" ");
        }
        System.out.println(sb);
    }

    /**
     * Méthode permettant de retourner la taille de la grille
     * 
     * @return taille
     */
    public int getTaille() {
        return taille;
    }

    Bloc findBlocForCase(Case target) {
        for (Bloc bloc : blocs) {
            if (bloc.getCases().contains(target)) {
                return bloc;
            }
        }
        return null; // Ne dois jamais arriver si la grille est bien construite
    }

    /**
     * Vérifie si toutes les contraintes sont respectées.
     * S'arrête dès qu'une contrainte n'est pas respectée.
     *
     * @param contraintes : liste des contraintes à vérifier
     * @return true si toutes les contraintes sont respectées, false sinon
     */
    public boolean verifierToutesContraintes(List<Contrainte> contraintes) {
        // Vérifier chaque case de la grille
        for (int i = 0; i < taille; i++) {
            for (int j = 0; j < taille; j++) {
                Case currentCase = cases[i][j];
                // Ne vérifier que les cases qui ont un symbole
                if (currentCase.getSymbole() != null) {
                    // Vérifier toutes les contraintes pour cette case
                    for (Contrainte contrainte : contraintes) {
                        if (!contrainte.estRespectee(this, currentCase)) {
                            Console.errorln(
                                    "GRILLE: Contrainte non respectée à la position : ligne=" + i + ", colonne=" + j);
                            return false;
                        }
                    }
                }
            }
        }
        return true;
    }

    /**
     * Méthode permettant de retourner la longueur du symbole le plus long pour
     * dimensionner correctement les cases et la grille en console
     * 
     * @return int
     */
    public int getLongueurSymboleLePlusLong() {
        int max = 0;
        for (Symbole symbole : symbolesPossibles) {
            if (symbole.toString().length() > max) {
                max = symbole.toString().length();
            }
        }
        return max;
    }

    /**
     * Méthode permettant d'afficher la grille
     * 
     * @return String : représentation de la grille
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        int maxLen = getLongueurSymboleLePlusLong(); // longueur maximale des symboles

        for (int i = 0; i < taille; i++) {
            for (int j = 0; j < taille; j++) {
                Case currentCase = cases[i][j];
                String cellStr = currentCase.toString();
                // Calculer le nombre d'espaces à ajouter pour atteindre maxLen
                int pad = maxLen - cellStr.length();
                String padding = " ".repeat(pad);

                Bloc bloc = findBlocForCase(currentCase);

                if (bloc != null) {
                    sb.append(bloc.getCouleur()) // couleur du bloc
                            .append(cellStr) // symbole
                            .append(padding) // padding pour aligner les symboles
                            .append("\u001B[0m ") // réinitialiser la couleur
                            .append(" ");
                } else { // pas de bloc, afficher normalement
                    sb.append(cellStr)
                            .append(padding)
                            .append(" ");
                }
            }
            sb.append("\n"); // nouvelle ligne
        }
        return sb.toString();
    }

}