GUYCOM_FLUTTER/lib/Services/app_database.dart

import 'dart:async';
import 'dart:io';
import 'package:flutter/services.dart';
import 'package:path/path.dart';
import 'package:path_provider/path_provider.dart';
import 'package:sqflite_common_ffi/sqflite_ffi.dart';
import '../Models/users.dart';
import '../Models/role.dart';
import '../Models/Permission.dart';

class AppDatabase {
  static final AppDatabase instance = AppDatabase._init();
  late Database _database;

  AppDatabase._init() {
    sqfliteFfiInit();
  }

  Future<Database> get database async {
    if (_database.isOpen) return _database;
    _database = await _initDB('app_database.db');
    return _database;
  }

  Future<void> initDatabase() async {
    _database = await _initDB('app_database.db');
    await _createDB(_database, 1);
    await insertDefaultPermissions();
    await insertDefaultMenus();
    await insertDefaultRoles();
    await insertDefaultSuperAdmin();
  }

  Future<Database> _initDB(String filePath) async {
    final documentsDirectory = await getApplicationDocumentsDirectory();
    final path = join(documentsDirectory.path, filePath);

    bool dbExists = await File(path).exists();
    if (!dbExists) {
      try {
        ByteData data = await rootBundle.load('assets/database/$filePath');
        List<int> bytes = data.buffer.asUint8List(data.offsetInBytes, data.lengthInBytes);
        await File(path).writeAsBytes(bytes);
      } catch (e) {
        print('Pas de fichier DB dans assets, création d\'une nouvelle DB');
      }
    }

    return await databaseFactoryFfi.openDatabase(path);
  }

  Future<void> _createDB(Database db, int version) async {
    final tables = await db.rawQuery("SELECT name FROM sqlite_master WHERE type='table'");
    final tableNames = tables.map((row) => row['name'] as String).toList();

    if (!tableNames.contains('roles')) {
      await db.execute('''
        CREATE TABLE roles (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          designation TEXT NOT NULL UNIQUE
        )
      ''');
      print("Table 'roles' créée.");
    }

    if (!tableNames.contains('permissions')) {
      await db.execute('''
        CREATE TABLE permissions (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          name TEXT NOT NULL UNIQUE
        )
      ''');
      print("Table 'permissions' créée.");
    }

    if (!tableNames.contains('menu')) {
      await db.execute('''
        CREATE TABLE menu (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          name TEXT NOT NULL UNIQUE,
          route TEXT NOT NULL UNIQUE
        )
      ''');
      print("Table 'menu' créée.");
    }

    if (!tableNames.contains('role_permissions')) {
      await db.execute('''
        CREATE TABLE role_permissions (
          role_id INTEGER,
          permission_id INTEGER,
          PRIMARY KEY (role_id, permission_id),
          FOREIGN KEY (role_id) REFERENCES roles(id) ON DELETE CASCADE,
          FOREIGN KEY (permission_id) REFERENCES permissions(id) ON DELETE CASCADE
        )
      ''');
      print("Table 'role_permissions' créée.");
    }

    if (!tableNames.contains('menu_permissions')) {
      await db.execute('''
        CREATE TABLE menu_permissions (
          menu_id INTEGER,
          permission_id INTEGER,
          PRIMARY KEY (menu_id, permission_id),
          FOREIGN KEY (menu_id) REFERENCES menu(id) ON DELETE CASCADE,
          FOREIGN KEY (permission_id) REFERENCES permissions(id) ON DELETE CASCADE
        )
      ''');
      print("Table 'menu_permissions' créée.");
    }

    if (!tableNames.contains('users')) {
      await db.execute('''
        CREATE TABLE users (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          name TEXT NOT NULL,
          lastname TEXT NOT NULL,
          email TEXT NOT NULL UNIQUE,
          password TEXT NOT NULL,
          username TEXT NOT NULL UNIQUE,
          role_id INTEGER NOT NULL,
          FOREIGN KEY (role_id) REFERENCES roles(id)
        )
      ''');
      print("Table 'users' créée.");
    }
    if (!tableNames.contains('role_menu_permissions')) {
  await db.execute('''
    CREATE TABLE role_menu_permissions (
      role_id INTEGER,
      menu_id INTEGER,
      permission_id INTEGER,
      PRIMARY KEY (role_id, menu_id, permission_id),
      FOREIGN KEY (role_id) REFERENCES roles(id) ON DELETE CASCADE,
      FOREIGN KEY (menu_id) REFERENCES menu(id) ON DELETE CASCADE,
      FOREIGN KEY (permission_id) REFERENCES permissions(id) ON DELETE CASCADE
    )
  ''');
  print("Table 'role_menu_permissions' créée.");
}

  }

 Future<void> insertDefaultPermissions() async {
  final db = await database;
  final existing = await db.query('permissions');
  if (existing.isEmpty) {
    await db.insert('permissions', {'name': 'view'});
    await db.insert('permissions', {'name': 'create'});
    await db.insert('permissions', {'name': 'update'});
    await db.insert('permissions', {'name': 'delete'});
    await db.insert('permissions', {'name': 'admin'});
    await db.insert('permissions', {'name': 'manage'}); // Nouvelle permission
    await db.insert('permissions', {'name': 'read'});   // Nouvelle permission
    print("Permissions par défaut insérées");
  } else {
    // Vérifier et ajouter les nouvelles permissions si elles n'existent pas
    final newPermissions = ['manage', 'read'];
    for (var permission in newPermissions) {
      final existingPermission = await db.query('permissions', where: 'name = ?', whereArgs: [permission]);
      if (existingPermission.isEmpty) {
        await db.insert('permissions', {'name': permission});
        print("Permission ajoutée: $permission");
      }
    }
  }
}

  Future<void> insertDefaultMenus() async {
  final db = await database;
  final existingMenus = await db.query('menu');

  if (existingMenus.isEmpty) {
    // Menus existants
    await db.insert('menu', {'name': 'Accueil', 'route': '/accueil'});
    await db.insert('menu', {'name': 'Ajouter un utilisateur', 'route': '/ajouter-utilisateur'});
    await db.insert('menu', {'name': 'Modifier/Supprimer un utilisateur', 'route': '/modifier-utilisateur'});
    await db.insert('menu', {'name': 'Ajouter un produit', 'route': '/ajouter-produit'});
    await db.insert('menu', {'name': 'Modifier/Supprimer un produit', 'route': '/modifier-produit'});
    await db.insert('menu', {'name': 'Bilan', 'route': '/bilan'});
    await db.insert('menu', {'name': 'Gérer les rôles', 'route': '/gerer-roles'});
    await db.insert('menu', {'name': 'Gestion de stock', 'route': '/gestion-stock'});
    await db.insert('menu', {'name': 'Historique', 'route': '/historique'});
    await db.insert('menu', {'name': 'Déconnexion', 'route': '/deconnexion'});
    
    // Nouveaux menus ajoutés
    await db.insert('menu', {'name': 'Nouvelle commande', 'route': '/nouvelle-commande'});
    await db.insert('menu', {'name': 'Gérer les commandes', 'route': '/gerer-commandes'});
    
    print("Menus par défaut insérés");
  } else {
    // Si des menus existent déjà, vérifier et ajouter les nouveaux menus manquants
    await _addMissingMenus(db);
  }
}

Future<void> _addMissingMenus(Database db) async {
  final menusToAdd = [
    {'name': 'Nouvelle commande', 'route': '/nouvelle-commande'},
    {'name': 'Gérer les commandes', 'route': '/gerer-commandes'},
  ];

  for (var menu in menusToAdd) {
    final existing = await db.query(
      'menu',
      where: 'route = ?',
      whereArgs: [menu['route']],
    );
    
    if (existing.isEmpty) {
      await db.insert('menu', menu);
      print("Menu ajouté: ${menu['name']}");
    }
  }
}

  Future<void> insertDefaultRoles() async {
  final db = await database;
  final existingRoles = await db.query('roles');

  if (existingRoles.isEmpty) {
    int superAdminRoleId = await db.insert('roles', {'designation': 'Super Admin'});
    int adminRoleId = await db.insert('roles', {'designation': 'Admin'});
    int userRoleId = await db.insert('roles', {'designation': 'User'});

    final permissions = await db.query('permissions');
    final menus = await db.query('menu');

    // Assigner toutes les permissions à tous les menus pour le Super Admin
    for (var menu in menus) {
      for (var permission in permissions) {
        await db.insert('role_menu_permissions', {
          'role_id': superAdminRoleId,
          'menu_id': menu['id'],
          'permission_id': permission['id'],
        },
         conflictAlgorithm: ConflictAlgorithm.ignore
        );
      }
    }

    // Assigner quelques permissions à l'Admin et à l'User pour les nouveaux menus
    await _assignBasicPermissionsToRoles(db, adminRoleId, userRoleId);

    print("Rôles par défaut créés et permissions assignées");
  } else {
    // Si les rôles existent déjà, vérifier et ajouter les permissions manquantes
    await _updateExistingRolePermissions(db);
  }
}
// Nouvelle méthode pour assigner les permissions de base aux nouveaux menus
Future<void> _assignBasicPermissionsToRoles(Database db, int adminRoleId, int userRoleId) async {
  final viewPermission = await db.query('permissions', where: 'name = ?', whereArgs: ['view']);
  final createPermission = await db.query('permissions', where: 'name = ?', whereArgs: ['create']);
  final updatePermission = await db.query('permissions', where: 'name = ?', whereArgs: ['update']);
  final managePermission = await db.query('permissions', where: 'name = ?', whereArgs: ['manage']);

  // Récupérer les IDs des nouveaux menus
  final nouvelleCommandeMenu = await db.query('menu', where: 'route = ?', whereArgs: ['/nouvelle-commande']);
  final gererCommandesMenu = await db.query('menu', where: 'route = ?', whereArgs: ['/gerer-commandes']);

  if (nouvelleCommandeMenu.isNotEmpty && createPermission.isNotEmpty) {
    // Admin peut créer de nouvelles commandes
    await db.insert('role_menu_permissions', {
      'role_id': adminRoleId,
      'menu_id': nouvelleCommandeMenu.first['id'],
      'permission_id': createPermission.first['id'],
    },
     conflictAlgorithm: ConflictAlgorithm.ignore
    );
    
    // User peut aussi créer de nouvelles commandes
    await db.insert('role_menu_permissions', {
      'role_id': userRoleId,
      'menu_id': nouvelleCommandeMenu.first['id'],
      'permission_id': createPermission.first['id'],
    },
     conflictAlgorithm: ConflictAlgorithm.ignore
    );
  }

  if (gererCommandesMenu.isNotEmpty && managePermission.isNotEmpty) {
    // Admin peut gérer les commandes
    await db.insert('role_menu_permissions', {
      'role_id': adminRoleId,
      'menu_id': gererCommandesMenu.first['id'],
      'permission_id': managePermission.first['id'],
    },
     conflictAlgorithm: ConflictAlgorithm.ignore
    );
  }

  if (gererCommandesMenu.isNotEmpty && viewPermission.isNotEmpty) {
    // User peut voir les commandes
    await db.insert('role_menu_permissions', {
      'role_id': userRoleId,
      'menu_id': gererCommandesMenu.first['id'],
      'permission_id': viewPermission.first['id'],
    }
    , conflictAlgorithm: ConflictAlgorithm.ignore
    );
  }
}
Future<void> _updateExistingRolePermissions(Database db) async {
  final superAdminRole = await db.query('roles', where: 'designation = ?', whereArgs: ['Super Admin']);
  if (superAdminRole.isNotEmpty) {
    final superAdminRoleId = superAdminRole.first['id'] as int;
    final permissions = await db.query('permissions');
    final menus = await db.query('menu');

    // Vérifier et ajouter les permissions manquantes pour le Super Admin sur tous les menus
    for (var menu in menus) {
      for (var permission in permissions) {
        final existingPermission = await db.query(
          'role_menu_permissions',
          where: 'role_id = ? AND menu_id = ? AND permission_id = ?',
          whereArgs: [superAdminRoleId, menu['id'], permission['id']],
        );
        if (existingPermission.isEmpty) {
          await db.insert('role_menu_permissions', {
            'role_id': superAdminRoleId,
            'menu_id': menu['id'],
            'permission_id': permission['id'],
          },
           conflictAlgorithm: ConflictAlgorithm.ignore
          );
        }
      }
    }

    // Assigner les permissions de base aux autres rôles pour les nouveaux menus
    final adminRole = await db.query('roles', where: 'designation = ?', whereArgs: ['Admin']);
    final userRole = await db.query('roles', where: 'designation = ?', whereArgs: ['User']);
    
    if (adminRole.isNotEmpty && userRole.isNotEmpty) {
      await _assignBasicPermissionsToRoles(db, adminRole.first['id'] as int, userRole.first['id'] as int);
    }

    print("Permissions mises à jour pour tous les rôles");
  }
}


  Future<void> insertDefaultSuperAdmin() async {
    final db = await database;

    final existingSuperAdmin = await db.rawQuery('''
      SELECT u.* FROM users u
      INNER JOIN roles r ON u.role_id = r.id
      WHERE r.designation = 'Super Admin'
    ''');

    if (existingSuperAdmin.isEmpty) {
      final superAdminRole = await db.query('roles',
        where: 'designation = ?',
        whereArgs: ['Super Admin']
      );

      if (superAdminRole.isNotEmpty) {
        final superAdminRoleId = superAdminRole.first['id'] as int;

        await db.insert('users', {
          'name': 'Super',
          'lastname': 'Admin',
          'email': 'superadmin@youmazgestion.com',
          'password': 'admin123',
          'username': 'superadmin',
          'role_id': superAdminRoleId,
        });

        print("Super Admin créé avec succès !");
        print("Username: superadmin");
        print("Password: admin123");
        print("ATTENTION: Changez ce mot de passe après la première connexion !");
      }
    } else {
      print("Super Admin existe déjà");
    }
  }

  Future<int> createUser(Users user) async {
    final db = await database;
    return await db.insert('users', user.toMap());
  }

  Future<int> deleteUser(int id) async {
    final db = await database;
    return await db.delete('users', where: 'id = ?', whereArgs: [id]);
  }

  Future<int> updateUser(Users user) async {
    final db = await database;
    return await db.update('users', user.toMap(), where: 'id = ?', whereArgs: [user.id]);
  }

  Future<int> getUserCount() async {
    final db = await database;
    List<Map<String, dynamic>> result = await db.rawQuery('SELECT COUNT(*) as count FROM users');
    return result.first['count'] as int;
  }

  Future<bool> verifyUser(String username, String password) async {
    final db = await database;
    final result = await db.rawQuery('''
      SELECT users.id
      FROM users
      WHERE users.username = ? AND users.password = ?
    ''', [username, password]);
    return result.isNotEmpty;
  }

  Future<Users> getUser(String username) async {
    final db = await database;
    final result = await db.rawQuery('''
      SELECT users.*, roles.designation as role_name
      FROM users
      INNER JOIN roles ON users.role_id = roles.id
      WHERE users.username = ?
    ''', [username]);

    if (result.isNotEmpty) {
      return Users.fromMap(result.first);
    } else {
      throw Exception('User not found');
    }
  }

  Future<Map<String, dynamic>?> getUserCredentials(String username, String password) async {
    final db = await database;
    final result = await db.rawQuery('''
      SELECT users.username, users.id, roles.designation as role_name, roles.id as role_id
      FROM users
      INNER JOIN roles ON users.role_id = roles.id
      WHERE username = ? AND password = ?
    ''', [username, password]);

    if (result.isNotEmpty) {
      return {
        'id': result.first['id'],
        'username': result.first['username'] as String,
        'role': result.first['role_name'] as String,
        'role_id': result.first['role_id'],
      };
    } else {
      return null;
    }
  }

  Future<List<Users>> getAllUsers() async {
    final db = await database;
    final result = await db.rawQuery('''
      SELECT users.*, roles.designation as role_name
      FROM users
      INNER JOIN roles ON users.role_id = roles.id
      ORDER BY users.id ASC
    ''');
    return result.map((json) => Users.fromMap(json)).toList();
  }

  Future<int> createRole(Role role) async {
    final db = await database;
    return await db.insert('roles', role.toMap());
  }

  Future<List<Role>> getRoles() async {
    final db = await database;
    final maps = await db.query('roles', orderBy: 'designation ASC');
    return List.generate(maps.length, (i) => Role.fromMap(maps[i]));
  }

  Future<int> updateRole(Role role) async {
    final db = await database;
    return await db.update(
      'roles',
      role.toMap(),
      where: 'id = ?',
      whereArgs: [role.id],
    );
  }

  Future<int> deleteRole(int? id) async {
    final db = await database;
    return await db.delete(
      'roles',
      where: 'id = ?',
      whereArgs: [id],
    );
  }

  Future<List<Permission>> getAllPermissions() async {
    final db = await database;
    final result = await db.query('permissions', orderBy: 'name ASC');
    return result.map((e) => Permission.fromMap(e)).toList();
  }

  Future<List<Permission>> getPermissionsForRole(int roleId) async {
    final db = await database;
    final result = await db.rawQuery('''
      SELECT p.id, p.name
      FROM permissions p
      JOIN role_permissions rp ON p.id = rp.permission_id
      WHERE rp.role_id = ?
      ORDER BY p.name ASC
    ''', [roleId]);

    return result.map((map) => Permission.fromMap(map)).toList();
  }

  Future<List<Permission>> getPermissionsForUser(String username) async {
    final db = await database;
    final result = await db.rawQuery('''
      SELECT DISTINCT p.id, p.name
      FROM permissions p
      JOIN role_permissions rp ON p.id = rp.permission_id
      JOIN roles r ON rp.role_id = r.id
      JOIN users u ON u.role_id = r.id
      WHERE u.username = ?
      ORDER BY p.name ASC
    ''', [username]);

    return result.map((map) => Permission.fromMap(map)).toList();
  }

  Future<void> assignPermission(int roleId, int permissionId) async {
    final db = await database;
    await db.insert('role_permissions', {
      'role_id': roleId,
      'permission_id': permissionId,
    }, conflictAlgorithm: ConflictAlgorithm.ignore);
  }

  Future<void> removePermission(int roleId, int permissionId) async {
    final db = await database;
    await db.delete(
      'role_permissions',
      where: 'role_id = ? AND permission_id = ?',
      whereArgs: [roleId, permissionId],
    );
  }

  Future<void> assignMenuPermission(int menuId, int permissionId) async {
    final db = await database;
    await db.insert('menu_permissions', {
      'menu_id': menuId,
      'permission_id': permissionId,
    }, conflictAlgorithm: ConflictAlgorithm.ignore);
  }

  Future<void> removeMenuPermission(int menuId, int permissionId) async {
    final db = await database;
    await db.delete(
      'menu_permissions',
      where: 'menu_id = ? AND permission_id = ?',
      whereArgs: [menuId, permissionId],
    );
  }

  Future<bool> isSuperAdmin(String username) async {
    final db = await database;
    final result = await db.rawQuery('''
      SELECT COUNT(*) as count
      FROM users u
      INNER JOIN roles r ON u.role_id = r.id
      WHERE u.username = ? AND r.designation = 'Super Admin'
    ''', [username]);

    return (result.first['count'] as int) > 0;
  }

  Future<void> changePassword(String username, String oldPassword, String newPassword) async {
    final db = await database;

    final isValidOldPassword = await verifyUser(username, oldPassword);
    if (!isValidOldPassword) {
      throw Exception('Ancien mot de passe incorrect');
    }

    await db.update(
      'users',
      {'password': newPassword},
      where: 'username = ?',
      whereArgs: [username],
    );
  }

 Future<bool> hasPermission(String username, String permissionName, String menuRoute) async {
  final db = await database;
  final result = await db.rawQuery('''
    SELECT COUNT(*) as count
    FROM permissions p
    JOIN role_menu_permissions rmp ON p.id = rmp.permission_id
    JOIN roles r ON rmp.role_id = r.id
    JOIN users u ON u.role_id = r.id
    JOIN menu m ON m.route = ?
    WHERE u.username = ? AND p.name = ? AND rmp.menu_id = m.id
  ''', [menuRoute, username, permissionName]);

  return (result.first['count'] as int) > 0;
}


  Future<void> close() async {
    if (_database.isOpen) {
      await _database.close();
    }
  }

  Future<void> printDatabaseInfo() async {
    final db = await database;

    print("=== INFORMATIONS DE LA BASE DE DONNÉES ===");

    final userCount = await getUserCount();
    print("Nombre d'utilisateurs: $userCount");

    final users = await getAllUsers();
    print("Utilisateurs:");
    for (var user in users) {
      print("  - ${user.username} (${user.name} ) - Email: ${user.email}");
    }

    final roles = await getRoles();
    print("Rôles:");
    for (var role in roles) {
      print("  - ${role.designation} (ID: ${role.id})");
    }

    final permissions = await getAllPermissions();
    print("Permissions:");
    for (var permission in permissions) {
      print("  - ${permission.name} (ID: ${permission.id})");
    }

    print("=========================================");
  }

  Future<List<Permission>> getPermissionsForRoleAndMenu(int roleId, int menuId) async {
  final db = await database;
  final result = await db.rawQuery('''
    SELECT p.id, p.name
    FROM permissions p
    JOIN role_menu_permissions rmp ON p.id = rmp.permission_id
    WHERE rmp.role_id = ? AND rmp.menu_id = ?
    ORDER BY p.name ASC
  ''', [roleId, menuId]);

  return result.map((map) => Permission.fromMap(map)).toList();
}
  // Ajoutez cette méthode temporaire pour supprimer la DB corrompue
Future<void> deleteDatabaseFile() async {
  final documentsDirectory = await getApplicationDocumentsDirectory();
  final path = join(documentsDirectory.path, 'app_database.db');
  final file = File(path);
  if (await file.exists()) {
    await file.delete();
    print("Base de données utilisateur supprimée");
  }
}
Future<void> assignRoleMenuPermission(int roleId, int menuId, int permissionId) async {
  final db = await database;
  await db.insert('role_menu_permissions', {
    'role_id': roleId,
    'menu_id': menuId,
    'permission_id': permissionId,
  }, conflictAlgorithm: ConflictAlgorithm.ignore);
}



Future<void> removeRoleMenuPermission(int roleId, int menuId, int permissionId) async {
  final db = await database;
  await db.delete(
    'role_menu_permissions',
    where: 'role_id = ? AND menu_id = ? AND permission_id = ?',
    whereArgs: [roleId, menuId, permissionId],
  );
}

}