// src/app/modules/users/users.ts
import { Component, inject, OnInit, TemplateRef, ViewChild, ChangeDetectorRef, OnDestroy } from '@angular/core';
import { CommonModule } from '@angular/common';
import { FormsModule } from '@angular/forms';
import { NgIcon } from '@ng-icons/core';
import { NgbNavModule, NgbModal, NgbModalModule } from '@ng-bootstrap/ng-bootstrap';
import { Subject, takeUntil } from 'rxjs';
import { PageTitle } from '@app/components/page-title/page-title';
import { UsersList } from './list/list';
import { UserProfile } from './profile/profile';
import { HubUsersService, CreateHubUserDto, UserRole, HubUserResponse } from './services/users.service';
import { RoleManagementService } from '@core/services/role-management.service';
import { AuthService } from '@core/services/auth.service';

@Component({
  selector: 'app-users',
  standalone: true,
  imports: [
    CommonModule,
    FormsModule,
    NgIcon,
    NgbNavModule,
    NgbModalModule,
    PageTitle, 
    UsersList, 
    UserProfile
  ],
  templateUrl: './users.html',
})
export class Users implements OnInit, OnDestroy {
  private modalService = inject(NgbModal);
  private usersService = inject(HubUsersService);
  private authService = inject(AuthService);
  private cdRef = inject(ChangeDetectorRef);
  private destroy$ = new Subject<void>();
  
  // Rendre le service accessible au template via des méthodes proxy
  protected roleService = inject(RoleManagementService);

  activeTab: 'list' | 'profile' = 'list';
  selectedUserId: string | null = null;

  // Gestion des permissions
  currentUserRole: UserRole | null = null;
  userPermissions: any = null;
  canCreateUsers = false;
  canDeleteUsers = false;
  canManageRoles = false;

  // Données pour la création d'utilisateur
  newUser: CreateHubUserDto = {
    username: '',
    email: '',
    firstName: '',
    lastName: '',
    password: '',
    role: UserRole.DCB_SUPPORT,
    enabled: true,
    emailVerified: false
  };
  
  availableRoles: { value: UserRole; label: string; description: string }[] = [];
  assignableRoles: UserRole[] = [];

  creatingUser = false;
  createUserError = '';

  // Données pour la réinitialisation de mot de passe
  selectedUserForReset: HubUserResponse | null = null;
  newPassword = '';
  temporaryPassword = false;
  resettingPassword = false;
  resetPasswordError = '';
  resetPasswordSuccess = '';

  selectedUserForDelete: HubUserResponse | null = null;
  deletingUser = false;
  deleteUserError = '';

  ngOnInit() {
    this.activeTab = 'list';
    this.initializeUserPermissions();
    this.loadAvailableRoles();
  }

  ngOnDestroy(): void {
    this.destroy$.next();
    this.destroy$.complete();
  }

  /**
   * Initialise les permissions de l'utilisateur courant
   */
  private initializeUserPermissions(): void {
    this.authService.getUserProfile()
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: (profile) => {
          // Supposons que le rôle principal est le premier rôle
          this.currentUserRole = profile?.roles?.[0] as UserRole || null;
          
          if (this.currentUserRole) {
            this.roleService.setCurrentUserRole(this.currentUserRole);
            this.userPermissions = this.roleService.getPermissionsForRole(this.currentUserRole);
            this.canCreateUsers = this.roleService.canCreateUsers(this.currentUserRole);
            this.canDeleteUsers = this.roleService.canDeleteUsers(this.currentUserRole);
            this.canManageRoles = this.roleService.canManageRoles(this.currentUserRole);
            
            // Rôles que l'utilisateur peut attribuer
            this.assignableRoles = this.roleService.getAssignableRoles(this.currentUserRole);
          }
        },
        error: (error) => {
          console.error('Error loading user profile:', error);
        }
      });
  }

  /**
   * Charge les rôles disponibles
   */
  private loadAvailableRoles(): void {
    this.roleService.getAvailableRolesSimple()
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: (roles) => {
          this.availableRoles = roles;
        },
        error: (error) => {
          console.error('Error loading available roles:', error);
          // Fallback en cas d'erreur
          this.availableRoles = [
            { value: UserRole.DCB_ADMIN, label: 'DCB Admin', description: 'Administrateur système' },
            { value: UserRole.DCB_SUPPORT, label: 'DCB Support', description: 'Support technique' },
            { value: UserRole.DCB_PARTNER, label: 'DCB Partner', description: 'Partenaire commercial' }
          ];
        }
      });
  }

  /**
   * Vérifie si l'utilisateur peut attribuer un rôle spécifique
   */
  canAssignRole(targetRole: UserRole): boolean {
    return this.roleService.canAssignRole(this.currentUserRole, targetRole);
  }

  // Méthodes proxy pour le template
  getRoleBadgeClass(role: UserRole): string {
    return this.roleService.getRoleBadgeClass(role);
  }

  getRoleLabel(role: UserRole): string {
    return this.roleService.getRoleLabel(role);
  }

  getRoleIcon(role: UserRole): string {
    return this.roleService.getRoleIcon(role);
  }

  getRoleDescription(role: UserRole): string {
    const roleInfo = this.availableRoles.find(r => r.value === role);
    return roleInfo?.description || 'Description non disponible';
  }


  showTab(tab: 'list' | 'profile', userId?: string) {
    this.activeTab = tab;
    
    if (userId) {
      this.selectedUserId = userId;
    }
  }

  backToList() {
    this.activeTab = 'list';
    this.selectedUserId = null;
  }

  // Méthodes pour les modals
  openModal(content: TemplateRef<any>, size: 'sm' | 'lg' | 'xl' = 'lg') {
    this.modalService.open(content, { 
      size: size,
      centered: true,
      scrollable: true 
    });
  }

  // Méthode pour ouvrir le modal de création d'utilisateur
  openCreateUserModal() {
    if (!this.canCreateUsers) {
      console.warn('User does not have permission to create users');
      return;
    }

    this.newUser = {
      username: '',
      email: '',
      firstName: '',
      lastName: '',
      password: '',
      role: this.assignableRoles[0] || UserRole.DCB_SUPPORT,
      enabled: true,
      emailVerified: false
    };
    this.createUserError = '';
    this.openModal(this.createUserModal);
  }

  // Méthode pour ouvrir le modal de réinitialisation de mot de passe
  openResetPasswordModal(userId: string) {
    this.usersService.getUserById(userId)
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: (user) => {
          this.selectedUserForReset = user;
          this.newPassword = '';
          this.temporaryPassword = false;
          this.resetPasswordError = '';
          this.resetPasswordSuccess = '';
          this.openModal(this.resetPasswordModal);
        },
        error: (error) => {
          console.error('Error loading user for password reset:', error);
          this.resetPasswordError = 'Erreur lors du chargement de l\'utilisateur';
        }
      });
  }

  // Création d'utilisateur
  createUser() {
    if (!this.canCreateUsers) {
      this.createUserError = 'Vous n\'avez pas la permission de créer des utilisateurs';
      return;
    }

    const validation = this.validateUserForm();
    if (!validation.isValid) {
      this.createUserError = validation.error!;
      return;
    }

    // Vérifier que l'utilisateur peut attribuer ce rôle
    if (!this.canAssignRole(this.newUser.role)) {
      this.createUserError = 'Vous n\'avez pas la permission d\'attribuer ce rôle';
      return;
    }

    this.creatingUser = true;
    this.createUserError = '';

    this.usersService.createUser(this.newUser)
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: (createdUser) => {
          this.creatingUser = false;
          this.modalService.dismissAll();
          
          // Rafraîchir la liste
          if (this.usersListComponent) {
            this.usersListComponent.loadUsers();
          }

          this.showTab('list');
          this.cdRef.detectChanges();
        },
        error: (error) => {
          this.creatingUser = false;
          this.createUserError = this.getErrorMessage(error);
          this.cdRef.detectChanges();
        }
      });
  }

  // Réinitialiser le mot de passe
  confirmResetPassword() {
    if (!this.selectedUserForReset || !this.newPassword || this.newPassword.length < 8) {
      this.resetPasswordError = 'Veuillez saisir un mot de passe valide (au moins 8 caractères).';
      return;
    }

    this.resettingPassword = true;
    this.resetPasswordError = '';
    this.resetPasswordSuccess = '';

    this.usersService.resetPassword(
      this.selectedUserForReset.id, 
      this.newPassword, 
      this.temporaryPassword
    )
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: () => {
          this.resettingPassword = false;
          this.resetPasswordSuccess = 'Mot de passe réinitialisé avec succès !';
          this.cdRef.detectChanges();
        },
        error: (error) => {
          this.resettingPassword = false;
          this.resetPasswordError = this.getResetPasswordErrorMessage(error);
          this.cdRef.detectChanges();
        }
      });
  }

  // Méthode pour ouvrir le modal de suppression
  openDeleteUserModal(userId: string) {
    if (!this.canDeleteUsers) {
      console.warn('User does not have permission to delete users');
      return;
    }

    this.usersService.getUserById(userId)
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: (user) => {
          this.selectedUserForDelete = user;
          this.deleteUserError = '';
          this.openModal(this.deleteUserModal);
        },
        error: (error) => {
          console.error('Error loading user for deletion:', error);
          this.deleteUserError = 'Erreur lors du chargement de l\'utilisateur';
        }
      });
  }

  confirmDeleteUser() {
    if (!this.selectedUserForDelete || !this.canDeleteUsers) return;

    this.deletingUser = true;
    this.deleteUserError = '';

    this.usersService.deleteUser(this.selectedUserForDelete.id)
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: () => {
          this.deletingUser = false;
          this.modalService.dismissAll();
          
          // Rafraîchir la liste
          if (this.usersListComponent) {
            this.usersListComponent.loadUsers();
          }
          
          this.cdRef.detectChanges();
        },
        error: (error) => {
          this.deletingUser = false;
          this.deleteUserError = this.getDeleteErrorMessage(error);
          this.cdRef.detectChanges();
        }
      });
  }

  // Gestion des erreurs
  private getErrorMessage(error: any): string {
    if (error.error?.message) {
      return error.error.message;
    }
    if (error.status === 400) {
      return 'Données invalides. Vérifiez les champs du formulaire.';
    }
    if (error.status === 409) {
      return 'Un utilisateur avec ce nom ou email existe déjà.';
    }
    if (error.status === 403) {
      return 'Vous n\'avez pas les permissions nécessaires pour cette action.';
    }
    return 'Erreur lors de la création de l\'utilisateur. Veuillez réessayer.';
  }

  private getResetPasswordErrorMessage(error: any): string {
    if (error.error?.message) {
      return error.error.message;
    }
    if (error.status === 404) {
      return 'Utilisateur non trouvé.';
    }
    if (error.status === 400) {
      return 'Le mot de passe ne respecte pas les critères de sécurité.';
    }
    if (error.status === 403) {
      return 'Vous n\'avez pas les permissions pour réinitialiser ce mot de passe.';
    }
    return 'Erreur lors de la réinitialisation du mot de passe. Veuillez réessayer.';
  }

  private getDeleteErrorMessage(error: any): string {
    if (error.error?.message) {
      return error.error.message;
    }
    if (error.status === 404) {
      return 'Utilisateur non trouvé.';
    }
    if (error.status === 403) {
      return 'Vous n\'avez pas les permissions pour supprimer cet utilisateur.';
    }
    return 'Erreur lors de la suppression de l\'utilisateur. Veuillez réessayer.';
  }

  // Validation du formulaire
  private validateUserForm(): { isValid: boolean; error?: string } {
    const requiredFields = [
      { field: this.newUser.username?.trim(), name: 'Nom d\'utilisateur' },
      { field: this.newUser.email?.trim(), name: 'Email' },
      { field: this.newUser.firstName?.trim(), name: 'Prénom' },
      { field: this.newUser.lastName?.trim(), name: 'Nom' }
    ];

    for (const { field, name } of requiredFields) {
      if (!field) {
        return { isValid: false, error: `${name} est requis` };
      }
    }

    // Validation email
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    if (!emailRegex.test(this.newUser.email)) {
      return { isValid: false, error: 'Format d\'email invalide' };
    }

    if (!this.newUser.password || this.newUser.password.length < 8) {
      return { isValid: false, error: 'Le mot de passe doit contenir au moins 8 caractères' };
    }

    if (!this.newUser.role) {
      return { isValid: false, error: 'Le rôle est requis' };
    }

    return { isValid: true };
  }

  @ViewChild(UsersList) usersListComponent!: UsersList;

  // Références aux templates de modals
  @ViewChild('createUserModal') createUserModal!: TemplateRef<any>;
  @ViewChild('resetPasswordModal') resetPasswordModal!: TemplateRef<any>;
  @ViewChild('deleteUserModal') deleteUserModal!: TemplateRef<any>;
}