import {
  Component,
  OnInit,
  OnDestroy,
  ChangeDetectorRef
} from '@angular/core';
import { CommonModule } from '@angular/common';
import { Router, ActivatedRoute } from '@angular/router';
import { Subscription } from 'rxjs';
import { AuthService } from '../../services/auth';
import { PacienteService } from '../../services/paciente';
import { AppHeaderComponent } from '../shared/app-header/app-header';
import { JobsService } from '../../services/jobs';

@Component({
  selector: 'app-dashboard',
  standalone: true,
  imports: [CommonModule, AppHeaderComponent],
  templateUrl: './dashboard.html',
  styleUrls: ['./dashboard.css']
})
export class DashboardComponent implements OnInit, OnDestroy {
  currentUser: any = null;
  errorMessage: string | null = null;
  private subscriptions: Subscription[] = [];

  // ---- Carga de Excel ----
  cargandoExcel = false;
  estadoCargaExcel: string | null = null;

  constructor(
    private authService: AuthService,
    private router: Router,
    private route: ActivatedRoute,
    private pacienteService: PacienteService,
    private jobsService: JobsService,
    private cdr: ChangeDetectorRef
  ) {}

  ngOnInit(): void {
    // Suscribirse al usuario actual
    this.subscriptions.push(
      this.authService.currentUser$.subscribe(user => {
        this.currentUser = user;
      })
    );

    // Verificar si hay mensajes de error en los query params
    this.subscriptions.push(
      this.route.queryParamMap.subscribe(params => {
        const error = params.get('error');
        if (error) {
          this.handleErrorMessage(error);
        }
      })
    );

    // Si no hay usuario autenticado, redirigir al login
    if (!this.authService.isLoggedIn()) {
      this.router.navigate(['/login']);
    }
  }

  ngOnDestroy(): void {
    // Limpiar suscripciones
    this.subscriptions.forEach(sub => sub.unsubscribe());
  }

  private handleErrorMessage(error: string): void {
    switch (error) {
      case 'no_admin':
        this.errorMessage =
          'No tienes permisos de administrador para acceder a esa página.';
        break;
      case 'no_permission':
        this.errorMessage =
          'No tienes los permisos necesarios para realizar esa acción.';
        break;
      default:
        this.errorMessage =
          'Ha ocurrido un error. Por favor, intenta nuevamente.';
    }

    // Limpiar el mensaje después de 5 segundos
    setTimeout(() => {
      this.errorMessage = null;
    }, 5000);
  }

  // =========================
  // Navegación
  // =========================
  irABusquedaPacientes(): void {
    this.router.navigate(['/autorizaciones']);
  }

  irAVerAutorizacionesPorFecha(): void {
    this.router.navigate(['/autorizaciones-por-fecha']);
  }

  irACargarCups(): void {
    this.router.navigate(['/cargar-cups']);
  }

  irAUsuarios(): void {
    this.router.navigate(['/usuarios']);
  }

  // ahora simplemente comprobamos si es admin
  puedeGestionarUsuarios(): boolean {
    return this.authService.isAdministrador();
  }

  // =========================
  // Logout y helpers de usuario
  // =========================
  logout(): void {
    this.authService.logout();
  }

  getNombreUsuario(): string {
    return this.currentUser?.nombre_completo || 'Usuario';
  }

  getRolUsuario(): string {
    return this.currentUser?.nombre_rol || 'Sin rol';
  }

  getNombreRolFormateado(): string {
    const rol = this.getRolUsuario();
    switch (rol) {
      case 'administrador':
        return 'Administrador';
      case 'administrativo_sede':
        return 'Administrativo de Sede';
      default:
        return rol;
    }
  }

  // =========================
  // Permisos
  // =========================
  puedeCargarPacientes(): boolean {
    return this.authService.puedeCargarPacientes();
  }

  puedeCargarCups(): boolean {
    return this.authService.isAdministrador();
  }

  puedeDescargarPdfs(): boolean {
    return this.authService.puedeDescargarPdfs();
  }

  puedeVerTodasAutorizaciones(): boolean {
    return this.authService.puedeVerTodasAutorizaciones();
  }

  puedeGenerarAutorizaciones(): boolean {
    return this.authService.puedeGenerarAutorizaciones();
  }

  getSedesUsuario(): any[] {
    return this.currentUser?.sedes || [];
  }

  cerrarMensajeError(): void {
    this.errorMessage = null;
  }

  getFechaActual(): string {
    const hoy = new Date();
    return hoy.toLocaleDateString('es-CO', {
      weekday: 'long',
      year: 'numeric',
      month: 'long',
      day: 'numeric'
    });
  }

  // =========================
  // Cargar pacientes (Excel)
  // =========================
  abrirCargadorPacientes(input: HTMLInputElement): void {
    if (!this.puedeCargarPacientes() || this.cargandoExcel) {
      return;
    }
    this.estadoCargaExcel = null;
    input.click();
  }

  onExcelSelected(event: Event): void {
    const input = event.target as HTMLInputElement;
    const file = input.files?.[0];

    if (!file) {
      return;
    }

    this.cargandoExcel = true;
    this.estadoCargaExcel = 'Subiendo archivo...';

    const formData = new FormData();
    formData.append('archivo', file); // mismo nombre que en server.js

    this.pacienteService.cargarExcelPacientes(formData).subscribe({
      next: (job) => {
        this.estadoCargaExcel = 'Archivo en cola. Procesando...';
        if (input) {
          input.value = '';
        }

        this.jobsService.pollJob(job.id).subscribe({
          next: (estado) => {
            if (estado.status === 'completed') {
              const partes: string[] = [];
              if (estado.result?.mensaje) {
                partes.push(estado.result.mensaje);
              }
              if (typeof estado.result?.activos === 'number') {
                partes.push(`Pacientes activos: ${estado.result.activos}`);
              }
              if (typeof estado.result?.antiguos === 'number') {
                partes.push(`Pacientes antiguos: ${estado.result.antiguos}`);
              }
              this.estadoCargaExcel =
                partes.join(' ? ') || 'Archivo procesado correctamente.';
              this.cargandoExcel = false;
            }

            if (estado.status === 'failed') {
              this.estadoCargaExcel =
                estado.error?.message ||
                'Error procesando el Excel de pacientes.';
              this.cargandoExcel = false;
            }
            this.cdr.detectChanges();
          },
          error: (error) => {
            console.error(error);
            this.estadoCargaExcel =
              'Error consultando el estado del procesamiento.';
            this.cargandoExcel = false;
            this.cdr.detectChanges();
          }
        });
      },
      error: (err) => {
        console.error(err);
        this.estadoCargaExcel =
          err?.error?.error || 'Error subiendo el Excel de pacientes.';
        this.cargandoExcel = false;
        if (input) {
          input.value = '';
        }
      }
    });
  }
}
