// src/services/doctorService.ts
import api from './api';
import { User } from '../types';
import { DoctorProfile, ApiResponse } from "../types";

export interface AddDoctorRequest {
  name: string;
  email: string;
  role: 'consultant' | 'junior_doctor' | 'senior_consultant';
  department: string;
  gender: 'Male' | 'Female' | 'Other';
  designation: string;
  registrationNumber: string;
  phoneNumber: string;
  profileSummary: string;
  qualifications: string;
  clinicalSummary: string;
  status: 'Active' | 'Inactive' | 'On Leave';
  reviewerId?: number;
  reviewer?: boolean;
}

export interface AddDoctorResponse {
  success: boolean;
  message?: string;
  data?: User;
  error?: string;
}

export interface GetDoctorsResponse {
  success: boolean;
  message?: string;
  data?: User[];
  error?: string;
}

export const addDoctor = async (doctorData: AddDoctorRequest): Promise<AddDoctorResponse> => {
  try {
    // Token is automatically attached via axios interceptor in api.ts
    // The interceptor reads from localStorage and adds: Authorization: Bearer <token>
    const token = localStorage.getItem("token");
    if (!token) {
      return {
        success: false,
        message: 'Authentication required. Please log in again.',
        error: 'No authentication token found',
      };
    }

    // API base URL is loaded from .env file (REACT_APP_API_BASE_URL)
    // This will make a POST request to: <API_BASE_URL>/doctors
    // Example: http://localhost:5000/api/doctors
    const response = await api.post('/doctors', doctorData);
    return response.data;
  } catch (error: any) {
    // Handle different error scenarios
    if (error.response) {
      // Server responded with error status
      return {
        success: false,
        message: error.response.data?.message || 'Failed to add doctor',
        error: error.response.data?.error || error.message,
      };
    } else if (error.request) {
      // Request was made but no response received
      return {
        success: false,
        message: 'Network error. Please check your connection.',
        error: 'No response from server',
      };
    } else {
      // Something else happened
      return {
        success: false,
        message: 'An unexpected error occurred',
        error: error.message,
      };
    }
  }
};

export const getDoctors = async (): Promise<User[]> => {
  try {
    const token = localStorage.getItem("token");
    if (!token) {
      throw new Error('Authentication required. Please log in again.');
    }

    const response = await api.get('/doctors');

    // ✅ backend returns array directly
    return response.data as User[];
  } catch (error: any) {
    console.error('getDoctors error:', error);

    // ✅ ALWAYS throw errors for fetch APIs
    throw new Error(
      error.response?.data?.message ||
      'Failed to fetch doctors'
    );
  }
};

export interface UpdateDoctorRequest {
  name?: string;
  email?: string;
  role?: 'consultant' | 'junior_doctor' | 'senior_consultant';
  department?: string;
  gender?: 'Male' | 'Female' | 'Other';
  designation?: string;
  registrationNumber?: string;
  phoneNumber?: string;
  profileSummary?: string;
  qualifications?: string;
  clinicalSummary?: string;
  status?: 'Active' | 'Inactive' | 'On Leave';
  reviewerId?: number;
  reviewer?: boolean;
}

export interface UpdateDoctorResponse {
  success: boolean;
  message?: string;
  data?: User;
  error?: string;
}

export const updateDoctor = async (doctorId: number, doctorData: UpdateDoctorRequest): Promise<UpdateDoctorResponse> => {
  try {
    const token = localStorage.getItem("token");
    if (!token) {
      return {
        success: false,
        message: 'Authentication required. Please log in again.',
        error: 'No authentication token found',
      };
    }

    const response = await api.put(`/doctors/${doctorId}`, doctorData);
    return response.data;
  } catch (error: any) {
    if (error.response) {
      return {
        success: false,
        message: error.response.data?.message || 'Failed to update doctor',
        error: error.response.data?.error || error.message,
      };
    } else if (error.request) {
      return {
        success: false,
        message: 'Network error. Please check your connection.',
        error: 'No response from server',
      };
    } else {
      return {
        success: false,
        message: 'An unexpected error occurred',
        error: error.message,
      };
    }
  }
};

export interface DeleteDoctorResponse {
  success: boolean;
  message?: string;
  error?: string;
}

// export const deleteDoctor = async (doctorId: number): Promise<DeleteDoctorResponse> => {
//   try {
//     const token = localStorage.getItem("token");
//     if (!token) {
//       return {
//         success: false,
//         message: 'Authentication required. Please log in again.',
//         error: 'No authentication token found',
//       };
//     }

//     const response = await api.delete(`/doctors/${doctorId}`);
//     return response.data;
//   } catch (error: any) {
//     if (error.response) {
//       return {
//         success: false,
//         message: error.response.data?.message || 'Failed to delete doctor',
//         error: error.response.data?.error || error.message,
//       };
//     } else if (error.request) {
//       return {
//         success: false,
//         message: 'Network error. Please check your connection.',
//         error: 'No response from server',
//       };
//     } else {
//       return {
//         success: false,
//         message: 'An unexpected error occurred',
//         error: error.message,
//       };
//     }
//   }
// };

// Fetch Senior Consultants for reviewer dropdown
export const getSeniorConsultants = async (): Promise<User[]> => {
  try {
    const token = localStorage.getItem("token");
    if (!token) {
      throw new Error('Authentication required. Please log in again.');
    }

    const response = await api.get('/doctors', {
      params: { role: 'senior_consultant' }
    });

    // Filter to only Senior Consultants if backend doesn't filter
    const allDoctors = response.data as User[];
    return allDoctors.filter(doctor => {
      const role = doctor?.User?.role || doctor?.role || '';
      return role.toLowerCase() === 'senior_consultant' || role === 'SENIOR_CONSULTANT';
    });
  } catch (error: any) {
    console.error('getSeniorConsultants error:', error);
    throw new Error(
      error.response?.data?.message ||
      'Failed to fetch senior consultants'
    );
  }
};


 
export const getAllDoctors = async (): Promise<DoctorProfile[]> => {
  try {
    const response = await api.get<ApiResponse<DoctorProfile[]>>("/admin/doctors");
    return response.data.data;
  } catch (error: any) {
    // Log full error details for debugging
    console.error("getAllDoctors error:", {
      message: error.message,
      status: error.response?.status,
      statusText: error.response?.statusText,
      url: error.config?.url,
      baseURL: error.config?.baseURL,
      fullURL: `${error.config?.baseURL || ''}${error.config?.url || ''}`
    });
    throw error;
  }
};
 
export const blockDoctor = async (userId: number): Promise<DoctorProfile> => {
  const response = await api.patch<ApiResponse<DoctorProfile>>(
    `/admin/doctors/${userId}/block`
  );
  return response.data.data;
};
 
export const unblockDoctor = async (userId: number): Promise<DoctorProfile> => {
  const response = await api.patch<ApiResponse<DoctorProfile>>(
    `/admin/doctors/${userId}/unblock`
  );
  return response.data.data;
};
 
export const deleteDoctor = async (userId: number): Promise<void> => {
  await api.delete<ApiResponse<{ message: string }>>(
    `/admin/doctors/${userId}`
  );
};