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;
  tiene_convenio?: boolean | null;
}

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 ActualizarAutorizantePayload {
  nombre?: string;
  telefono?: string | null;
  cargo?: string | null;
}

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;
  estado_autorizacion?: string;
}

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;
  estado_autorizacion?: string | null;
  id_ips?: number | null;
  numero_documento_autorizante?: number | null;
  nombre_ips: string;
  municipio?: string | null;
  departamento?: string | null;
  ips_tiene_convenio?: boolean | null;
  nombre_autorizante: string;
}

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

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

export interface CupInfo {
  codigo: string;
  descripcion: string;
  nivel?: string | null;
  especialidad?: string | null;
  cubierto: boolean;
}

// ====== 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}/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}/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}/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}/ips-por-interno`, {
      params,
      headers: this.getAuthHeaders()
    });
  }

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

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

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

  actualizarDatosAutorizante(
    numeroDocumento: number,
    payload: ActualizarAutorizantePayload
  ): Observable<any> {
    return this.http.patch(
      `${this.API_URL}/autorizantes/${numeroDocumento}`,
      payload,
      { headers: this.getAuthHeaders() }
    );
  }

  // ---- Autorizaciones ----

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

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

  obtenerVersionesAutorizacion(numeroAutorizacion: string): Observable<AutorizacionVersionResponse> {
    return this.http.get<AutorizacionVersionResponse>(
      `${this.API_URL}/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}/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}/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}/cargar-cups`,
      formData,
      { headers }
    );
  }

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

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

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

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

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

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

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

  buscarCups(termino: string, limit = 200): Observable<CupInfo[]> {
    const params = new HttpParams()
      .set('q', termino)
      .set('limit', String(limit));
    return this.http.get<CupInfo[]>(`${this.API_URL}/cups`, {
      params,
      headers: this.getAuthHeaders()
    });
  }

  actualizarEstadoAutorizacion(
    numeroAutorizacion: string,
    estado: 'pendiente' | 'autorizado' | 'no_autorizado'
  ): Observable<any> {
    return this.http.patch(
      `${this.API_URL}/autorizaciones/${numeroAutorizacion}/estado`,
      { estado_autorizacion: estado },
      { headers: this.getAuthHeaders() }
    );
  }

  actualizarEstadoAutorizacionesMasivo(
    fechaInicio: string,
    fechaFin: string,
    estado: 'pendiente' | 'autorizado' | 'no_autorizado',
    soloPendientes = false
  ): Observable<any> {
    return this.http.patch(
      `${this.API_URL}/autorizaciones/estado-masivo`,
      {
        fecha_inicio: fechaInicio,
        fecha_fin: fechaFin,
        estado_autorizacion: estado,
        solo_pendientes: soloPendientes,
      },
      { headers: this.getAuthHeaders() }
    );
  }

}
