/**
 * Serviço de Pacientes (Frontend)
 */

import { apiClient } from "../api/client";
import type {
  Patient,
  CreatePatientInput,
  UpdatePatientInput,
  PatientFilters,
  RegisterPatientInput,
  RegisterPatientResponse,
} from "./types";

class PatientService {
  /**
   * Lista todos os pacientes
   */
  async list(filters?: PatientFilters): Promise<Patient[]> {
    try {
      const params = new URLSearchParams();

      if (filters?.full_name) {
        params.append("full_name", `ilike.*${filters.full_name}*`);
      }
      if (filters?.cpf) {
        params.append("cpf", `eq.${filters.cpf}`);
      }
      if (filters?.email) {
        params.append("email", `ilike.*${filters.email}*`);
      }
      if (filters?.phone_mobile) {
        params.append("phone_mobile", `eq.${filters.phone_mobile}`);
      }

      const queryString = params.toString();
      const url = queryString ? `/patients?${queryString}` : "/patients";

      const response = await apiClient.get<Patient[]>(url);
      return response.data;
    } catch (error: any) {
      // Silenciar erro 401 (não autenticado) - é esperado em páginas públicas
      if (error?.response?.status !== 401) {
        console.error("Erro ao listar pacientes:", error);
      }
      throw error;
    }
  }

  /**
   * Busca paciente por ID
   */
  async getById(id: string): Promise<Patient> {
    try {
      console.log("[patientService] Buscando paciente por ID:", id);
      const response = await apiClient.get<Patient[]>(`/patients?id=eq.${id}`);
      console.log("[patientService] Response data:", response.data);
      console.log("[patientService] Response length:", response.data?.length);

      if (response.data && response.data.length > 0) {
        console.log("[patientService] Paciente encontrado:", response.data[0]);
        return response.data[0];
      }

      console.warn(
        "[patientService] Array vazio - paciente não existe na tabela patients"
      );
      throw new Error("Paciente não encontrado");
    } catch (error) {
      console.error("[patientService] Erro ao buscar paciente:", error);
      throw error;
    }
  }

  /**
   * Busca paciente por user_id (ID do auth do Supabase)
   */
  async getByUserId(userId: string): Promise<Patient> {
    try {
      console.log("[patientService] Buscando paciente por user_id:", userId);
      const response = await apiClient.get<Patient[]>(
        `/patients?user_id=eq.${userId}`
      );
      console.log("[patientService] Response data:", response.data);

      if (response.data && response.data.length > 0) {
        console.log("[patientService] Paciente encontrado:", response.data[0]);
        return response.data[0];
      }

      console.warn(
        "[patientService] Paciente não encontrado com user_id:",
        userId
      );
      throw new Error("Paciente não encontrado");
    } catch (error) {
      console.error("[patientService] Erro ao buscar paciente:", error);
      throw error;
    }
  }

  /**
   * Cria novo paciente
   */
  async create(data: CreatePatientInput): Promise<Patient> {
    try {
      const response = await apiClient.post<Patient>("/patients", data);
      return response.data;
    } catch (error) {
      console.error("Erro ao criar paciente:", error);
      throw error;
    }
  }

  /**
   * Atualiza paciente existente
   */
  async update(id: string, data: UpdatePatientInput): Promise<Patient> {
    try {
      const response = await apiClient.patch<Patient[]>(
        `/patients?id=eq.${id}`,
        data
      );
      if (response.data && response.data.length > 0) {
        return response.data[0];
      }
      throw new Error("Paciente não encontrado");
    } catch (error) {
      console.error("Erro ao atualizar paciente:", error);
      throw error;
    }
  }

  /**
   * Atualiza paciente por user_id
   */
  async updateByUserId(
    userId: string,
    data: UpdatePatientInput
  ): Promise<Patient> {
    try {
      console.log("[patientService] Atualizando paciente por user_id:", {
        userId,
        data,
      });
      const response = await apiClient.patch<Patient[]>(
        `/patients?user_id=eq.${userId}`,
        data
      );
      if (response.data && response.data.length > 0) {
        console.log("[patientService] Paciente atualizado:", response.data[0]);
        return response.data[0];
      }
      throw new Error("Paciente não encontrado");
    } catch (error) {
      console.error("[patientService] Erro ao atualizar paciente:", error);
      throw error;
    }
  }

  /**
   * Deleta paciente
   */
  async delete(id: string): Promise<void> {
    try {
      await apiClient.delete(`/patients?id=eq.${id}`);
    } catch (error) {
      console.error("Erro ao deletar paciente:", error);
      throw error;
    }
  }

  /**
   * Registro público de paciente (não requer autenticação)
   * Usa o endpoint register-patient que tem validações rigorosas
   */
  async register(data: RegisterPatientInput): Promise<RegisterPatientResponse> {
    try {
      console.log("[patientService.register] Enviando dados:", data);

      // Usa postPublic para não enviar token de autenticação
      const response = await (
        apiClient as any
      ).postPublic<RegisterPatientResponse>("/register-patient", data);

      console.log("[patientService.register] Resposta:", response.data);
      return response.data;
    } catch (error: any) {
      console.error("[patientService.register] Erro completo:", {
        message: error.message,
        response: error.response?.data,
        status: error.response?.status,
      });
      throw error;
    }
  }
}

export const patientService = new PatientService();
