import { Component, inject, OnInit, Output, EventEmitter, ChangeDetectorRef, OnDestroy, ViewChild, TemplateRef } from '@angular/core';
import { CommonModule } from '@angular/common';
import { FormsModule } from '@angular/forms';
import { NgIcon } from '@ng-icons/core';
import { NgbAlertModule, NgbModal } from '@ng-bootstrap/ng-bootstrap';
import { Subject, takeUntil } from 'rxjs';

import { 
  User,
  UpdateUserDto,
  UserRole,
  UserType,
  UserUtils,
  ResetPasswordDto
} from '@core/models/dcb-bo-hub-user.model';

import { HubUsersService } from '@modules/hub-users-management/hub-users.service';
import { MerchantUsersService } from '@modules/hub-users-management/merchant-users.service';
import { RoleManagementService } from '@core/services/hub-users-roles-management.service';
import { AuthService } from '@core/services/auth.service';

@Component({
  selector: 'app-my-profile',
  standalone: true,
  imports: [CommonModule, FormsModule, NgIcon, NgbAlertModule],
  templateUrl: './profile.html',
  styles: [`
    .avatar-lg {
      width: 80px;
      height: 80px;
    }
    .fs-24 {
      font-size: 24px;
    }
    .profile-card {
      max-width: 800px;
      margin: 0 auto;
    }
  `]
})
export class MyProfile implements OnInit, OnDestroy {
  private modalService = inject(NgbModal);
  private hubUsersService = inject(HubUsersService);
  private merchantUsersService = inject(MerchantUsersService);
  private roleService = inject(RoleManagementService);
  private authService = inject(AuthService);
  private cdRef = inject(ChangeDetectorRef);
  private destroy$ = new Subject<void>();

  readonly UserRole = UserRole;
  readonly UserUtils = UserUtils;

  @Output() back = new EventEmitter<void>();

    // Référence au modal MyProfile
  @ViewChild('myProfileResetPasswordModal') myProfileResetPasswordModal!: TemplateRef<any>;
  
  // États pour MyProfile
  myProfileCurrentPassword: string = '';
  myProfileNewPassword: string = '';
  temporaryPassword = false;
  myProfileConfirmPassword: string = '';
  resettingMyPassword = false;
  myProfileResetSuccess: string = '';
  myProfileResetError: string = '';
  
  // États pour afficher/masquer les mots de passe
  showCurrentPassword = false;
  showNewMyPassword = false;
  showConfirmMyPassword = false;

  // Utilisateur connecté

  user: User | undefined;
  loading = false;
  saving = false;
  error = '';
  success = '';

  // Édition
  isEditing = false;
  editedUser: UpdateUserDto = {};

  // Gestion des rôles (lecture seule)
  availableRoles: { value: UserRole; label: string; description: string }[] = [];

  ngOnInit() {
    this.loadUserProfile();
    this.loadAvailableRoles();
  }

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

  /**
   * Charge les rôles disponibles (lecture seule pour profil personnel)
   */
  private loadAvailableRoles(): void {
    this.isHubUser() 
      ? this.hubUsersService.getAvailableHubRoles()
      : this.merchantUsersService.getAvailableMerchantRoles()
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: (response) => {
          this.availableRoles = response.roles.map(role => ({
            value: role.value,
            label: role.label,
            description: role.description
          }));
        },
        error: (error) => {
          console.error('Error loading available roles:', error);
          // Fallback avec les rôles principaux
          this.availableRoles = [];
        }
      });
  }

  loadUserProfile() {
    this.loading = true;
    this.error = '';

    this.authService.getProfile()
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: (profile) => {
          this.user = profile || undefined;
          console.log("Profile User : " + this.user?.role);
          this.loading = false;
          this.cdRef.detectChanges();
        },
        error: (error) => {
          this.error = 'Erreur lors du chargement de votre profil';
          this.loading = false;
          this.cdRef.detectChanges();
          console.error('Error loading user profile:', error);
        }
      });
  }

  startEditing() {
    this.isEditing = true;
    this.editedUser = {
      firstName: this.user?.firstName,
      lastName: this.user?.lastName,
      email: this.user?.email
    };
    this.clearMessages();
  }

  cancelEditing() {
    this.isEditing = false;
    this.editedUser = {};
    this.clearMessages();
  }

  saveProfile() {
    if (!this.user) return;

    if (!this.isFormValid()) {
      this.error = 'Veuillez remplir tous les champs obligatoires correctement';
      return;
    }

    this.saving = true;
    this.clearMessages();

    const updateObservable = this.isHubUser() 
      ? this.hubUsersService.updateHubUser(this.user.id, this.editedUser)
      : this.merchantUsersService.updateMerchantUser(this.user.id, this.editedUser);

    updateObservable
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: (updatedUser) => {
          this.user = updatedUser;
          this.isEditing = false;
          this.saving = false;
          this.success = 'Profil mis à jour avec succès';
          this.editedUser = {};
          this.cdRef.detectChanges();
        },
        error: (error) => {
          this.error = this.getErrorMessage(error);
          this.saving = false;
          this.cdRef.detectChanges();
        }
      });
  }

  // ==================== VALIDATION ====================

  isFormValid(): boolean {
    if (!this.editedUser.firstName?.trim() || !this.editedUser.lastName?.trim()) {
      return false;
    }
    if (!this.editedUser.email?.trim() || !this.isValidEmail(this.editedUser.email)) {
      return false;
    }
    return true;
  }

  isValidEmail(email: string): boolean {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(email);
  }

  // ==================== UTILITAIRES D'AFFICHAGE ====================

  getStatusBadgeClass(): string {
    if (!this.user) return 'badge bg-secondary';
    if (!this.user.enabled) return 'badge bg-danger';
    if (!this.user.emailVerified) return 'badge bg-warning';
    return 'badge bg-success';
  }

  getStatusText(): string {
    if (!this.user) return 'Inconnu';
    if (!this.user.enabled) return 'Désactivé';
    if (!this.user.emailVerified) return 'Email non vérifié';
    return 'Actif';
  }

  formatTimestamp(timestamp: number): string {
    if (!timestamp) return 'Non disponible';
    return new Date(timestamp).toLocaleDateString('fr-FR', {
      year: 'numeric',
      month: 'long',
      day: 'numeric',
      hour: '2-digit',
      minute: '2-digit'
    });
  }

  getUserInitials(): string {
    if (!this.user) return 'U';
    return (this.user.firstName?.charAt(0) || '') + (this.user.lastName?.charAt(0) || '') || 'U';
  }

  getUserDisplayName(): string {
    if (!this.user) return 'Utilisateur';
    if (this.user.firstName && this.user.lastName) {
      return `${this.user.firstName} ${this.user.lastName}`;
    }
    return this.user.username;
  }

  getRoleBadgeClass(): string {
    if (!this.user?.role) return 'badge bg-secondary';
    return this.roleService.getRoleBadgeClass(this.user.role);
  }

  getRoleLabel(): string {
    if (!this.user?.role) return 'Aucun rôle';
    return this.roleService.getRoleLabel(this.user.role);
  }

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

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

  // Obtenir le rôle (peut être string ou UserRole)
  getUserRole(): string | UserRole | undefined {
    return this.user?.role;
  }

  // Pour le template, retourner un tableau pour la boucle
  getUserRoles(): (string | UserRole)[] {
    const role = this.user?.role;
    if (!role) return [];
    return Array.isArray(role) ? role : [role];
  }

  // Afficher le rôle
  getUserRoleDisplay(): string {
    if (!this.user?.role) return 'Aucun rôle';
    return this.getRoleLabel();
  }

  // ==================== 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 informations saisies.';
    }
    if (error.status === 403) {
      return 'Vous n\'avez pas les permissions nécessaires pour cette action';
    }
    if (error.status === 404) {
      return 'Utilisateur non trouvé';
    }
    if (error.status === 409) {
      return 'Cet email est déjà utilisé par un autre utilisateur';
    }
    return 'Une erreur est survenue. Veuillez réessayer.';
  }

  // ==================== MÉTHODES DE NAVIGATION ====================

  goBack() {
    this.back.emit();
  }

  // ==================== MÉTHODES UTILITAIRES ====================

  isHubUser(): boolean {
    return UserUtils.isHubUser(this.user!);
  }

  isMerchantUser(): boolean {
    return UserUtils.isMerchantPartnerUser(this.user!);
  }

  getUserTypeDisplay(): string {
    if (!this.user) return '';
    return UserUtils.getUserTypeDisplayName(this.user.userType);
  }

  getCreationDate(): string {
    if (!this.user?.createdTimestamp) return 'Non disponible';
    return this.formatTimestamp(this.user.createdTimestamp);
  }

  getMerchantPartnerId(): string {
    return this.user?.merchantPartnerId || 'Non applicable';
  }

  refresh() {
    this.loadUserProfile();
  }

  clearMessages() {
    this.error = '';
    this.success = '';
    this.cdRef.detectChanges();
  }

  // ==================== GETTERS POUR LE TEMPLATE ====================

  getProfileTitle(): string {
    return 'Mon Profil';
  }

  getWelcomeMessage(): string {
    if (!this.user) return 'Bienvenue';
    return `Bonjour, ${this.getUserDisplayName()}`;
  }

  canEditProfile(): boolean {
    return true; // Toujours vrai pour son propre profil
  }

  // ==================== MÉTHODES D'ACTION ====================

  openModal(content: TemplateRef<any>, size: 'sm' | 'lg' | 'xl' = 'lg') {
    this.modalService.open(content, { 
      size: size,
      centered: true,
      scrollable: true 
    });
  }

  /**
   * Ouvre la modal de réinitialisation personnelle
   */
  openMyProfileResetModal(): void {
    this.resetMyProfileForm();
    this.openModal(this.myProfileResetPasswordModal);
  }

  /**
   * Ferme la modal de réinitialisation personnelle
   */
  closeMyProfileResetModal(): void {
    this.modalService.dismissAll();
    this.resetMyProfileForm();
  }

  /**
   * Réinitialise le formulaire MyProfile
   */
  resetMyProfileForm(): void {
    this.myProfileCurrentPassword = '';
    this.myProfileNewPassword = '';
    this.myProfileConfirmPassword = '';
    this.myProfileResetSuccess = '';
    this.myProfileResetError = '';
    this.resettingMyPassword = false;
    this.showCurrentPassword = false;
    this.showNewMyPassword = false;
    this.showConfirmMyPassword = false;
  }

  /**
   * Vérifie si le formulaire MyProfile est valide
   */
  isMyProfileResetFormValid(): boolean {
    const hasCurrentPassword = !!this.myProfileCurrentPassword;
    const hasNewPassword = !!this.myProfileNewPassword && this.myProfileNewPassword.length >= 8;
    const passwordsMatch = this.myProfileNewPassword === this.myProfileConfirmPassword;
    const isStrongPassword = this.isStrongPassword();

    return hasCurrentPassword && hasNewPassword && passwordsMatch && isStrongPassword;
  }

  /**
   * Vérifie la longueur minimale
   */
  hasMinLength(): boolean {
    return (this.myProfileNewPassword?.length || 0) >= 8;
  }

  /**
   * Vérifie la présence d'une lettre minuscule
   */
  hasLowerCase(): boolean {
    return /[a-z]/.test(this.myProfileNewPassword || '');
  }

  /**
   * Vérifie la présence d'une lettre majuscule
   */
  hasUpperCase(): boolean {
    return /[A-Z]/.test(this.myProfileNewPassword || '');
  }

  /**
   * Vérifie la présence d'un chiffre
   */
  hasNumber(): boolean {
    return /\d/.test(this.myProfileNewPassword || '');
  }

  /**
   * Vérifie la présence d'un caractère spécial
   */
  hasSpecialChar(): boolean {
    return /[@$!%*?&]/.test(this.myProfileNewPassword || '');
  }

  /**
   * Vérifie si tous les critères sont remplis
   */
  isStrongPassword(): boolean {
    return this.hasMinLength() && 
           this.hasLowerCase() && 
           this.hasUpperCase() && 
           this.hasNumber() && 
           this.hasSpecialChar();
  }

  /**
   * Calcule la force du mot de passe (0-100)
   */
  getPasswordStrength(password: string): number {
    if (!password) return 0;
    
    let strength = 0;
    
    // Longueur
    if (password.length >= 8) strength += 25;
    if (password.length >= 12) strength += 10;
    
    // Complexité
    if (/[a-z]/.test(password)) strength += 15;
    if (/[A-Z]/.test(password)) strength += 15;
    if (/[0-9]/.test(password)) strength += 15;
    if (/[@$!%*?&]/.test(password)) strength += 20;
    
    return Math.min(strength, 100);
  }

  /**
   * Classe CSS pour la force du mot de passe
   */
  getPasswordStrengthClass(password: string): string {
    const strength = this.getPasswordStrength(password);
    
    if (strength < 40) return 'bg-danger';
    if (strength < 70) return 'bg-warning';
    return 'bg-success';
  }

  /**
   * Texte pour la force du mot de passe
   */
  getPasswordStrengthText(password: string): string {
    const strength = this.getPasswordStrength(password);
    
    if (strength < 40) return 'Faible';
    if (strength < 70) return 'Moyen';
    return 'Fort';
  }

  /**
   * Récupère les initiales de l'utilisateur connecté
   */
  getMyInitials(): string {
    if (!this.user) return '?';
    
    const first = this.user.firstName?.[0] || '';
    const last = this.user.lastName?.[0] || '';
    
    return (first + last).toUpperCase() || this.user.username?.[0]?.toUpperCase() || 'U';
  }

  /**
   * Confirme la réinitialisation du mot de passe personnel
   */
  confirmMyProfileResetPassword(): void {
    if (!this.isMyProfileResetFormValid()) {
      this.myProfileResetError = 'Veuillez corriger les erreurs dans le formulaire';
      return;
    }

    this.resettingMyPassword = true;
    this.myProfileResetError = '';

    console.log('🔐 Réinitialisation du mot de passe personnel...');

    const resetPasswordDto: ResetPasswordDto = {
      newPassword: this.myProfileNewPassword,
      temporary: this.temporaryPassword
    };

    if(this.user) {

      // Appel au service de réinitialisation
      this.isHubUser() 
        ? this.hubUsersService.resetHubUserPassword(
          this.user.id,
          resetPasswordDto
        )
        : this.merchantUsersService.resetMerchantUserPassword(
          this.user.id,
          resetPasswordDto
      ).subscribe({
        next: (response) => {
          this.resettingMyPassword = false;
          this.myProfileResetSuccess = 'Votre mot de passe a été changé avec succès. Vous serez déconnecté dans quelques secondes...';
          
          console.log('✅ Mot de passe personnel changé avec succès');
          
          // Déconnexion automatique après 3 secondes
          setTimeout(() => {
            this.authService.logout();
          }, 3000);
        },
        error: (error) => {
          this.resettingMyPassword = false;
          
          if (error.status === 401) {
            this.myProfileResetError = 'Mot de passe actuel incorrect';
          } else if (error.status === 400) {
            this.myProfileResetError = 'Le nouveau mot de passe ne respecte pas les politiques de sécurité';
          } else {
            this.myProfileResetError = 'Erreur lors du changement de mot de passe. Veuillez réessayer.';
          }
          
          console.error('❌ Erreur réinitialisation mot de passe personnel:', error);
        }
      });
    }
  }


  // Actions désactivées pour le profil personnel
  updateUserRole(newRole: UserRole) {
    this.error = 'Vous ne pouvez pas modifier votre propre rôle';
    this.cdRef.detectChanges();
  }

  enableUser() {
    this.error = 'Vous ne pouvez pas vous activer/désactiver vous-même';
    this.cdRef.detectChanges();
  }

  disableUser() {
    this.error = 'Vous ne pouvez pas vous activer/désactiver vous-même';
    this.cdRef.detectChanges();
  }

  // ==================== VÉRIFICATIONS DE PERMISSIONS ====================

  canManageRoles(): boolean {
    return false; // Jamais vrai pour le profil personnel
  }

  canEnableDisableUser(): boolean {
    return false; // Jamais vrai pour le profil personnel
  }

  canDeleteUser(): boolean {
    return false; // Jamais vrai pour le profil personnel
  }

  isCurrentUserProfile(): boolean {
    return true; // Toujours vrai pour MyProfile
  }
}