// src/app/modules/merchant-users/profile/profile.ts
import { Component, inject, OnInit, Input, Output, EventEmitter, ChangeDetectorRef, OnDestroy } from '@angular/core';
import { CommonModule } from '@angular/common';
import { FormsModule } from '@angular/forms';
import { NgIcon } from '@ng-icons/core';
import { NgbAlertModule } from '@ng-bootstrap/ng-bootstrap';
import { Subject, takeUntil } from 'rxjs';
import { 
  MerchantUsersService, 
  MerchantUserResponse, 
  UserRole,
  UpdateMerchantUserDto
} from '../services/merchant-partners.service';
import { AuthService } from '@core/services/auth.service';

@Component({
  selector: 'app-merchant-user-profile',
  standalone: true,
  imports: [CommonModule, FormsModule, NgIcon, NgbAlertModule],
  templateUrl: './profile.html',
  styles: [`
    .avatar-lg {
      width: 80px;
      height: 80px;
    }
    .fs-24 {
      font-size: 24px;
    }
  `]
})
export class MerchantUserProfile implements OnInit, OnDestroy {
  private merchantUsersService = inject(MerchantUsersService);
  private authService = inject(AuthService);
  private cdRef = inject(ChangeDetectorRef);
  private destroy$ = new Subject<void>();

  @Input() userId!: string;
  @Output() back = new EventEmitter<void>();
  @Output() openResetPasswordModal = new EventEmitter<string>();

  user: MerchantUserResponse | null = null;
  loading = false;
  saving = false;
  error = '';
  success = '';

  // Édition
  isEditing = false;
  editedUser: UpdateMerchantUserDto = {};
  
  // Gestion des rôles
  availableRoles: UserRole[] = [
    UserRole.DCB_PARTNER_ADMIN,
    UserRole.DCB_PARTNER_MANAGER, 
    UserRole.DCB_PARTNER_SUPPORT
  ];
  updatingRole = false;

  ngOnInit() {
    if (this.userId) {
      this.loadUserProfile();
    }
  }

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

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

    this.merchantUsersService.getMerchantUserById(this.userId)
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: (user) => {
          this.user = user;
          this.loading = false;
          this.cdRef.detectChanges(); 
        },
        error: (error) => {
          this.error = 'Erreur lors du chargement du profil utilisateur';
          this.loading = false;
          this.cdRef.detectChanges(); 
          console.error('Error loading merchant user profile:', error);
        }
      });
  }

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

  cancelEditing() {
    this.isEditing = false;
    this.editedUser = {};
    this.error = '';
    this.success = '';
    this.cdRef.detectChanges(); 
  }

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

    this.saving = true;
    this.error = '';
    this.success = '';

    this.merchantUsersService.updateMerchantUser(this.user.id, this.editedUser)
      .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(); 
          console.error('Error updating merchant user:', error);
        }
      });
  }

  // Gestion des rôles
  updateUserRole(newRole: UserRole) {
    if (!this.user) return;

    this.updatingRole = true;
    this.error = '';
    this.success = '';

    // Pour changer le rôle, on doit recréer l'utilisateur ou utiliser une méthode spécifique
    // Pour l'instant, on utilise la mise à jour standard
    const updateData: UpdateMerchantUserDto = {
      ...this.editedUser
      // Note: Le rôle n'est pas modifiable via update dans l'API actuelle
      // Vous devrez peut-être implémenter une méthode spécifique dans le service
    };

    this.merchantUsersService.updateMerchantUser(this.user.id, updateData)
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: (updatedUser) => {
          this.user = updatedUser;
          this.updatingRole = false;
          this.success = 'Profil mis à jour avec succès';
          this.cdRef.detectChanges(); 
        },
        error: (error) => {
          this.updatingRole = false;
          this.error = this.getErrorMessage(error);
          this.cdRef.detectChanges(); 
        }
      });
  }

  // Gestion du statut
  enableUser() {
    if (!this.user) return;

    this.error = '';
    this.success = '';

    this.merchantUsersService.enableMerchantUser(this.user.id)
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: (updatedUser) => {
          this.user = updatedUser;
          this.success = 'Utilisateur activé avec succès';
          this.cdRef.detectChanges(); 
        },
        error: (error) => {
          this.error = this.getErrorMessage(error);
          this.cdRef.detectChanges(); 
          console.error('Error enabling merchant user:', error);
        }
      });
  }

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

    this.error = '';
    this.success = '';

    this.merchantUsersService.disableMerchantUser(this.user.id)
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: (updatedUser) => {
          this.user = updatedUser;
          this.success = 'Utilisateur désactivé avec succès';
          this.cdRef.detectChanges(); 
        },
        error: (error) => {
          this.error = this.getErrorMessage(error);
          this.cdRef.detectChanges(); 
          console.error('Error disabling merchant user:', error);
        }
      });
  }

  // Réinitialisation du mot de passe
  resetPassword() {
    if (this.user) {
      this.openResetPasswordModal.emit(this.user.id);
    }
  }

  // ==================== 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(role: UserRole): string {
    switch (role) {
      case UserRole.DCB_PARTNER_ADMIN:
        return 'bg-danger';
      case UserRole.DCB_PARTNER_MANAGER:
        return 'bg-warning text-dark';
      case UserRole.DCB_PARTNER_SUPPORT:
        return 'bg-info text-white';
      default:
        return 'bg-secondary';
    }
  }

  getRoleDisplayName(role: UserRole): string {
    const roleNames = {
      [UserRole.DCB_PARTNER_ADMIN]: 'Administrateur',
      [UserRole.DCB_PARTNER_MANAGER]: 'Manager',
      [UserRole.DCB_PARTNER_SUPPORT]: 'Support'
    };
    return roleNames[role] || role;
  }

  getRoleIcon(role: UserRole): string {
    switch (role) {
      case UserRole.DCB_PARTNER_ADMIN:
        return 'lucideShield';
      case UserRole.DCB_PARTNER_MANAGER:
        return 'lucideUserCog';
      case UserRole.DCB_PARTNER_SUPPORT:
        return 'lucideHeadphones';
      default:
        return 'lucideUser';
    }
  }

  getRoleDescription(role: UserRole): string {
    const descriptions = {
      [UserRole.DCB_PARTNER_ADMIN]: 'Accès administratif complet au sein du partenaire marchand',
      [UserRole.DCB_PARTNER_MANAGER]: 'Accès de gestion avec capacités administratives limitées',
      [UserRole.DCB_PARTNER_SUPPORT]: 'Rôle support avec accès en lecture seule et opérations de base'
    };
    return descriptions[role] || 'Description non disponible';
  }

  getUserType(): string {
    if (!this.user) return 'Utilisateur';
    
    switch (this.user.role) {
      case UserRole.DCB_PARTNER_ADMIN:
        return 'Administrateur';
      case UserRole.DCB_PARTNER_MANAGER:
        return 'Manager';
      case UserRole.DCB_PARTNER_SUPPORT:
        return 'Support';
      default:
        return 'Utilisateur';
    }
  }

  getUserTypeBadgeClass(): string {
    const userType = this.getUserType();
    switch (userType) {
      case 'Administrateur': return 'bg-danger';
      case 'Manager': return 'bg-success';
      case 'Support': return 'bg-info';
      default: return 'bg-secondary';
    }
  }

  // ==================== 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 pour effectuer cette action.';
    }
    if (error.status === 404) {
      return 'Utilisateur non trouvé.';
    }
    if (error.status === 409) {
      return 'Conflit de données. Cet utilisateur existe peut-être déjà.';
    }
    return 'Erreur lors de l\'opération. Veuillez réessayer.';
  }

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

  canEditUser(): boolean {
    // Logique pour déterminer si l'utilisateur connecté peut éditer cet utilisateur
    return true; // Temporaire - à implémenter
  }

  canManageRoles(): boolean {
    // Logique pour déterminer si l'utilisateur connecté peut gérer les rôles
    return true; // Temporaire - à implémenter
  }

  canEnableDisableUser(): boolean {
    // Empêcher la désactivation de soi-même
    return this.user?.id !== 'current-user-id';
  }

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

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

  // ==================== MÉTHODES DE 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;
  }

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

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

  isAdmin(): boolean {
    return this.user?.role === UserRole.DCB_PARTNER_ADMIN;
  }

  isManager(): boolean {
    return this.user?.role === UserRole.DCB_PARTNER_MANAGER;
  }

  isSupport(): boolean {
    return this.user?.role === UserRole.DCB_PARTNER_SUPPORT;
  }

  refresh() {
    this.loadUserProfile();
  }

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

  // Vérifie si c'est le profil de l'utilisateur courant
  isCurrentUserProfile(): boolean {
    // Implémentez cette logique selon votre système d'authentification
    // Exemple: return this.authService.getCurrentUserId() === this.user?.id;
    return false;
  }

  // Méthode pour obtenir la date de création formatée
  getCreationDate(): string {
    if (!this.user?.createdTimestamp) return 'Non disponible';
    return this.formatTimestamp(this.user.createdTimestamp);
  }

  // Méthode pour obtenir la date de dernière connexion formatée
  getLastLoginDate(): string {
    if (!this.user?.lastLogin) return 'Jamais connecté';
    return this.formatTimestamp(this.user.lastLogin);
  }

  // Méthode pour obtenir le nom du créateur
  getCreatorName(): string {
    if (!this.user?.createdByUsername) return 'Non disponible';
    return this.user.createdByUsername;
  }
}