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 { MerchantUsersList } from './list/list';
import { MerchantUserProfile } from './profile/profile';
import { 
  MerchantUsersService, 
  CreateMerchantUserDto, 
  MerchantUserResponse,
  UserRole,
  AvailableRolesResponse,
} from './services/merchant-partners.service';
import { AuthService } from '@core/services/auth.service';

@Component({
  selector: 'app-merchant-partners',
  standalone: true,
  imports: [
    CommonModule,
    FormsModule,
    NgIcon,
    NgbNavModule,
    NgbModalModule,
    PageTitle,
    MerchantUsersList,
    MerchantUserProfile
  ],
  templateUrl: './merchant-partners.html',
})
export class MerchantPartners implements OnInit, OnDestroy {
  private modalService = inject(NgbModal);
  private authService = inject(AuthService); 
  private merchantUsersService = inject(MerchantUsersService);
  private cdRef = inject(ChangeDetectorRef);
  private destroy$ = new Subject<void>();

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

  // Données pour la création d'utilisateur marchand
  newMerchantUser: CreateMerchantUserDto = {
    username: '',
    email: '',
    firstName: '',
    lastName: '',
    password: '',
    role: UserRole.DCB_PARTNER_SUPPORT,
    merchantPartnerId: '',
    enabled: true,
    emailVerified: false
  };

  availableRoles: AvailableRolesResponse | null = null;
  creatingUser = false;
  createUserError = '';

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

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

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

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

  private loadCurrentMerchantPartnerId() {
    this.authService.getProfile().subscribe({
      next: (user) => {
        this.currentMerchantPartnerId = user.merchantPartnerId || '';
        this.newMerchantUser.merchantPartnerId = this.currentMerchantPartnerId;
      },
      error: (error) => {
        console.error('Error loading current merchant partner ID:', error);
      }
    });
  }

  private loadAvailableRoles() {
    this.merchantUsersService.getAvailableMerchantRoles()
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: (roles) => {
          this.availableRoles = roles;
          // Sélectionner le premier rôle disponible par défaut
          const firstAllowedRole = roles.roles.find(role => role.allowedForCreation);
          if (firstAllowedRole) {
            this.newMerchantUser.role = firstAllowedRole.value as any;
          }
        },
        error: (error) => {
          console.error('Error loading available roles:', error);
        }
      });
  }

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

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

  // Méthodes de gestion des événements du composant enfant
  onUserSelected(userId: string) {
    this.showTab('profile', userId);
  }

  onResetPasswordRequested(userId: string) {
    this.openResetPasswordModal(userId);
  }

  onDeleteUserRequested(userId: string) {
    this.openDeleteUserModal(userId);
  }

  // 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() {
    this.resetUserForm();
    this.createUserError = '';
    this.openModal(this.createUserModal);
  }

  // Réinitialiser le formulaire de création
  private resetUserForm() {
    this.newMerchantUser = {
      username: '',
      email: '',
      firstName: '',
      lastName: '',
      password: '',
      role: UserRole.DCB_PARTNER_SUPPORT,
      merchantPartnerId: this.currentMerchantPartnerId,
      enabled: true,
      emailVerified: false
    };
  }

  // Méthode pour ouvrir le modal de réinitialisation de mot de passe
  openResetPasswordModal(userId: string) {
    this.merchantUsersService.getMerchantUserById(userId)
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: (user) => {
          this.selectedUserForReset = user;
          this.newPassword = '';
          this.temporaryPassword = true;
          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';
        }
      });
  }

  // Méthode pour ouvrir le modal de suppression
  openDeleteUserModal(userId: string) {
    this.merchantUsersService.getMerchantUserById(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';
        }
      });
  }

  // Créer un utilisateur marchand
  createMerchantUser() {
    const validation = this.validateUserForm();
    if (!validation.isValid) {
      this.createUserError = validation.error!;
      return;
    }

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

    // S'assurer que le merchantPartnerId est défini
    this.newMerchantUser.merchantPartnerId = this.currentMerchantPartnerId;

    this.merchantUsersService.createMerchantUser(this.newMerchantUser)
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: (createdUser) => {
          this.creatingUser = false;
          this.modalService.dismissAll();
          this.refreshUsersList();
          this.showSuccessMessage(`Utilisateur "${createdUser.username}" créé avec succès`);
        },
        error: (error) => {
          this.creatingUser = false;
          this.createUserError = this.getErrorMessage(error);
        }
      });
  }

  // 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.merchantUsersService.resetMerchantUserPassword(
      this.selectedUserForReset.id, 
      { 
        newPassword: this.newPassword,
        temporary: this.temporaryPassword
      }
    ).pipe(takeUntil(this.destroy$))
    .subscribe({
      next: (response) => {
        this.resettingPassword = false;
        this.resetPasswordSuccess = 'Mot de passe réinitialisé avec succès !';
        this.cdRef.detectChanges();
        
        // Fermer le modal après 2 secondes
        setTimeout(() => {
          this.modalService.dismissAll();
        }, 2000);
      },
      error: (error) => {
        this.resettingPassword = false;
        this.resetPasswordError = this.getResetPasswordErrorMessage(error);
        this.cdRef.detectChanges();
      }
    });
  }

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

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

    this.merchantUsersService.deleteMerchantUser(this.selectedUserForDelete.id)
      .pipe(takeUntil(this.destroy$))
      .subscribe({
        next: () => {
          this.deletingUser = false;
          this.modalService.dismissAll();
          this.refreshUsersList();
          this.showSuccessMessage(`Utilisateur "${this.selectedUserForDelete?.username}" supprimé avec succès`);
          this.cdRef.detectChanges();
        },
        error: (error) => {
          this.deletingUser = false;
          this.deleteUserError = this.getDeleteErrorMessage(error);
          this.cdRef.detectChanges();
        }
      });
  }

  @ViewChild(MerchantUsersList) usersListComponent!: MerchantUsersList;

  private refreshUsersList(): void {
    if (this.usersListComponent && typeof this.usersListComponent.loadUsers === 'function') {
      this.usersListComponent.loadUsers();
    } else {
      console.warn('MerchantUsersList component not available for refresh');
      this.showTab('list');
    }
  }

  // ==================== 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 d\'utilisateur ou email existe déjà.';
    }
    if (error.status === 403) {
      return 'Vous n\'avez pas les permissions pour créer cet utilisateur.';
    }
    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.';
    }
    if (error.status === 409) {
      return 'Impossible de supprimer cet utilisateur car il est associé à des données.';
    }
    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.newMerchantUser.username?.trim(), name: 'Nom d\'utilisateur' },
      { field: this.newMerchantUser.email?.trim(), name: 'Email' },
      { field: this.newMerchantUser.firstName?.trim(), name: 'Prénom' },
      { field: this.newMerchantUser.lastName?.trim(), name: 'Nom' }
    ];

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

    // Validation email
    const email = this.newMerchantUser.email?.trim();
    if (!email) {
      return { isValid: false, error: 'Email est requis' };
    }

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

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

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

    if (!this.newMerchantUser.merchantPartnerId) {
      return { isValid: false, error: 'Merchant Partner ID est requis' };
    }

    return { isValid: true };
  }

  // ==================== MESSAGES DE SUCCÈS ====================

  private showSuccessMessage(message: string) {
    // Vous pouvez implémenter un service de notification ici
    console.log('Success:', message);
    // Exemple avec un toast:
    // this.notificationService.success(message);
  }

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

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

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

  isRoleAllowedForCreation(role: UserRole): boolean {
    if (!this.availableRoles) return false;
    
    const roleInfo = this.availableRoles.roles.find(r => r.value === role);
    return roleInfo?.allowedForCreation || false;
  }

  // Méthodes utilitaires pour le template
  getUserInitials(user: MerchantUserResponse): string {
    return (user.firstName?.charAt(0) || '') + (user.lastName?.charAt(0) || '') || 'U';
  }

  getUserType(user: MerchantUserResponse): string {
    switch (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';
    }
  }

  getRoleBadgeClass(role: UserRole): string {
    switch (role) {
      case UserRole.DCB_PARTNER_ADMIN:
        return 'bg-danger text-white';
      case UserRole.DCB_PARTNER_MANAGER:
        return 'bg-warning text-dark';
      case UserRole.DCB_PARTNER_SUPPORT:
        return 'bg-info text-white';
      default:
        return 'bg-secondary text-white';
    }
  }

  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';
    }
  }

  // ==================== RÉFÉRENCES AUX TEMPLATES ====================

  @ViewChild('createUserModal') createUserModal!: TemplateRef<any>;
  @ViewChild('resetPasswordModal') resetPasswordModal!: TemplateRef<any>;
  @ViewChild('deleteUserModal') deleteUserModal!: TemplateRef<any>;
}