import { Injectable } from '@angular/core';
import { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';
import { Observable } from 'rxjs';
import { AuthService } from './auth';
import { JobResponse } from './job-types';
import { API_BASE_URL } from '../config';


// ====== Interfaces ======

export interface Paciente {
  interno: string;
  tipo_documento: string;
  numero_documento: string;
  primer_apellido: string;
  segundo_apellido: string | null;
  primer_nombre: string;
  segundo_nombre: string | null;
  fecha_nacimiento: string; // viene como texto ISO del backend
  edad: number;
  sexo: string;
  codigo_establecimiento?: string | null;
  nombre_establecimiento?: string | null;
  epc_departamento?: string | null;
  epc_ciudad?: string | null;
  estado?: string | null;
  fecha_ingreso?: string | null;
  tiempo_reclusion?: number | null;
}

export interface Ips {
  id_ips: number;
  nombre_ips: string;
  direccion?: string;
  telefono?: string;
  departamento: string;
  municipio: string;
}

export interface Autorizante {
  numero_documento: number;
  tipo_documento: string;
  nombre: string;
  telefono?: string;
  cargo?: string;
  activo: boolean;
}

export interface CrearAutorizantePayload {
  numero_documento: number;
  tipo_documento: string;
  nombre: string;
  telefono?: string;
  cargo?: string;
  activo?: boolean;
}

export interface CrearAutorizacionPayload {
  interno: string;
  id_ips: number;
  numero_documento_autorizante: number;
  cup_codigo: string;
  tipo_autorizacion?: string;
  tipo_servicio?: string;
  observacion?: string;
  fecha_autorizacion?: string; // yyyy-MM-dd
}

export interface RespuestaAutorizacion {
  numero_autorizacion: string;
  fecha_autorizacion: string;
  version?: number;
}

export interface AutorizacionListado {
  numero_autorizacion: string;
  fecha_autorizacion: string;
  observacion: string | null;
  cup_codigo?: string | null;
  cup_descripcion?: string | null;
  cup_nivel?: string | null;
  cup_especialidad?: string | null;
  tipo_autorizacion?: string | null;
  tipo_servicio?: string | null;
  version?: number | null;
  id_ips?: number | null;
  numero_documento_autorizante?: number | null;
  nombre_ips: string;
  municipio: string;
  departamento: string;
  nombre_autorizante: string;
}

export interface AutorizacionVersion {
  version: number;
  fecha_version?: string | null;
  fecha_autorizacion?: string | null;
}

export interface AutorizacionVersionResponse {
  version_actual: number;
  versiones: AutorizacionVersion[];
}

// ====== Servicio ======

@Injectable({
  providedIn: 'root'
})
export class PacienteService {
  private readonly API_URL = API_BASE_URL;

  constructor(
    private http: HttpClient,
    private authService: AuthService
  ) {}

  private getAuthHeaders(): HttpHeaders {
    // Este método probablemente devuelve un header con 'Content-Type': 'application/json'
    return this.authService.getAuthHeaders();
  }

  // ---- Búsquedas de pacientes ----

  buscarPorDocumento(numero_documento: string): Observable<Paciente[]> {
    const params = new HttpParams().set('numero_documento', numero_documento);
    return this.http.get<Paciente[]>(`${this.API_URL}/api/pacientes`, {
      params,
      headers: this.getAuthHeaders()
    });
  }

  buscarPorInterno(interno: string): Observable<Paciente[]> {
    const params = new HttpParams().set('interno', interno);
    return this.http.get<Paciente[]>(`${this.API_URL}/api/pacientes`, {
      params,
      headers: this.getAuthHeaders()
    });
  }

  buscarPorNombre(nombre: string): Observable<Paciente[]> {
    const params = new HttpParams().set('nombre', nombre);
    return this.http.get<Paciente[]>(`${this.API_URL}/api/pacientes`, {
      params,
      headers: this.getAuthHeaders()
    });
  }

  // ---- IPS y autorizantes ----

  obtenerIpsPorInterno(interno: string, verTodas = false): Observable<Ips[]> {
    let params = new HttpParams().set('interno', interno);
    if (verTodas) {
      params = params.set('ver_todas', '1');
    }
    return this.http.get<Ips[]>(`${this.API_URL}/api/ips-por-interno`, {
      params,
      headers: this.getAuthHeaders()
    });
  }

  obtenerAutorizantes(): Observable<Autorizante[]> {
    return this.http.get<Autorizante[]>(`${this.API_URL}/api/autorizantes`, {
      headers: this.getAuthHeaders()
    });
  }

  obtenerAutorizantesAdmin(): Observable<Autorizante[]> {
    return this.http.get<Autorizante[]>(`${this.API_URL}/api/autorizantes/admin`, {
      headers: this.getAuthHeaders()
    });
  }

  actualizarEstadoAutorizante(numeroDocumento: number, activo: boolean): Observable<any> {
    return this.http.patch(
      `${this.API_URL}/api/autorizantes/${numeroDocumento}/estado`,
      { activo },
      { headers: this.getAuthHeaders() }
    );
  }

  // ---- Autorizaciones ----

  crearAutorizacion(payload: CrearAutorizacionPayload): Observable<RespuestaAutorizacion> {
    return this.http.post<RespuestaAutorizacion>(
      `${this.API_URL}/api/autorizaciones`,
      payload,
      { headers: this.getAuthHeaders() }
    );
  }

  actualizarAutorizacion(
    numeroAutorizacion: string,
    payload: CrearAutorizacionPayload
  ): Observable<RespuestaAutorizacion> {
    return this.http.put<RespuestaAutorizacion>(
      `${this.API_URL}/api/autorizaciones/${numeroAutorizacion}`,
      payload,
      { headers: this.getAuthHeaders() }
    );
  }

  obtenerVersionesAutorizacion(numeroAutorizacion: string): Observable<AutorizacionVersionResponse> {
    return this.http.get<AutorizacionVersionResponse>(
      `${this.API_URL}/api/autorizaciones/${numeroAutorizacion}/versiones`,
      { headers: this.getAuthHeaders() }
    );
  }

  obtenerAutorizacionesPorInterno(interno: string): Observable<AutorizacionListado[]> {
    const params = new HttpParams().set('interno', interno);
    return this.http.get<AutorizacionListado[]>(
      `${this.API_URL}/api/autorizaciones`,
      { params, headers: this.getAuthHeaders() }
    );
  }

  // ---- Cargar Excel (Python + SQL) ----
  cargarExcelPacientes(formData: FormData): Observable<JobResponse> {
    // 1. Obtenemos el token desde el AuthService.
    //    Asumimos que tu AuthService tiene un método para obtener el token.
    const token = this.authService.getToken(); 

    // 2. Creamos un objeto de headers nuevo y solo añadimos el de autorización.
    //    NO añadimos 'Content-Type' para que Angular lo gestione automáticamente.
    const headers = new HttpHeaders({
      'Authorization': `Bearer ${token}`
    });

    // 3. Hacemos la petición con estos headers limpios.
    return this.http.post<JobResponse>(
      `${this.API_URL}/api/cargar-excel-pacientes`,
      formData,
      { headers }
    );
  }

  cargarExcelCups(formData: FormData): Observable<JobResponse> {
    const token = this.authService.getToken();
    const headers = new HttpHeaders({
      'Authorization': `Bearer ${token}`
    });

    return this.http.post<JobResponse>(
      `${this.API_URL}/api/cargar-cups`,
      formData,
      { headers }
    );
  }

  crearAutorizante(payload: CrearAutorizantePayload): Observable<any> {
    return this.http.post(
      `${this.API_URL}/api/autorizantes`,
      payload,
      { headers: this.getAuthHeaders() }
    );
  }

  buscarCupsCubiertos(termino: string): Observable<any[]> {
    const params = new HttpParams().set('q', termino);
    return this.http.get<any[]>(`${this.API_URL}/api/cups-cubiertos`, {
      params,
      headers: this.getAuthHeaders()
    });
  }

}
