/**
 * Classe utilitaire centralisant la logique de création et d'affichage des notifications
 * pour l'application Best 2048.
 * Gère également la création du canal de notification nécessaire pour Android 8.0 (API 26) et supérieur.
 * Utilise {@link NotificationCompat} pour assurer la compatibilité avec les anciennes versions d'Android.
 */
package legion.muyue.best2048;

import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager; // Import pour PackageManager.PERMISSION_GRANTED
import android.os.Build;
import android.util.Log; // Pour le logging des erreurs/warnings

import androidx.annotation.NonNull; // Pour marquer les paramètres non-null
import androidx.core.app.ActivityCompat; // Pour checkSelfPermission (remplace ContextCompat ici)
import androidx.core.app.NotificationCompat;
import androidx.core.app.NotificationManagerCompat;
// import androidx.core.content.ContextCompat; // Peut être utilisé mais ActivityCompat est plus direct pour la permission ici

public class NotificationHelper {

    /**
     * Identifiant unique et constant pour le canal de notification de cette application.
     * Ce même ID doit être utilisé lors de la création de la notification via {@link NotificationCompat.Builder}.
     * Il est visible par l'utilisateur dans les paramètres de notification de l'application sur Android 8.0+.
     */
    public static final String CHANNEL_ID = "BEST_2048_CHANNEL"; // Doit correspondre à celui utilisé dans MainActivity/Service

    /** Tag pour les logs spécifiques à ce helper. */
    private static final String TAG = "NotificationHelper";

    /**
     * Crée le canal de notification requis pour afficher des notifications sur Android 8.0 (API 26) et supérieur.
     * Si le canal existe déjà, cette méthode ne fait rien (elle est idempotente).
     * Doit être appelée une fois, idéalement au démarrage de l'application (par exemple dans `Application.onCreate`
     * ou dans `MainActivity.onCreate`), avant d'afficher la toute première notification sur un appareil API 26+.
     *
     * @param context Le contexte applicatif ({@code Context}) utilisé pour accéder aux services système.
     */
    public static void createNotificationChannel(@NonNull Context context) {
        // La création de canal n'est nécessaire que sur Android Oreo (API 26) et versions ultérieures
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            // Récupère les chaînes de caractères pour le nom et la description du canal depuis les ressources
            CharSequence name = context.getString(R.string.notification_channel_name);
            String description = context.getString(R.string.notification_channel_description);
            // Définit l'importance du canal (affecte comment la notification est présentée à l'utilisateur)
            // IMPORTANCE_DEFAULT est un bon point de départ pour la plupart des notifications.
            int importance = NotificationManager.IMPORTANCE_DEFAULT;

            // Crée l'objet NotificationChannel
            NotificationChannel channel = new NotificationChannel(CHANNEL_ID, name, importance);
            channel.setDescription(description);
            // Optionnel : Configurer d'autres propriétés du canal ici (vibration, lumière, son par défaut, etc.)
            // channel.enableLights(true);
            // channel.setLightColor(Color.RED);
            // channel.enableVibration(true);
            // channel.setVibrationPattern(new long[]{100, 200, 300, 400, 500, 400, 300, 200, 400});

            // Récupère le NotificationManager système
            NotificationManager notificationManager = context.getSystemService(NotificationManager.class);

            // Enregistre le canal auprès du système. Si le canal existe déjà, aucune opération n'est effectuée.
            if (notificationManager != null) {
                Log.d(TAG, "Création ou mise à jour du canal de notification: " + CHANNEL_ID);
                notificationManager.createNotificationChannel(channel);
            } else {
                Log.e(TAG, "NotificationManager non disponible, impossible de créer le canal.");
            }
        } else {
            Log.d(TAG, "API < 26, pas besoin de créer de canal de notification.");
        }
    }

    /**
     * Construit et affiche une notification standard pour l'application.
     * Vérifie la permission {@code POST_NOTIFICATIONS} sur Android 13 (API 33) et supérieur
     * avant de tenter d'afficher la notification. Si la permission est manquante,
     * un message d'erreur est logué et la méthode se termine sans afficher de notification.
     *
     * @param context        Le contexte ({@code Context}, peut être une Activity, un Service, etc.)
     * utilisé pour construire la notification et accéder aux ressources.
     * @param title          Le titre à afficher dans la notification.
     * @param message        Le contenu textuel principal de la notification.
     * @param notificationId Un identifiant entier unique pour cette notification. Permet de mettre à jour
     * ou d'annuler cette notification spécifique plus tard en utilisant le même ID.
     */
    public static void showNotification(@NonNull Context context, @NonNull String title, @NonNull String message, int notificationId) {
        Log.d(TAG, "Tentative d'affichage de la notification ID: " + notificationId + " Titre: " + title);

        // --- Vérification de la permission pour Android 13 (API 33) et supérieur ---
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
            // Utilise ActivityCompat.checkSelfPermission pour vérifier la permission
            if (ActivityCompat.checkSelfPermission(context, android.Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
                // Si la permission n'est pas accordée, loguer un avertissement et ne pas continuer.
                // L'application appelante (ex: MainActivity, Service) est responsable de demander la permission
                // si l'utilisateur a indiqué vouloir recevoir des notifications.
                Log.w(TAG, "Permission POST_NOTIFICATIONS manquante pour API 33+. Notification ID " + notificationId + " non affichée.");
                // Optionnel : Envoyer un broadcast ou utiliser une autre méthode pour signaler l'échec ? Non, simple log suffit ici.
                return;
            } else {
                Log.d(TAG, "Permission POST_NOTIFICATIONS accordée sur API 33+.");
            }
        } else {
            Log.d(TAG, "API < 33, permission POST_NOTIFICATIONS non requise pour afficher.");
        }

        // --- Création de l'Intent pour le clic sur la notification ---
        // Ouvre MainActivity lorsque l'utilisateur clique sur la notification.
        Intent intent = new Intent(context, MainActivity.class);
        // Flags pour gérer correctement la pile d'activités (ramène l'instance existante ou en crée une nouvelle)
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
        // Flags pour le PendingIntent (requis : IMMUTABLE sur API 31+)
        int pendingIntentFlags = PendingIntent.FLAG_UPDATE_CURRENT;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            pendingIntentFlags |= PendingIntent.FLAG_IMMUTABLE;
        }
        // Crée le PendingIntent qui enveloppe l'Intent
        PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, pendingIntentFlags);

        // --- Construction de la notification via NotificationCompat ---
        NotificationCompat.Builder builder = new NotificationCompat.Builder(context, CHANNEL_ID)
                .setSmallIcon(R.drawable.ic_stat_notification_2048) // Icône obligatoire (doit être monochrome/blanche avec transparence)
                // .setLargeIcon(BitmapFactory.decodeResource(context.getResources(), R.mipmap.ic_launcher)) // Icône optionnelle plus grande
                .setContentTitle(title)                 // Titre de la notification
                .setContentText(message)                // Texte principal
                .setPriority(NotificationCompat.PRIORITY_DEFAULT) // Priorité (affecte l'affichage head-up, etc.)
                .setContentIntent(pendingIntent)        // Action à exécuter au clic
                .setAutoCancel(true)                    // Ferme automatiquement la notification après le clic
                .setDefaults(NotificationCompat.DEFAULT_SOUND | NotificationCompat.DEFAULT_VIBRATE) // Utilise son/vibration par défaut du système (si autorisé)
                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC); // Visible sur l'écran de verrouillage

        // --- Affichage de la notification ---
        // Utilise NotificationManagerCompat pour la compatibilité
        NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);

        try {
            // Affiche la notification. Si une notification avec le même ID existe déjà, elle est mise à jour.
            notificationManager.notify(notificationId, builder.build());
            Log.i(TAG, "Notification ID " + notificationId + " affichée avec succès.");
        } catch (SecurityException e){
            // Gérer l'exception de sécurité qui peut (rarement) survenir même avec la vérification ci-dessus.
            Log.e(TAG, "Erreur de sécurité lors de l'affichage de la notification ID " + notificationId, e);
            // Afficher un Toast ou logguer est généralement suffisant ici.
        } catch (Exception ex) {
            // Capturer d'autres exceptions potentielles
            Log.e(TAG, "Erreur inattendue lors de l'affichage de la notification ID " + notificationId, ex);
        }
    }
}