import { ChangeDetectorRef, Component, OnInit } from '@angular/core';
import { CommonModule } from '@angular/common';
import { FormsModule } from '@angular/forms';
import {
  AuthService,
  RegisterRequest,
  Rol
} from '../../services/auth';
import {
  Autorizante,
  CrearAutorizantePayload,
  PacienteService
} from '../../services/paciente';
import { Router } from '@angular/router';
import { AppHeaderComponent } from '../shared/app-header/app-header';

@Component({
  selector: 'app-usuarios',
  standalone: true,
  imports: [CommonModule, FormsModule, AppHeaderComponent],
  templateUrl: './usuarios.html',
  styleUrls: ['./usuarios.css'],
})
export class UsuariosComponent implements OnInit {

  usuarios: any[] = [];
  roles: Rol[] = [];
  autorizantes: Autorizante[] = [];

  cargandoUsuarios = false;
  errorUsuarios: string | null = null;
  limiteUsuarios = 200;
  avisoUsuarios = false;

  cargandoAutorizantes = false;
  errorAutorizantes: string | null = null;

  creando = false;
  mensajeOk: string | null = null;
  mensajeError: string | null = null;

  creandoAutorizante = false;
  mensajeAutorizanteOk: string | null = null;
  mensajeAutorizanteError: string | null = null;

  // para administrativos, códigos separados por coma
  sedesTexto = '';

  nuevoUsuario: RegisterRequest = {
    username: '',
    email: '',
    password: '',
    nombre_completo: '',
    id_rol: 2,   // por defecto administrativo_sede
    sedes: []
  };

  nuevoAutorizante = {
    numero_documento: '',
    tipo_documento: 'CC',
    nombre: '',
    telefono: '',
    cargo: '',
    activo: true
  };

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

  ngOnInit(): void {
    // si no es admin, lo saco
    if (!this.authService.isAdministrador()) {
      this.router.navigate(['/dashboard']);
      return;
    }

    this.cargarRoles();
    this.cargarUsuarios();
    this.cargarAutorizantesAdmin();
  }

  // ========= HEADER =============

  getNombreUsuario(): string {
    const user = this.authService.getCurrentUser();
    return user?.nombre_completo || 'Usuario';
  }

  getNombreRolFormateado(): string {
    const user = this.authService.getCurrentUser();
    const rol = user?.nombre_rol || '';

    switch (rol) {
      case 'administrador':
        return 'Administrador';
      case 'administrativo_sede':
        return 'Administrativo de Sede';
      default:
        return rol || 'Sin rol';
    }
  }

  logout(): void {
    this.authService.logout();
  }

  volverDashboard(): void {
    this.router.navigate(['/dashboard']);
  }

  // ========= CARGA DE ROLES / USUARIOS =============

  cargarRoles(): void {
    this.authService.getRoles().subscribe({
      next: (roles) => {
        this.roles = roles;
        this.cdr.detectChanges();
      },
      error: (err) => {
        console.error(err);
        this.cdr.detectChanges();
      }
    });
  }

  cargarUsuarios(): void {
    this.cargandoUsuarios = true;
    this.errorUsuarios = null;

    this.authService.getUsuarios(this.limiteUsuarios, 0).subscribe({
      next: (usuarios) => {
        this.usuarios = usuarios;
        this.avisoUsuarios = usuarios.length >= this.limiteUsuarios;
        this.cargandoUsuarios = false;
        this.cdr.detectChanges();
      },
      error: (err) => {
        console.error(err);
        this.errorUsuarios = 'Error cargando usuarios.';
        this.cargandoUsuarios = false;
        this.cdr.detectChanges();
      }
    });
  }

  // ========= CREAR USUARIO =============

  crearUsuario(): void {
    this.mensajeOk = null;
    this.mensajeError = null;

    if (!this.nuevoUsuario.username ||
        !this.nuevoUsuario.email ||
        !this.nuevoUsuario.password ||
        !this.nuevoUsuario.nombre_completo) {
      this.mensajeError = 'Completa todos los campos obligatorios.';
      return;
    }

    // Si es administrativo de sede (id_rol = 2) procesamos las sedes
    if (this.nuevoUsuario.id_rol === 2) {
      const codigos = this.sedesTexto
        .split(',')
        .map(s => s.trim())
        .filter(s => s.length > 0);

      this.nuevoUsuario.sedes = codigos;
    } else {
      this.nuevoUsuario.sedes = [];
    }

    this.creando = true;

    this.authService.register(this.nuevoUsuario).subscribe({
      next: (resp: any) => {
        this.mensajeOk = resp?.mensaje || 'Usuario creado correctamente.';
        this.creando = false;

        // Limpiar formulario
        this.nuevoUsuario = {
          username: '',
          email: '',
          password: '',
          nombre_completo: '',
          id_rol: 2,
          sedes: []
        };
        this.sedesTexto = '';

        // Recargar lista sin refrescar la página
        this.cargarUsuarios();
        this.cdr.detectChanges();
      },
      error: (err) => {
        console.error(err);
        this.mensajeError = err?.error?.error || 'Error creando el usuario.';
        this.creando = false;
        this.cdr.detectChanges();
      }
    });
  }

  // ========= CREAR AUTORIZANTE =============

  crearAutorizante(): void {
    this.mensajeAutorizanteOk = null;
    this.mensajeAutorizanteError = null;

    if (!this.nuevoAutorizante.numero_documento ||
        !this.nuevoAutorizante.tipo_documento ||
        !this.nuevoAutorizante.nombre) {
      this.mensajeAutorizanteError = 'Completa los campos obligatorios.';
      return;
    }

    const numero = Number(this.nuevoAutorizante.numero_documento);
    if (!Number.isFinite(numero)) {
      this.mensajeAutorizanteError = 'El numero de documento debe ser numerico.';
      return;
    }

    const payload: CrearAutorizantePayload = {
      numero_documento: numero,
      tipo_documento: this.nuevoAutorizante.tipo_documento,
      nombre: this.nuevoAutorizante.nombre,
      telefono: this.nuevoAutorizante.telefono || undefined,
      cargo: this.nuevoAutorizante.cargo || undefined,
      activo: this.nuevoAutorizante.activo
    };

    this.creandoAutorizante = true;

    this.pacienteService.crearAutorizante(payload).subscribe({
      next: (resp: any) => {
        this.mensajeAutorizanteOk =
          resp?.mensaje || 'Autorizante creado correctamente.';
        this.creandoAutorizante = false;

        this.nuevoAutorizante = {
          numero_documento: '',
          tipo_documento: 'CC',
          nombre: '',
          telefono: '',
          cargo: '',
          activo: true
        };

        this.cargarAutorizantesAdmin();
        this.cdr.detectChanges();
      },
      error: (err) => {
        console.error(err);
        this.mensajeAutorizanteError =
          err?.error?.error || 'Error creando el autorizante.';
        this.creandoAutorizante = false;
        this.cdr.detectChanges();
      }
    });
  }

  cambiarEstadoAutorizante(a: Autorizante, activo: boolean): void {
    if (!confirm(`¿Seguro que deseas ${activo ? 'activar' : 'desactivar'} al autorizante "${a.nombre}"?`)) {
      return;
    }

    this.pacienteService.actualizarEstadoAutorizante(a.numero_documento, activo).subscribe({
      next: (resp: any) => {
        if (resp?.autorizante) {
          a.activo = resp.autorizante.activo;
        } else {
          a.activo = activo;
        }
        this.cdr.detectChanges();
      },
      error: (err) => {
        console.error(err);
        alert('Error actualizando estado del autorizante.');
      }
    });
  }

  cargarAutorizantesAdmin(): void {
    this.cargandoAutorizantes = true;
    this.errorAutorizantes = null;

    this.pacienteService.obtenerAutorizantesAdmin().subscribe({
      next: (autorizantes) => {
        this.autorizantes = autorizantes;
        this.cargandoAutorizantes = false;
        this.cdr.detectChanges();
      },
      error: (err) => {
        console.error(err);
        this.errorAutorizantes = 'Error cargando autorizantes.';
        this.cargandoAutorizantes = false;
        this.cdr.detectChanges();
      }
    });
  }

  // ========= ACTIVAR / DESACTIVAR =============

  cambiarEstadoUsuario(u: any, activo: boolean): void {
    if (!confirm(`¿Seguro que deseas ${activo ? 'activar' : 'desactivar'} al usuario "${u.username}"?`)) {
      return;
    }

    this.authService.actualizarEstadoUsuario(u.id_usuario, activo).subscribe({
      next: () => {
        // Actualizamos en memoria para que se vea de una
        u.activo = activo;
      },
      error: (err) => {
        console.error(err);
        alert('Error actualizando estado del usuario.');
      }
    });
  }

  trackByUsuario(_index: number, usuario: any): number | string {
    return usuario?.id_usuario ?? usuario?.username ?? _index;
  }

  trackByAutorizante(_index: number, autorizante: Autorizante): number | string {
    return autorizante?.numero_documento ?? _index;
  }
}
