import { MatMomentDateModule } from '@angular/material-moment-adapter';
import { ChangeDetectionStrategy, Component, Inject, OnInit, OnDestroy, ChangeDetectorRef } from '@angular/core';
import { MAT_DIALOG_DATA, MatDialogRef } from '@angular/material/dialog';
import { Organigrama, UserToBlock, Usuario } from '../organization.component';
import { UsersProfilesService } from '../../../../services/users-profiles.service';
import { EncService } from '../../../../services/enc.service';
import { FunctionsService } from '../../../../services/functions.service';
import { MatDatepickerControl, MatDatepickerPanel, MatDatepickerModule } from '@angular/material/datepicker';
import { MatTimepickerModule } from '@angular/material/timepicker';
import { MatInputModule } from '@angular/material/input';
import { MatFormFieldModule } from '@angular/material/form-field';
import { provideNativeDateAdapter } from '@angular/material/core';
import { NgModule } from '@angular/core';
import { NgxMaterialTimepickerModule } from 'ngx-material-timepicker';
import { lastValueFrom } from 'rxjs';

@Component({
  selector: 'block-user',
  templateUrl: './block-user.component.html',
  styleUrl: './block-user.component.css',
  standalone: false,
  changeDetection: ChangeDetectionStrategy.OnPush,
})
export class BlockUserComponent implements OnInit, OnDestroy {
  
  userToBlock: UserToBlock;
  isLoading: boolean = false;
  hasError: boolean = false;
  errorMessage: string = '';
  
  fechaInicio: Date | null = null;
  fechaFin: Date | null = null;
  horaInicio: string = '00:00';
  horaFin: string = '23:59';
  tiempoLimite: string = '5:00'; 
  
  isBlocked: boolean = false;
  blockTimestamp: Date | null = null;
  canUnblock: boolean = false; 
  timeRemaining: number = 0;
  countdownInterval: any;

  pickerstart!: MatDatepickerPanel<MatDatepickerControl<any>, any, any>;
  pickerend!: MatDatepickerPanel<MatDatepickerControl<any>, any, any>;

  constructor(
    @Inject(MAT_DIALOG_DATA) public data: { 
      userToBlock: UserToBlock, 
      currentUserEncryptedId: string 
    },
    private dialogRef: MatDialogRef<BlockUserComponent>,
    private _usersProfilesService: UsersProfilesService,
    private _encrypt: EncService,
    private _functionService: FunctionsService,
    private cdr: ChangeDetectorRef
  ) {
    this.userToBlock = data.userToBlock;
  }

  ngOnInit(): void {

    this.checkUserBlockStatus();
    
    this.fechaInicio = new Date();
    this.fechaFin = new Date();
    this.fechaFin.setDate(this.fechaFin.getDate() + 1);
  }

  private checkUserBlockStatus(): void {
    console.log('Verificando estado de bloqueo del usuario:', this.userToBlock);
    
   
    if (this.userToBlock.userData && this.userToBlock.userData.ESTATUS === 'Inactivo') {
      this.isBlocked = true; 
      

      if (this.userToBlock.userData.FECHA_INICIO_BLOQUEO && 
          this.userToBlock.userData.FECHA_INICIO_BLOQUEO.trim() !== '') {
        console.log('Fecha de inicio de bloqueo encontrada:', this.userToBlock.userData.FECHA_INICIO_BLOQUEO);
        
       
        this.blockTimestamp = new Date(this.userToBlock.userData.FECHA_INICIO_BLOQUEO);
        

        if (isNaN(this.blockTimestamp.getTime())) {
          console.error('Fecha de bloqueo inválida desde BD:', this.userToBlock.userData.FECHA_INICIO_BLOQUEO);
          
          this.blockTimestamp = null;
          this.canUnblock = false;
          this.timeRemaining = 0;
        } else {
          this.calculateTimeRemaining();
        }
      } else {
        console.warn('Usuario bloqueado pero sin fecha de inicio válida en BD');
        
        this.blockTimestamp = null;
        this.canUnblock = false;
        this.timeRemaining = 0;
      }
      
      console.log('Usuario detectado como bloqueado:', {
        estatus: this.userToBlock.userData.ESTATUS,
        fechaBloqueoOriginal: this.userToBlock.userData.FECHA_INICIO_BLOQUEO,
        timestamp: this.blockTimestamp,
        canUnblock: this.canUnblock,
        timeRemaining: this.timeRemaining
      });
    } else {
      this.isBlocked = false;
      this.canUnblock = false;
      console.log('Usuario detectado como activo:', this.userToBlock.userData?.ESTATUS || 'Sin estado');
    }
    

    this.cdr.detectChanges();
  }

  private calculateTimeRemaining(): void {
    if (!this.blockTimestamp) {
      console.log('No hay timestamp de bloqueo');
      return;
    }
    
    const now = new Date().getTime();
    const blockTime = this.blockTimestamp.getTime();
    const timeLimit = 5 * 60 * 1000; 
    const elapsed = now - blockTime;
    
    console.log('Calculando tiempo restante:', {
      now: new Date(now),
      blockTime: new Date(blockTime),
      elapsed: elapsed,
      elapsedMinutes: elapsed / (60 * 1000),
      timeLimit: timeLimit / (60 * 1000)
    });
    
    if (elapsed < timeLimit) {
      this.timeRemaining = Math.ceil((timeLimit - elapsed) / 1000); // Usar ceil para redondear hacia arriba
      this.canUnblock = true;
      console.log(`Dentro del límite de tiempo. Tiempo restante: ${this.timeRemaining} segundos`);
      this.startCountdown();
    } else {
      this.timeRemaining = 0;
      this.canUnblock = false;
      console.log('Tiempo límite excedido, no se puede desbloquear');
    }
    
    this.cdr.detectChanges();
  }

  private startCountdown(): void {
    console.log('Iniciando countdown con tiempo restante:', this.timeRemaining);
    
    if (this.countdownInterval) {
      clearInterval(this.countdownInterval);
    }

    this.countdownInterval = setInterval(() => {
      this.timeRemaining--;
      console.log('Countdown:', this.timeRemaining);
      
      if (this.timeRemaining <= 0) {
        this.canUnblock = false;
        clearInterval(this.countdownInterval);
        console.log('Countdown terminado, desbloqueo no disponible');
      }
      
      this.cdr.detectChanges();
    }, 1000);
  }

  public formatDateTime(fecha: Date, hora: string): string {
    if (!fecha || !hora) return '';
    
    const year = fecha.getFullYear();
    const month = String(fecha.getMonth() + 1).padStart(2, '0');
    const day = String(fecha.getDate()).padStart(2, '0');
    
    return `${year}-${month}-${day} ${hora}:00`;
  }

  private validateDates(): boolean {
    if (!this.fechaInicio || !this.fechaFin) {
      this.hasError = true;
      this.errorMessage = 'Debe seleccionar tanto la fecha de inicio como la fecha de fin';
      return false;
    }

    const fechaInicioCompleta = new Date(`${this.fechaInicio.toDateString()} ${this.horaInicio}`);
    const fechaFinCompleta = new Date(`${this.fechaFin.toDateString()} ${this.horaFin}`);

    if (fechaFinCompleta <= fechaInicioCompleta) {
      this.hasError = true;
      this.errorMessage = 'La fecha y hora de fin debe ser posterior a la fecha y hora de inicio';
      return false;
    }

    this.hasError = false;
    this.errorMessage = '';
    return true;
  }

  async blockUser(): Promise<void> {
    if (!this.validateDates()) {
      return;
    }

    try {
      this.isLoading = true;
      this.hasError = false;
      this.errorMessage = '';

      const formData = new FormData();
      const currentUserEncryptedId = this.data.currentUserEncryptedId; 
      const cryptedUserIdToBlock = this.userToBlock.idUsuarioEncriptado;
      const currentUserIdFromStorage = localStorage.getItem('idusuario')!;

      const fechaInicioBloqueo = this.formatDateTime(this.fechaInicio!, this.horaInicio);

      console.log('Datos del bloqueo:', {
        usuarioQueBloquea: currentUserEncryptedId,
        usuarioABloquear: cryptedUserIdToBlock,
        fechaInicio: fechaInicioBloqueo,
        fechaFin: this.formatDateTime(this.fechaFin!, this.horaFin),
        estadoAnterior: this.userToBlock.userData?.ESTATUS
      });
      
      formData.append('id_user', cryptedUserIdToBlock);
      formData.append('linea', '1');
      formData.append('id', currentUserIdFromStorage);
      formData.append('fecha_inicio_bloqueo', fechaInicioBloqueo);
      formData.append('fecha_fin_bloqueo', this.formatDateTime(this.fechaFin!, this.horaFin));
      formData.append('estatus', 'Inactivo');
      
      const result = await lastValueFrom(this._usersProfilesService.blockUser(formData));

      if (result.error) {
        throw new Error(result.msg || 'Error al bloquear el usuario');
      }

      this.isBlocked = true;
      this.blockTimestamp = new Date(fechaInicioBloqueo); 
      this.calculateTimeRemaining();

      if (this.userToBlock.userData) {
        this.userToBlock.userData.ESTATUS = 'Inactivo';
        this.userToBlock.userData.FECHA_INICIO_BLOQUEO = fechaInicioBloqueo;
        this.userToBlock.userData.FECHA_FIN_BLOQUEO = this.formatDateTime(this.fechaFin!, this.horaFin);
      }

      console.log('Usuario bloqueado exitosamente con timestamp:', this.blockTimestamp);

      this.dialogRef.close({ 
        success: true, 
        message: 'Usuario bloqueado exitosamente',
        action: 'block'
      });

    } catch (error) {
      console.error('Error al bloquear usuario:', error);
      this.hasError = true;
      this.errorMessage = error instanceof Error ? error.message : 'Error al bloquear el usuario. Intente nuevamente.';
    } finally {
      this.isLoading = false;
      this.cdr.detectChanges();
    }
  }

  async unlockUser(): Promise<void> {
    if (!this.canUnblock) {
      console.log('No se puede desbloquear: tiempo expirado o no permitido');
      this.hasError = true;
      this.errorMessage = 'No se puede desbloquear el usuario. El tiempo límite ha expirado.';
      this.cdr.detectChanges();
      return;
    }

    try {
      this.isLoading = true;
      this.hasError = false;
      this.errorMessage = '';

      const formData = new FormData();
      const cryptedUserIdToBlock = this.userToBlock.idUsuarioEncriptado;
      const currentUserIdFromStorage = localStorage.getItem('idusuario')!;

      console.log('Datos del desbloqueo:', {
        usuarioADesbloquear: cryptedUserIdToBlock,
        estadoAnterior: this.userToBlock.userData?.ESTATUS,
        timeRemaining: this.timeRemaining
      });

      formData.append('id_user', cryptedUserIdToBlock);
      formData.append('linea', '1');
      formData.append('id', currentUserIdFromStorage);
      formData.append('fecha_inicio_bloqueo', '');
      formData.append('fecha_fin_bloqueo', '');
      formData.append('estatus', 'Activo');

      const result = await lastValueFrom(this._usersProfilesService.blockUser(formData));

      if (result.error) {
        throw new Error(result.msg || 'Error al desbloquear el usuario');
      }

      // Limpiar el countdown
      if (this.countdownInterval) {
        clearInterval(this.countdownInterval);
      }

      this.isBlocked = false;
      this.blockTimestamp = null;
      this.canUnblock = false;
      this.timeRemaining = 0;

      if (this.userToBlock.userData) {
        this.userToBlock.userData.ESTATUS = 'Activo';
        this.userToBlock.userData.FECHA_INICIO_BLOQUEO = '';
        this.userToBlock.userData.FECHA_FIN_BLOQUEO = '';
      }

      console.log('Usuario desbloqueado exitosamente');

      this.dialogRef.close({ 
        success: true, 
        message: 'Usuario desbloqueado exitosamente',
        action: 'unblock'
      });

    } catch (error) {
      console.error('Error al desbloquear usuario:', error);
      this.hasError = true;
      this.errorMessage = error instanceof Error ? error.message : 'Error al desbloquear el usuario. Intente nuevamente.';
    } finally {
      this.isLoading = false;
      this.cdr.detectChanges();
    }
  }

  onFechaInicioChange(): void {
    if (this.fechaInicio && this.fechaFin && this.fechaInicio > this.fechaFin) {
      this.fechaFin = new Date(this.fechaInicio);
      this.fechaFin.setDate(this.fechaFin.getDate() + 1);
    }
    this.validateDates();
  }

  onFechaFinChange(): void {
    this.validateDates();
  }

  onHoraChange(): void {
    this.validateDates();
  }

  cancelar(): void {
    if (this.countdownInterval) {
      clearInterval(this.countdownInterval);
    }
    this.dialogRef.close();
  }

  get minDate(): Date {
    return new Date();
  }

  get minEndDate(): Date {
    return this.fechaInicio || new Date();
  }

  public getTimeRemainingFormatted(): string {
    const minutes = Math.floor(this.timeRemaining / 60);
    const seconds = this.timeRemaining % 60;
    return `${minutes}:${seconds.toString().padStart(2, '0')}`;
  }

  ngOnDestroy(): void {
    if (this.countdownInterval) {
      clearInterval(this.countdownInterval);
    }
  }
}