@blackcode_sa/metaestetics-api 1.12.62 → 1.12.63

package/src/services/patient/patient.service.ts

@@ -1,883 +1,883 @@
-import {
-  doc,
-  getDoc,
-  writeBatch,
-  updateDoc,
-  arrayUnion,
-  serverTimestamp,
-} from 'firebase/firestore';
-import { BaseService } from '../base.service';
-import { MediaService, MediaAccessLevel, MediaResource } from '../media/media.service';
-import {
-  PatientProfile,
-  PatientSensitiveInfo,
-  PatientLocationInfo,
-  CreatePatientProfileData,
-  CreatePatientSensitiveInfoData,
-  UpdatePatientSensitiveInfoData,
-  CreatePatientLocationInfoData,
-  UpdatePatientLocationInfoData,
-  PatientMedicalInfo,
-  CreatePatientMedicalInfoData,
-  UpdateVitalStatsData,
-  AddAllergyData,
-  UpdateAllergyData,
-  AddBlockingConditionData,
-  UpdateBlockingConditionData,
-  AddContraindicationData,
-  UpdateContraindicationData,
-  AddMedicationData,
-  UpdateMedicationData,
-  PatientDoctor,
-  PatientClinic,
-  SearchPatientsParams,
-  RequesterInfo,
-  PatientProfileForDoctor,
-  CreateManualPatientData,
-} from '../../types/patient';
-import { Auth } from 'firebase/auth';
-import { Firestore } from 'firebase/firestore';
-import { FirebaseApp } from 'firebase/app';
-import { Timestamp } from 'firebase/firestore';
-
-// Importujemo utility funkcije
-import {
-  createPatientProfileUtil,
-  getPatientProfileUtil,
-  getPatientProfileByUserRefUtil,
-  addExpoTokenUtil,
-  removeExpoTokenUtil,
-  addPointsUtil,
-  updatePatientProfileUtil,
-  updatePatientProfileByUserRefUtil,
-  searchPatientsUtil,
-  getAllPatientsUtil,
-  updatePatientLocationUtil,
-  createLocationInfoUtil,
-  getLocationInfoUtil,
-  updateLocationInfoUtil,
-  createSensitiveInfoUtil,
-  getSensitiveInfoUtil,
-  updateSensitiveInfoUtil,
-  claimPatientSensitiveInfoUtil,
-  createMedicalInfoUtil,
-  getMedicalInfoUtil,
-  updateVitalStatsUtil,
-  addAllergyUtil,
-  updateAllergyUtil,
-  removeAllergyUtil,
-  addBlockingConditionUtil,
-  updateBlockingConditionUtil,
-  removeBlockingConditionUtil,
-  addContraindicationUtil,
-  updateContraindicationUtil,
-  removeContraindicationUtil,
-  addMedicationUtil,
-  updateMedicationUtil,
-  removeMedicationUtil,
-  getPatientDocRef,
-  getSensitiveInfoDocRef,
-  getLocationInfoDocRef,
-  getMedicalInfoDocRef,
-  addDoctorUtil,
-  removeDoctorUtil,
-  addClinicUtil,
-  removeClinicUtil,
-  getPatientsByPractitionerUtil,
-  getPatientsByPractitionerWithDetailsUtil,
-  getPatientsByClinicUtil,
-  createPatientTokenUtil,
-  validatePatientTokenUtil,
-  markPatientTokenAsUsedUtil,
-  getActiveInviteTokensByClinicUtil,
-  getActiveInviteTokensByPatientUtil,
-} from './utils';
-
-import {
-  getAestheticAnalysisUtil,
-  createOrUpdateAestheticAnalysisUtil,
-} from './utils/aesthetic-analysis.utils';
-
-import {
-  AestheticAnalysis,
-  CreateAestheticAnalysisData,
-  UpdateAestheticAnalysisData,
-} from '../../types/patient';
-
-import { CreatePatientTokenData, PatientToken } from '../../types/patient/token.types';
-
-export class PatientService extends BaseService {
-  private mediaService: MediaService;
-
-  constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
-    super(db, auth, app);
-    this.mediaService = new MediaService(db, auth, app);
-  }
-
-  // Metode za rad sa profilom pacijenta
-  async createPatientProfile(data: CreatePatientProfileData): Promise<PatientProfile> {
-    return createPatientProfileUtil(this.db, data, () => this.generateId());
-  }
-
-  async getPatientProfile(patientId: string): Promise<PatientProfile | null> {
-    return getPatientProfileUtil(this.db, patientId);
-  }
-
-  /**
-   * Manually creates a new patient profile, typically initiated by a clinic admin.
-   * This creates a patient record that is not initially linked to an authenticated user.
-   *
-   * @param {CreateManualPatientData} data - The data for the new patient.
-   * @param {RequesterInfo} requester - Information about the user creating the patient (must be a clinic admin).
-   * @returns {Promise<PatientProfile>} The newly created patient profile.
-   * @throws {Error} If the requester is not a valid clinic admin.
-   */
-  async createManualPatient(
-    data: CreateManualPatientData,
-    requester: RequesterInfo,
-  ): Promise<PatientProfile> {
-    console.log(
-      `[PatientService.createManualPatient] Attempting to create manual patient by requester:`,
-      requester,
-    );
-
-    // Security Check: Ensure the requester is a clinic admin
-    if (
-      requester.role !== 'clinic_admin' ||
-      !requester.associatedClinicId ||
-      requester.associatedClinicId !== data.clinicId
-    ) {
-      throw new Error(
-        'Unauthorized: Requester must be a clinic admin and can only add patients to their own clinic.',
-      );
-    }
-
-    const patientId = this.generateId();
-    const batch = writeBatch(this.db);
-    const now = Timestamp.now();
-
-    // 1. Create Patient Profile
-    const patientProfileRef = getPatientDocRef(this.db, patientId);
-    const newProfile: PatientProfile = {
-      id: patientId,
-      displayName: `${data.firstName} ${data.lastName.charAt(0)}.`,
-      expoTokens: [],
-      gamification: { level: 1, points: 0 },
-      isActive: true,
-      isVerified: false, // Manual profiles are not verified by default
-      isManual: true,
-      doctors: [],
-      clinics: [
-        {
-          clinicId: data.clinicId,
-          assignedAt: now,
-          assignedBy: requester.id,
-          isActive: true,
-          notes: data.notes,
-        },
-      ],
-      doctorIds: [],
-      clinicIds: [data.clinicId],
-      createdAt: now,
-      updatedAt: now,
-      phoneNumber: data.phoneNumber,
-      dateOfBirth: data.dateOfBirth,
-    };
-    batch.set(patientProfileRef, newProfile);
-
-    // 2. Create Patient Sensitive Info
-    const sensitiveInfoRef = getSensitiveInfoDocRef(this.db, patientId);
-    const newSensitiveInfo: Omit<PatientSensitiveInfo, 'photoUrl'> = {
-      patientId,
-      firstName: data.firstName,
-      lastName: data.lastName,
-      dateOfBirth: data.dateOfBirth,
-      gender: data.gender,
-      email: data.email,
-      phoneNumber: data.phoneNumber,
-      addressData: data.addressData,
-      emergencyContacts: [],
-      createdAt: now,
-      updatedAt: now,
-    };
-    batch.set(sensitiveInfoRef, newSensitiveInfo);
-
-    // 3. Create Patient Medical Info
-    const medicalInfoRef = getMedicalInfoDocRef(this.db, patientId);
-    const newMedicalInfo: PatientMedicalInfo = {
-      patientId,
-      vitalStats: {},
-      blockingConditions: [],
-      contraindications: [],
-      allergies: [],
-      currentMedications: [],
-      emergencyNotes: '',
-      lastUpdated: now,
-      updatedBy: requester.id, // The admin who created the record
-    };
-    batch.set(medicalInfoRef, newMedicalInfo);
-
-    await batch.commit();
-
-    console.log(
-      `[PatientService.createManualPatient] Successfully created manual patient with ID: ${patientId}`,
-    );
-
-    return newProfile;
-  }
-
-  async getPatientProfileByUserRef(userRef: string): Promise<PatientProfile | null> {
-    return getPatientProfileByUserRefUtil(this.db, userRef);
-  }
-
-  // Metode za rad sa lokacijskim podacima
-  async updatePatientLocation(
-    patientId: string,
-    latitude: number,
-    longitude: number,
-  ): Promise<void> {
-    await updatePatientLocationUtil(this.db, patientId, latitude, longitude);
-  }
-
-  async updatePatientLocationByUserRef(
-    userRef: string,
-    latitude: number,
-    longitude: number,
-  ): Promise<void> {
-    const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) throw new Error('Patient profile not found');
-    await this.updatePatientLocation(profile.id, latitude, longitude);
-  }
-
-  async createLocationInfo(
-    data: CreatePatientLocationInfoData,
-    requesterId: string,
-  ): Promise<PatientLocationInfo> {
-    return createLocationInfoUtil(this.db, data, requesterId);
-  }
-
-  async getLocationInfo(
-    patientId: string,
-    requesterId: string,
-  ): Promise<PatientLocationInfo | null> {
-    return getLocationInfoUtil(this.db, patientId, requesterId);
-  }
-
-  async getLocationInfoByUserRef(
-    userRef: string,
-    requesterId: string,
-  ): Promise<PatientLocationInfo | null> {
-    const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) return null;
-    return this.getLocationInfo(profile.id, requesterId);
-  }
-
-  async updateLocationInfo(
-    patientId: string,
-    data: UpdatePatientLocationInfoData,
-    requesterId: string,
-  ): Promise<PatientLocationInfo> {
-    return updateLocationInfoUtil(this.db, patientId, data, requesterId);
-  }
-
-  // Metode za rad sa osetljivim informacijama
-  async createSensitiveInfo(
-    data: CreatePatientSensitiveInfoData,
-    requesterUserId: string,
-  ): Promise<PatientSensitiveInfo> {
-    const currentUser = await this.getCurrentUser();
-    if (currentUser.uid !== requesterUserId) {
-      throw new Error('Requester does not match authenticated user.');
-    }
-
-    return createSensitiveInfoUtil(
-      this.db,
-      data,
-      requesterUserId,
-      currentUser.roles,
-      this.mediaService,
-    );
-  }
-
-  async getSensitiveInfo(
-    patientId: string,
-    requesterUserId: string,
-  ): Promise<PatientSensitiveInfo | null> {
-    const currentUser = await this.getCurrentUser();
-    if (currentUser.uid !== requesterUserId) {
-      // Allow for read-only access if authorized, but for now we check identity
-      // This could be expanded later based on practitioner/admin roles
-    }
-    return getSensitiveInfoUtil(this.db, patientId, requesterUserId, currentUser.roles);
-  }
-
-  async getSensitiveInfoByUserRef(
-    userRef: string,
-    requesterUserId: string,
-  ): Promise<PatientSensitiveInfo | null> {
-    const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) return null;
-    // We pass requesterUserId which is the UID of the one asking.
-    return this.getSensitiveInfo(profile.id, requesterUserId);
-  }
-
-  async updateSensitiveInfo(
-    patientId: string,
-    data: UpdatePatientSensitiveInfoData,
-    requesterUserId: string,
-  ): Promise<PatientSensitiveInfo> {
-    const currentUser = await this.getCurrentUser();
-    if (currentUser.uid !== requesterUserId) {
-      throw new Error('Requester does not match authenticated user.');
-    }
-    return updateSensitiveInfoUtil(
-      this.db,
-      patientId,
-      data,
-      requesterUserId,
-      currentUser.roles,
-      this.mediaService,
-    );
-  }
-
-  async claimPatientSensitiveInfo(
-    patientId: string,
-    userId: string,
-  ): Promise<PatientSensitiveInfo> {
-    return claimPatientSensitiveInfoUtil(this.db, patientId, userId);
-  }
-
-  // Metode za rad sa medicinskim informacijama
-  async createMedicalInfo(patientId: string, data: CreatePatientMedicalInfoData): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    await createMedicalInfoUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
-  }
-
-  async getMedicalInfo(patientId: string): Promise<PatientMedicalInfo> {
-    const currentUser = await this.getCurrentUser();
-    return getMedicalInfoUtil(this.db, patientId, currentUser.uid, currentUser.roles);
-  }
-
-  async getMedicalInfoByUserRef(userRef: string): Promise<PatientMedicalInfo> {
-    const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) throw new Error('Patient profile not found');
-    return this.getMedicalInfo(profile.id);
-  }
-
-  // Metode za rad sa vitalnim statistikama
-  async updateVitalStats(patientId: string, data: UpdateVitalStatsData): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    await updateVitalStatsUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
-  }
-
-  // Metode za rad sa alergijama
-  async addAllergy(patientId: string, data: AddAllergyData): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    await addAllergyUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
-  }
-
-  async updateAllergy(patientId: string, data: UpdateAllergyData): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    await updateAllergyUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
-  }
-
-  async removeAllergy(patientId: string, allergyIndex: number): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    await removeAllergyUtil(this.db, patientId, allergyIndex, currentUser.uid, currentUser.roles);
-  }
-
-  // Metode za rad sa blocking conditions
-  async addBlockingCondition(patientId: string, data: AddBlockingConditionData): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    await addBlockingConditionUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
-  }
-
-  async updateBlockingCondition(
-    patientId: string,
-    data: UpdateBlockingConditionData,
-  ): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    await updateBlockingConditionUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
-  }
-
-  async removeBlockingCondition(patientId: string, conditionIndex: number): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    await removeBlockingConditionUtil(
-      this.db,
-      patientId,
-      conditionIndex,
-      currentUser.uid,
-      currentUser.roles,
-    );
-  }
-
-  // Metode za rad sa kontraindikacijama
-  async addContraindication(patientId: string, data: AddContraindicationData): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    await addContraindicationUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
-  }
-
-  async updateContraindication(patientId: string, data: UpdateContraindicationData): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    await updateContraindicationUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
-  }
-
-  async removeContraindication(patientId: string, contraindicationIndex: number): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    await removeContraindicationUtil(
-      this.db,
-      patientId,
-      contraindicationIndex,
-      currentUser.uid,
-      currentUser.roles,
-    );
-  }
-
-  // Metode za rad sa medikacijama
-  async addMedication(patientId: string, data: AddMedicationData): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    await addMedicationUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
-  }
-
-  async updateMedication(patientId: string, data: UpdateMedicationData): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    await updateMedicationUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
-  }
-
-  async removeMedication(patientId: string, medicationIndex: number): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    await removeMedicationUtil(
-      this.db,
-      patientId,
-      medicationIndex,
-      currentUser.uid,
-      currentUser.roles,
-    );
-  }
-
-  // Pomoćne metode
-  async addExpoToken(patientId: string, token: string): Promise<void> {
-    await addExpoTokenUtil(this.db, patientId, token);
-  }
-
-  async addExpoTokenByUserRef(userRef: string, token: string): Promise<void> {
-    const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) throw new Error('Patient profile not found');
-    await this.addExpoToken(profile.id, token);
-  }
-
-  async removeExpoToken(patientId: string, token: string): Promise<void> {
-    await removeExpoTokenUtil(this.db, patientId, token);
-  }
-
-  async removeExpoTokenByUserRef(userRef: string, token: string): Promise<void> {
-    const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) throw new Error('Patient profile not found');
-    await this.removeExpoToken(profile.id, token);
-  }
-
-  async addPoints(patientId: string, points: number): Promise<void> {
-    await addPointsUtil(this.db, patientId, points);
-  }
-
-  async addPointsByUserRef(userRef: string, points: number): Promise<void> {
-    const profile = await this.getPatientProfileByUserRef(userRef);
-    if (!profile) throw new Error('Patient profile not found');
-    await this.addPoints(profile.id, points);
-  }
-
-  private async getCurrentUser(): Promise<any> {
-    if (!this.auth.currentUser) {
-      throw new Error('No authenticated user');
-    }
-    const userDoc = await getDoc(doc(this.db, 'users', this.auth.currentUser.uid));
-    if (!userDoc.exists()) {
-      throw new Error('User not found');
-    }
-    return userDoc.data();
-  }
-
-  /**
-   * Briše profil pacijenta i sve povezane subkolekcije
-   */
-  async deletePatientProfile(patientId: string): Promise<void> {
-    const batch = writeBatch(this.db);
-
-    // Brisanje sensitive info
-    batch.delete(getSensitiveInfoDocRef(this.db, patientId));
-
-    // Brisanje location info
-    batch.delete(getLocationInfoDocRef(this.db, patientId));
-
-    // Brisanje medical info
-    batch.delete(getMedicalInfoDocRef(this.db, patientId));
-
-    // Brisanje glavnog profila
-    batch.delete(getPatientDocRef(this.db, patientId));
-
-    await batch.commit();
-  }
-
-  // Metode za rad sa doktorima
-  async addDoctor(patientId: string, doctorRef: string): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    await addDoctorUtil(this.db, patientId, doctorRef, currentUser.uid);
-  }
-
-  async removeDoctor(patientId: string, doctorRef: string): Promise<void> {
-    await removeDoctorUtil(this.db, patientId, doctorRef);
-  }
-
-  // Metode za rad sa klinikama
-  async addClinic(patientId: string, clinicId: string): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    await addClinicUtil(this.db, patientId, clinicId, currentUser.uid);
-  }
-
-  async removeClinic(patientId: string, clinicId: string): Promise<void> {
-    await removeClinicUtil(this.db, patientId, clinicId);
-  }
-
-  // Metode za rad sa profilnom slikom
-  /**
-   * Uploads a profile photo for a patient
-   * @param patientId - ID of the patient
-   * @param file - File or Blob to upload
-   * @returns URL of the uploaded photo
-   */
-  async uploadProfilePhoto(patientId: string, file: File | Blob): Promise<string> {
-    console.log(`[PatientService] Uploading profile photo for patient ${patientId}`);
-
-    const mediaMetadata = await this.mediaService.uploadMedia(
-      file,
-      patientId, // Using patientId as ownerId
-      MediaAccessLevel.PRIVATE, // Profile photos should be private
-      'patient_profile_photos',
-      file instanceof File ? file.name : `profile_photo_${patientId}`,
-    );
-
-    // Update the patient sensitive info with the new photo URL
-    await updateDoc(getSensitiveInfoDocRef(this.db, patientId), {
-      photoUrl: mediaMetadata.url,
-      updatedAt: serverTimestamp(),
-    });
-
-    return mediaMetadata.url;
-  }
-
-  /**
-   * Updates a patient's profile photo (replaces existing one)
-   * @param patientId - ID of the patient
-   * @param file - New file or Blob to upload
-   * @returns URL of the new uploaded photo
-   */
-  async updateProfilePhoto(patientId: string, file: File | Blob): Promise<string> {
-    console.log(`[PatientService] Updating profile photo for patient ${patientId}`);
-
-    // Get current patient sensitive info to check for existing photo
-    const currentUser = await this.getCurrentUser();
-    const currentSensitiveInfo = await this.getSensitiveInfo(patientId, currentUser.uid);
-
-    // Delete old photo if it exists and is managed by our MediaService
-    if (currentSensitiveInfo?.photoUrl && typeof currentSensitiveInfo.photoUrl === 'string') {
-      try {
-        const existingMediaMetadata = await this.mediaService.getMediaMetadataByUrl(
-          currentSensitiveInfo.photoUrl,
-        );
-        if (existingMediaMetadata) {
-          await this.mediaService.deleteMedia(existingMediaMetadata.id);
-        }
-      } catch (error) {
-        console.warn(
-          `[PatientService] Could not delete old profile photo for patient ${patientId}:`,
-          error,
-        );
-        // Continue with upload even if deletion fails
-      }
-    }
-
-    // Upload new photo
-    return this.uploadProfilePhoto(patientId, file);
-  }
-
-  /**
-   * Deletes a patient's profile photo
-   * @param patientId - ID of the patient
-   */
-  async deleteProfilePhoto(patientId: string): Promise<void> {
-    console.log(`[PatientService] Deleting profile photo for patient ${patientId}`);
-
-    // Get current patient sensitive info to find the photo URL
-    const currentUser = await this.getCurrentUser();
-    const currentSensitiveInfo = await this.getSensitiveInfo(patientId, currentUser.uid);
-
-    if (currentSensitiveInfo?.photoUrl && typeof currentSensitiveInfo.photoUrl === 'string') {
-      try {
-        const existingMediaMetadata = await this.mediaService.getMediaMetadataByUrl(
-          currentSensitiveInfo.photoUrl,
-        );
-        if (existingMediaMetadata) {
-          await this.mediaService.deleteMedia(existingMediaMetadata.id);
-        }
-      } catch (error) {
-        console.warn(
-          `[PatientService] Could not delete profile photo for patient ${patientId}:`,
-          error,
-        );
-      }
-
-      // Remove photo URL from patient sensitive info
-      await updateDoc(getSensitiveInfoDocRef(this.db, patientId), {
-        photoUrl: null,
-        updatedAt: serverTimestamp(),
-      });
-    }
-  }
-
-  /**
-   * Handles profile photo upload for patients (supports MediaResource)
-   * @param photoUrl - MediaResource (File, Blob, or URL string) from CreatePatientSensitiveInfoData
-   * @param patientId - ID of the patient
-   * @returns URL string of the uploaded or existing photo
-   */
-  private async handleProfilePhotoUpload(
-    photoUrl: MediaResource | undefined,
-    patientId: string,
-  ): Promise<string | undefined> {
-    if (!photoUrl) {
-      return undefined;
-    }
-
-    // If it's already a URL string, return it as is
-    if (typeof photoUrl === 'string') {
-      return photoUrl;
-    }
-
-    // If it's a File or Blob, upload it
-    if (photoUrl instanceof File || photoUrl instanceof Blob) {
-      return this.uploadProfilePhoto(patientId, photoUrl);
-    }
-
-    return undefined;
-  }
-
-  // Metode za ažuriranje profila
-  async updatePatientProfile(
-    patientId: string,
-    data: Partial<Omit<PatientProfile, 'id' | 'createdAt' | 'updatedAt'>>,
-  ): Promise<PatientProfile> {
-    return updatePatientProfileUtil(this.db, patientId, data);
-  }
-
-  async updatePatientProfileByUserRef(
-    userRef: string,
-    data: Partial<Omit<PatientProfile, 'id' | 'createdAt' | 'updatedAt'>>,
-  ): Promise<PatientProfile> {
-    return updatePatientProfileByUserRefUtil(this.db, userRef, data);
-  }
-
-  /**
-   * Searches for patient profiles based on clinic/practitioner association.
-   * Requires information about the requester for security checks.
-   *
-   * @param {SearchPatientsParams} params - The search criteria (clinicId, practitionerId).
-   * @param {RequesterInfo} requester - Information about the user performing the search (ID, role, associated IDs).
-   * @returns {Promise<PatientProfile[]>} A promise resolving to an array of matching patient profiles.
-   */
-  async searchPatients(
-    params: SearchPatientsParams,
-    requester: RequesterInfo,
-  ): Promise<PatientProfile[]> {
-    // We can potentially add more service-level logic here in the future,
-    // like fetching additional data or enriching the results.
-    // For now, we delegate directly to the utility function.
-    console.log(
-      `[PatientService.searchPatients] Initiating search with params:`,
-      params,
-      `by requester:`,
-      requester,
-    );
-
-    // The utility function already handles validation and security checks.
-    return searchPatientsUtil(this.db, params, requester);
-  }
-
-  /**
-   * Gets all patient profiles.
-   *
-   * @param {Object} options - Optional parameters for pagination
-   * @param {number} options.limit - Maximum number of profiles to return
-   * @param {string} options.startAfter - The ID of the document to start after (for pagination)
-   * @returns {Promise<PatientProfile[]>} A promise resolving to an array of all patient profiles.
-   */
-  async getAllPatients(options?: {
-    limit?: number;
-    startAfter?: string;
-  }): Promise<PatientProfile[]> {
-    console.log(`[PatientService.getAllPatients] Fetching patients with options:`, options);
-    return getAllPatientsUtil(this.db, options);
-  }
-
-  /**
-   * Gets all patients associated with a specific practitioner.
-   *
-   * @param {string} practitionerId - ID of the practitioner whose patients to retrieve
-   * @param {Object} options - Optional parameters for pagination
-   * @param {number} options.limit - Maximum number of profiles to return
-   * @param {string} options.startAfter - The ID of the document to start after (for pagination)
-   * @returns {Promise<PatientProfile[]>} A promise resolving to an array of patient profiles
-   */
-  async getPatientsByPractitioner(
-    practitionerId: string,
-    options?: {
-      limit?: number;
-      startAfter?: string;
-    },
-  ): Promise<PatientProfile[]> {
-    console.log(
-      `[PatientService.getPatientsByPractitioner] Fetching patients for practitioner: ${practitionerId}`,
-    );
-    return getPatientsByPractitionerUtil(this.db, practitionerId, options);
-  }
-
-  /**
-   * Gets all patients associated with a specific practitioner with their sensitive information.
-   *
-   * @param {string} practitionerId - ID of the practitioner whose patients to retrieve
-   * @param {Object} options - Optional parameters for pagination
-   * @param {number} options.limit - Maximum number of profiles to return
-   * @param {string} options.startAfter - The ID of the document to start after (for pagination)
-   * @returns {Promise<PatientProfileForDoctor[]>} A promise resolving to an array of patient profiles with sensitive info
-   */
-  async getPatientsByPractitionerWithDetails(
-    practitionerId: string,
-    options?: {
-      limit?: number;
-      startAfter?: string;
-    },
-  ): Promise<PatientProfileForDoctor[]> {
-    console.log(
-      `[PatientService.getPatientsByPractitionerWithDetails] Fetching detailed patient profiles for practitioner: ${practitionerId}`,
-    );
-    return getPatientsByPractitionerWithDetailsUtil(this.db, practitionerId, options);
-  }
-
-  /**
-   * Gets all patients associated with a specific clinic.
-   *
-   * @param {string} clinicId - ID of the clinic whose patients to retrieve
-   * @param {Object} options - Optional parameters for pagination
-   * @param {number} options.limit - Maximum number of profiles to return
-   * @param {string} options.startAfter - The ID of the document to start after (for pagination)
-   * @returns {Promise<PatientProfile[]>} A promise resolving to an array of patient profiles
-   */
-  async getPatientsByClinic(
-    clinicId: string,
-    options?: {
-      limit?: number;
-      startAfter?: string;
-    },
-  ): Promise<PatientProfile[]> {
-    console.log(`[PatientService.getPatientsByClinic] Fetching patients for clinic: ${clinicId}`);
-    return getPatientsByClinicUtil(this.db, clinicId, options);
-  }
-
-  /**
-   * Creates a token for inviting a patient to claim their profile.
-   *
-   * @param {CreatePatientTokenData} data - Data for creating the token.
-   * @param {string} createdBy - ID of the admin user creating the token.
-   * @returns {Promise<PatientToken>} The created token.
-   */
-  async createPatientToken(data: CreatePatientTokenData, createdBy: string): Promise<PatientToken> {
-    // We assume the 'createdBy' user is validated to be a clinic admin
-    // in the calling context (e.g., a cloud function or API endpoint).
-    return createPatientTokenUtil(
-      this.db,
-      data,
-      createdBy,
-      () => this.generateId(), // Pass the ID generation function
-    );
-  }
-
-  /**
-   * Validates a patient invitation token.
-   *
-   * @param {string} tokenString - The token string to validate.
-   * @returns {Promise<PatientToken | null>} The token if found and valid, otherwise null.
-   */
-  async validatePatientToken(tokenString: string): Promise<PatientToken | null> {
-    return validatePatientTokenUtil(this.db, tokenString);
-  }
-
-  /**
-   * Marks a patient invitation token as used.
-   *
-   * @param {string} tokenId - The ID of the token to mark as used.
-   * @param {string} patientId - The ID of the patient associated with the token.
-   * @param {string} userId - The ID of the user who is using the token.
-   * @returns {Promise<void>}
-   */
-  async markPatientTokenAsUsed(tokenId: string, patientId: string, userId: string): Promise<void> {
-    return markPatientTokenAsUsedUtil(this.db, tokenId, patientId, userId);
-  }
-
-  /**
-   * Retrieves all active invitation tokens for a specific clinic.
-   * NOTE: This should be protected and only exposed to authorized clinic admins.
-   *
-   * @param {string} clinicId - The ID of the clinic.
-   * @returns {Promise<PatientToken[]>} An array of active tokens for the clinic.
-   */
-  async getActiveInviteTokensByClinic(clinicId: string): Promise<PatientToken[]> {
-    return getActiveInviteTokensByClinicUtil(this.db, clinicId);
-  }
-
-  /**
-   * Retrieves all active invitation tokens for a specific patient.
-   * NOTE: This should be protected and only exposed to authorized clinic admins.
-   *
-   * @param {string} patientId - The ID of the patient.
-   * @returns {Promise<PatientToken[]>} An array of active tokens for the patient.
-   */
-  async getActiveInviteTokensByPatient(patientId: string): Promise<PatientToken[]> {
-    // Security check should be done in the calling context to ensure
-    // the admin has permission to view this patient's tokens.
-    return getActiveInviteTokensByPatientUtil(this.db, patientId);
-  }
-
-  async getAestheticAnalysis(patientId: string): Promise<AestheticAnalysis | null> {
-    const currentUser = await this.getCurrentUser();
-    return getAestheticAnalysisUtil(this.db, patientId, currentUser.uid, currentUser.roles);
-  }
-
-  async createAestheticAnalysis(
-    patientId: string,
-    data: CreateAestheticAnalysisData
-  ): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    return createOrUpdateAestheticAnalysisUtil(
-      this.db,
-      patientId,
-      data,
-      currentUser.uid,
-      currentUser.roles,
-      false
-    );
-  }
-
-  async updateAestheticAnalysis(
-    patientId: string,
-    data: UpdateAestheticAnalysisData
-  ): Promise<void> {
-    const currentUser = await this.getCurrentUser();
-    return createOrUpdateAestheticAnalysisUtil(
-      this.db,
-      patientId,
-      data,
-      currentUser.uid,
-      currentUser.roles,
-      true
-    );
-  }
-}
+import {
+  doc,
+  getDoc,
+  writeBatch,
+  updateDoc,
+  arrayUnion,
+  serverTimestamp,
+} from 'firebase/firestore';
+import { BaseService } from '../base.service';
+import { MediaService, MediaAccessLevel, MediaResource } from '../media/media.service';
+import {
+  PatientProfile,
+  PatientSensitiveInfo,
+  PatientLocationInfo,
+  CreatePatientProfileData,
+  CreatePatientSensitiveInfoData,
+  UpdatePatientSensitiveInfoData,
+  CreatePatientLocationInfoData,
+  UpdatePatientLocationInfoData,
+  PatientMedicalInfo,
+  CreatePatientMedicalInfoData,
+  UpdateVitalStatsData,
+  AddAllergyData,
+  UpdateAllergyData,
+  AddBlockingConditionData,
+  UpdateBlockingConditionData,
+  AddContraindicationData,
+  UpdateContraindicationData,
+  AddMedicationData,
+  UpdateMedicationData,
+  PatientDoctor,
+  PatientClinic,
+  SearchPatientsParams,
+  RequesterInfo,
+  PatientProfileForDoctor,
+  CreateManualPatientData,
+} from '../../types/patient';
+import { Auth } from 'firebase/auth';
+import { Firestore } from 'firebase/firestore';
+import { FirebaseApp } from 'firebase/app';
+import { Timestamp } from 'firebase/firestore';
+
+// Importujemo utility funkcije
+import {
+  createPatientProfileUtil,
+  getPatientProfileUtil,
+  getPatientProfileByUserRefUtil,
+  addExpoTokenUtil,
+  removeExpoTokenUtil,
+  addPointsUtil,
+  updatePatientProfileUtil,
+  updatePatientProfileByUserRefUtil,
+  searchPatientsUtil,
+  getAllPatientsUtil,
+  updatePatientLocationUtil,
+  createLocationInfoUtil,
+  getLocationInfoUtil,
+  updateLocationInfoUtil,
+  createSensitiveInfoUtil,
+  getSensitiveInfoUtil,
+  updateSensitiveInfoUtil,
+  claimPatientSensitiveInfoUtil,
+  createMedicalInfoUtil,
+  getMedicalInfoUtil,
+  updateVitalStatsUtil,
+  addAllergyUtil,
+  updateAllergyUtil,
+  removeAllergyUtil,
+  addBlockingConditionUtil,
+  updateBlockingConditionUtil,
+  removeBlockingConditionUtil,
+  addContraindicationUtil,
+  updateContraindicationUtil,
+  removeContraindicationUtil,
+  addMedicationUtil,
+  updateMedicationUtil,
+  removeMedicationUtil,
+  getPatientDocRef,
+  getSensitiveInfoDocRef,
+  getLocationInfoDocRef,
+  getMedicalInfoDocRef,
+  addDoctorUtil,
+  removeDoctorUtil,
+  addClinicUtil,
+  removeClinicUtil,
+  getPatientsByPractitionerUtil,
+  getPatientsByPractitionerWithDetailsUtil,
+  getPatientsByClinicUtil,
+  createPatientTokenUtil,
+  validatePatientTokenUtil,
+  markPatientTokenAsUsedUtil,
+  getActiveInviteTokensByClinicUtil,
+  getActiveInviteTokensByPatientUtil,
+} from './utils';
+
+import {
+  getAestheticAnalysisUtil,
+  createOrUpdateAestheticAnalysisUtil,
+} from './utils/aesthetic-analysis.utils';
+
+import {
+  AestheticAnalysis,
+  CreateAestheticAnalysisData,
+  UpdateAestheticAnalysisData,
+} from '../../types/patient';
+
+import { CreatePatientTokenData, PatientToken } from '../../types/patient/token.types';
+
+export class PatientService extends BaseService {
+  private mediaService: MediaService;
+
+  constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
+    super(db, auth, app);
+    this.mediaService = new MediaService(db, auth, app);
+  }
+
+  // Metode za rad sa profilom pacijenta
+  async createPatientProfile(data: CreatePatientProfileData): Promise<PatientProfile> {
+    return createPatientProfileUtil(this.db, data, () => this.generateId());
+  }
+
+  async getPatientProfile(patientId: string): Promise<PatientProfile | null> {
+    return getPatientProfileUtil(this.db, patientId);
+  }
+
+  /**
+   * Manually creates a new patient profile, typically initiated by a clinic admin.
+   * This creates a patient record that is not initially linked to an authenticated user.
+   *
+   * @param {CreateManualPatientData} data - The data for the new patient.
+   * @param {RequesterInfo} requester - Information about the user creating the patient (must be a clinic admin).
+   * @returns {Promise<PatientProfile>} The newly created patient profile.
+   * @throws {Error} If the requester is not a valid clinic admin.
+   */
+  async createManualPatient(
+    data: CreateManualPatientData,
+    requester: RequesterInfo,
+  ): Promise<PatientProfile> {
+    console.log(
+      `[PatientService.createManualPatient] Attempting to create manual patient by requester:`,
+      requester,
+    );
+
+    // Security Check: Ensure the requester is a clinic admin
+    if (
+      requester.role !== 'clinic_admin' ||
+      !requester.associatedClinicId ||
+      requester.associatedClinicId !== data.clinicId
+    ) {
+      throw new Error(
+        'Unauthorized: Requester must be a clinic admin and can only add patients to their own clinic.',
+      );
+    }
+
+    const patientId = this.generateId();
+    const batch = writeBatch(this.db);
+    const now = Timestamp.now();
+
+    // 1. Create Patient Profile
+    const patientProfileRef = getPatientDocRef(this.db, patientId);
+    const newProfile: PatientProfile = {
+      id: patientId,
+      displayName: `${data.firstName} ${data.lastName.charAt(0)}.`,
+      expoTokens: [],
+      gamification: { level: 1, points: 0 },
+      isActive: true,
+      isVerified: false, // Manual profiles are not verified by default
+      isManual: true,
+      doctors: [],
+      clinics: [
+        {
+          clinicId: data.clinicId,
+          assignedAt: now,
+          assignedBy: requester.id,
+          isActive: true,
+          notes: data.notes,
+        },
+      ],
+      doctorIds: [],
+      clinicIds: [data.clinicId],
+      createdAt: now,
+      updatedAt: now,
+      phoneNumber: data.phoneNumber,
+      dateOfBirth: data.dateOfBirth,
+    };
+    batch.set(patientProfileRef, newProfile);
+
+    // 2. Create Patient Sensitive Info
+    const sensitiveInfoRef = getSensitiveInfoDocRef(this.db, patientId);
+    const newSensitiveInfo: Omit<PatientSensitiveInfo, 'photoUrl'> = {
+      patientId,
+      firstName: data.firstName,
+      lastName: data.lastName,
+      dateOfBirth: data.dateOfBirth,
+      gender: data.gender,
+      email: data.email,
+      phoneNumber: data.phoneNumber,
+      addressData: data.addressData,
+      emergencyContacts: [],
+      createdAt: now,
+      updatedAt: now,
+    };
+    batch.set(sensitiveInfoRef, newSensitiveInfo);
+
+    // 3. Create Patient Medical Info
+    const medicalInfoRef = getMedicalInfoDocRef(this.db, patientId);
+    const newMedicalInfo: PatientMedicalInfo = {
+      patientId,
+      vitalStats: {},
+      blockingConditions: [],
+      contraindications: [],
+      allergies: [],
+      currentMedications: [],
+      emergencyNotes: '',
+      lastUpdated: now,
+      updatedBy: requester.id, // The admin who created the record
+    };
+    batch.set(medicalInfoRef, newMedicalInfo);
+
+    await batch.commit();
+
+    console.log(
+      `[PatientService.createManualPatient] Successfully created manual patient with ID: ${patientId}`,
+    );
+
+    return newProfile;
+  }
+
+  async getPatientProfileByUserRef(userRef: string): Promise<PatientProfile | null> {
+    return getPatientProfileByUserRefUtil(this.db, userRef);
+  }
+
+  // Metode za rad sa lokacijskim podacima
+  async updatePatientLocation(
+    patientId: string,
+    latitude: number,
+    longitude: number,
+  ): Promise<void> {
+    await updatePatientLocationUtil(this.db, patientId, latitude, longitude);
+  }
+
+  async updatePatientLocationByUserRef(
+    userRef: string,
+    latitude: number,
+    longitude: number,
+  ): Promise<void> {
+    const profile = await this.getPatientProfileByUserRef(userRef);
+    if (!profile) throw new Error('Patient profile not found');
+    await this.updatePatientLocation(profile.id, latitude, longitude);
+  }
+
+  async createLocationInfo(
+    data: CreatePatientLocationInfoData,
+    requesterId: string,
+  ): Promise<PatientLocationInfo> {
+    return createLocationInfoUtil(this.db, data, requesterId);
+  }
+
+  async getLocationInfo(
+    patientId: string,
+    requesterId: string,
+  ): Promise<PatientLocationInfo | null> {
+    return getLocationInfoUtil(this.db, patientId, requesterId);
+  }
+
+  async getLocationInfoByUserRef(
+    userRef: string,
+    requesterId: string,
+  ): Promise<PatientLocationInfo | null> {
+    const profile = await this.getPatientProfileByUserRef(userRef);
+    if (!profile) return null;
+    return this.getLocationInfo(profile.id, requesterId);
+  }
+
+  async updateLocationInfo(
+    patientId: string,
+    data: UpdatePatientLocationInfoData,
+    requesterId: string,
+  ): Promise<PatientLocationInfo> {
+    return updateLocationInfoUtil(this.db, patientId, data, requesterId);
+  }
+
+  // Metode za rad sa osetljivim informacijama
+  async createSensitiveInfo(
+    data: CreatePatientSensitiveInfoData,
+    requesterUserId: string,
+  ): Promise<PatientSensitiveInfo> {
+    const currentUser = await this.getCurrentUser();
+    if (currentUser.uid !== requesterUserId) {
+      throw new Error('Requester does not match authenticated user.');
+    }
+
+    return createSensitiveInfoUtil(
+      this.db,
+      data,
+      requesterUserId,
+      currentUser.roles,
+      this.mediaService,
+    );
+  }
+
+  async getSensitiveInfo(
+    patientId: string,
+    requesterUserId: string,
+  ): Promise<PatientSensitiveInfo | null> {
+    const currentUser = await this.getCurrentUser();
+    if (currentUser.uid !== requesterUserId) {
+      // Allow for read-only access if authorized, but for now we check identity
+      // This could be expanded later based on practitioner/admin roles
+    }
+    return getSensitiveInfoUtil(this.db, patientId, requesterUserId, currentUser.roles);
+  }
+
+  async getSensitiveInfoByUserRef(
+    userRef: string,
+    requesterUserId: string,
+  ): Promise<PatientSensitiveInfo | null> {
+    const profile = await this.getPatientProfileByUserRef(userRef);
+    if (!profile) return null;
+    // We pass requesterUserId which is the UID of the one asking.
+    return this.getSensitiveInfo(profile.id, requesterUserId);
+  }
+
+  async updateSensitiveInfo(
+    patientId: string,
+    data: UpdatePatientSensitiveInfoData,
+    requesterUserId: string,
+  ): Promise<PatientSensitiveInfo> {
+    const currentUser = await this.getCurrentUser();
+    if (currentUser.uid !== requesterUserId) {
+      throw new Error('Requester does not match authenticated user.');
+    }
+    return updateSensitiveInfoUtil(
+      this.db,
+      patientId,
+      data,
+      requesterUserId,
+      currentUser.roles,
+      this.mediaService,
+    );
+  }
+
+  async claimPatientSensitiveInfo(
+    patientId: string,
+    userId: string,
+  ): Promise<PatientSensitiveInfo> {
+    return claimPatientSensitiveInfoUtil(this.db, patientId, userId);
+  }
+
+  // Metode za rad sa medicinskim informacijama
+  async createMedicalInfo(patientId: string, data: CreatePatientMedicalInfoData): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    await createMedicalInfoUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
+  }
+
+  async getMedicalInfo(patientId: string): Promise<PatientMedicalInfo> {
+    const currentUser = await this.getCurrentUser();
+    return getMedicalInfoUtil(this.db, patientId, currentUser.uid, currentUser.roles);
+  }
+
+  async getMedicalInfoByUserRef(userRef: string): Promise<PatientMedicalInfo> {
+    const profile = await this.getPatientProfileByUserRef(userRef);
+    if (!profile) throw new Error('Patient profile not found');
+    return this.getMedicalInfo(profile.id);
+  }
+
+  // Metode za rad sa vitalnim statistikama
+  async updateVitalStats(patientId: string, data: UpdateVitalStatsData): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    await updateVitalStatsUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
+  }
+
+  // Metode za rad sa alergijama
+  async addAllergy(patientId: string, data: AddAllergyData): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    await addAllergyUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
+  }
+
+  async updateAllergy(patientId: string, data: UpdateAllergyData): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    await updateAllergyUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
+  }
+
+  async removeAllergy(patientId: string, allergyIndex: number): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    await removeAllergyUtil(this.db, patientId, allergyIndex, currentUser.uid, currentUser.roles);
+  }
+
+  // Metode za rad sa blocking conditions
+  async addBlockingCondition(patientId: string, data: AddBlockingConditionData): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    await addBlockingConditionUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
+  }
+
+  async updateBlockingCondition(
+    patientId: string,
+    data: UpdateBlockingConditionData,
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    await updateBlockingConditionUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
+  }
+
+  async removeBlockingCondition(patientId: string, conditionIndex: number): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    await removeBlockingConditionUtil(
+      this.db,
+      patientId,
+      conditionIndex,
+      currentUser.uid,
+      currentUser.roles,
+    );
+  }
+
+  // Metode za rad sa kontraindikacijama
+  async addContraindication(patientId: string, data: AddContraindicationData): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    await addContraindicationUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
+  }
+
+  async updateContraindication(patientId: string, data: UpdateContraindicationData): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    await updateContraindicationUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
+  }
+
+  async removeContraindication(patientId: string, contraindicationIndex: number): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    await removeContraindicationUtil(
+      this.db,
+      patientId,
+      contraindicationIndex,
+      currentUser.uid,
+      currentUser.roles,
+    );
+  }
+
+  // Metode za rad sa medikacijama
+  async addMedication(patientId: string, data: AddMedicationData): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    await addMedicationUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
+  }
+
+  async updateMedication(patientId: string, data: UpdateMedicationData): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    await updateMedicationUtil(this.db, patientId, data, currentUser.uid, currentUser.roles);
+  }
+
+  async removeMedication(patientId: string, medicationIndex: number): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    await removeMedicationUtil(
+      this.db,
+      patientId,
+      medicationIndex,
+      currentUser.uid,
+      currentUser.roles,
+    );
+  }
+
+  // Pomoćne metode
+  async addExpoToken(patientId: string, token: string): Promise<void> {
+    await addExpoTokenUtil(this.db, patientId, token);
+  }
+
+  async addExpoTokenByUserRef(userRef: string, token: string): Promise<void> {
+    const profile = await this.getPatientProfileByUserRef(userRef);
+    if (!profile) throw new Error('Patient profile not found');
+    await this.addExpoToken(profile.id, token);
+  }
+
+  async removeExpoToken(patientId: string, token: string): Promise<void> {
+    await removeExpoTokenUtil(this.db, patientId, token);
+  }
+
+  async removeExpoTokenByUserRef(userRef: string, token: string): Promise<void> {
+    const profile = await this.getPatientProfileByUserRef(userRef);
+    if (!profile) throw new Error('Patient profile not found');
+    await this.removeExpoToken(profile.id, token);
+  }
+
+  async addPoints(patientId: string, points: number): Promise<void> {
+    await addPointsUtil(this.db, patientId, points);
+  }
+
+  async addPointsByUserRef(userRef: string, points: number): Promise<void> {
+    const profile = await this.getPatientProfileByUserRef(userRef);
+    if (!profile) throw new Error('Patient profile not found');
+    await this.addPoints(profile.id, points);
+  }
+
+  private async getCurrentUser(): Promise<any> {
+    if (!this.auth.currentUser) {
+      throw new Error('No authenticated user');
+    }
+    const userDoc = await getDoc(doc(this.db, 'users', this.auth.currentUser.uid));
+    if (!userDoc.exists()) {
+      throw new Error('User not found');
+    }
+    return userDoc.data();
+  }
+
+  /**
+   * Briše profil pacijenta i sve povezane subkolekcije
+   */
+  async deletePatientProfile(patientId: string): Promise<void> {
+    const batch = writeBatch(this.db);
+
+    // Brisanje sensitive info
+    batch.delete(getSensitiveInfoDocRef(this.db, patientId));
+
+    // Brisanje location info
+    batch.delete(getLocationInfoDocRef(this.db, patientId));
+
+    // Brisanje medical info
+    batch.delete(getMedicalInfoDocRef(this.db, patientId));
+
+    // Brisanje glavnog profila
+    batch.delete(getPatientDocRef(this.db, patientId));
+
+    await batch.commit();
+  }
+
+  // Metode za rad sa doktorima
+  async addDoctor(patientId: string, doctorRef: string): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    await addDoctorUtil(this.db, patientId, doctorRef, currentUser.uid);
+  }
+
+  async removeDoctor(patientId: string, doctorRef: string): Promise<void> {
+    await removeDoctorUtil(this.db, patientId, doctorRef);
+  }
+
+  // Metode za rad sa klinikama
+  async addClinic(patientId: string, clinicId: string): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    await addClinicUtil(this.db, patientId, clinicId, currentUser.uid);
+  }
+
+  async removeClinic(patientId: string, clinicId: string): Promise<void> {
+    await removeClinicUtil(this.db, patientId, clinicId);
+  }
+
+  // Metode za rad sa profilnom slikom
+  /**
+   * Uploads a profile photo for a patient
+   * @param patientId - ID of the patient
+   * @param file - File or Blob to upload
+   * @returns URL of the uploaded photo
+   */
+  async uploadProfilePhoto(patientId: string, file: File | Blob): Promise<string> {
+    console.log(`[PatientService] Uploading profile photo for patient ${patientId}`);
+
+    const mediaMetadata = await this.mediaService.uploadMedia(
+      file,
+      patientId, // Using patientId as ownerId
+      MediaAccessLevel.PRIVATE, // Profile photos should be private
+      'patient_profile_photos',
+      file instanceof File ? file.name : `profile_photo_${patientId}`,
+    );
+
+    // Update the patient sensitive info with the new photo URL
+    await updateDoc(getSensitiveInfoDocRef(this.db, patientId), {
+      photoUrl: mediaMetadata.url,
+      updatedAt: serverTimestamp(),
+    });
+
+    return mediaMetadata.url;
+  }
+
+  /**
+   * Updates a patient's profile photo (replaces existing one)
+   * @param patientId - ID of the patient
+   * @param file - New file or Blob to upload
+   * @returns URL of the new uploaded photo
+   */
+  async updateProfilePhoto(patientId: string, file: File | Blob): Promise<string> {
+    console.log(`[PatientService] Updating profile photo for patient ${patientId}`);
+
+    // Get current patient sensitive info to check for existing photo
+    const currentUser = await this.getCurrentUser();
+    const currentSensitiveInfo = await this.getSensitiveInfo(patientId, currentUser.uid);
+
+    // Delete old photo if it exists and is managed by our MediaService
+    if (currentSensitiveInfo?.photoUrl && typeof currentSensitiveInfo.photoUrl === 'string') {
+      try {
+        const existingMediaMetadata = await this.mediaService.getMediaMetadataByUrl(
+          currentSensitiveInfo.photoUrl,
+        );
+        if (existingMediaMetadata) {
+          await this.mediaService.deleteMedia(existingMediaMetadata.id);
+        }
+      } catch (error) {
+        console.warn(
+          `[PatientService] Could not delete old profile photo for patient ${patientId}:`,
+          error,
+        );
+        // Continue with upload even if deletion fails
+      }
+    }
+
+    // Upload new photo
+    return this.uploadProfilePhoto(patientId, file);
+  }
+
+  /**
+   * Deletes a patient's profile photo
+   * @param patientId - ID of the patient
+   */
+  async deleteProfilePhoto(patientId: string): Promise<void> {
+    console.log(`[PatientService] Deleting profile photo for patient ${patientId}`);
+
+    // Get current patient sensitive info to find the photo URL
+    const currentUser = await this.getCurrentUser();
+    const currentSensitiveInfo = await this.getSensitiveInfo(patientId, currentUser.uid);
+
+    if (currentSensitiveInfo?.photoUrl && typeof currentSensitiveInfo.photoUrl === 'string') {
+      try {
+        const existingMediaMetadata = await this.mediaService.getMediaMetadataByUrl(
+          currentSensitiveInfo.photoUrl,
+        );
+        if (existingMediaMetadata) {
+          await this.mediaService.deleteMedia(existingMediaMetadata.id);
+        }
+      } catch (error) {
+        console.warn(
+          `[PatientService] Could not delete profile photo for patient ${patientId}:`,
+          error,
+        );
+      }
+
+      // Remove photo URL from patient sensitive info
+      await updateDoc(getSensitiveInfoDocRef(this.db, patientId), {
+        photoUrl: null,
+        updatedAt: serverTimestamp(),
+      });
+    }
+  }
+
+  /**
+   * Handles profile photo upload for patients (supports MediaResource)
+   * @param photoUrl - MediaResource (File, Blob, or URL string) from CreatePatientSensitiveInfoData
+   * @param patientId - ID of the patient
+   * @returns URL string of the uploaded or existing photo
+   */
+  private async handleProfilePhotoUpload(
+    photoUrl: MediaResource | undefined,
+    patientId: string,
+  ): Promise<string | undefined> {
+    if (!photoUrl) {
+      return undefined;
+    }
+
+    // If it's already a URL string, return it as is
+    if (typeof photoUrl === 'string') {
+      return photoUrl;
+    }
+
+    // If it's a File or Blob, upload it
+    if (photoUrl instanceof File || photoUrl instanceof Blob) {
+      return this.uploadProfilePhoto(patientId, photoUrl);
+    }
+
+    return undefined;
+  }
+
+  // Metode za ažuriranje profila
+  async updatePatientProfile(
+    patientId: string,
+    data: Partial<Omit<PatientProfile, 'id' | 'createdAt' | 'updatedAt'>>,
+  ): Promise<PatientProfile> {
+    return updatePatientProfileUtil(this.db, patientId, data);
+  }
+
+  async updatePatientProfileByUserRef(
+    userRef: string,
+    data: Partial<Omit<PatientProfile, 'id' | 'createdAt' | 'updatedAt'>>,
+  ): Promise<PatientProfile> {
+    return updatePatientProfileByUserRefUtil(this.db, userRef, data);
+  }
+
+  /**
+   * Searches for patient profiles based on clinic/practitioner association.
+   * Requires information about the requester for security checks.
+   *
+   * @param {SearchPatientsParams} params - The search criteria (clinicId, practitionerId).
+   * @param {RequesterInfo} requester - Information about the user performing the search (ID, role, associated IDs).
+   * @returns {Promise<PatientProfile[]>} A promise resolving to an array of matching patient profiles.
+   */
+  async searchPatients(
+    params: SearchPatientsParams,
+    requester: RequesterInfo,
+  ): Promise<PatientProfile[]> {
+    // We can potentially add more service-level logic here in the future,
+    // like fetching additional data or enriching the results.
+    // For now, we delegate directly to the utility function.
+    console.log(
+      `[PatientService.searchPatients] Initiating search with params:`,
+      params,
+      `by requester:`,
+      requester,
+    );
+
+    // The utility function already handles validation and security checks.
+    return searchPatientsUtil(this.db, params, requester);
+  }
+
+  /**
+   * Gets all patient profiles.
+   *
+   * @param {Object} options - Optional parameters for pagination
+   * @param {number} options.limit - Maximum number of profiles to return
+   * @param {string} options.startAfter - The ID of the document to start after (for pagination)
+   * @returns {Promise<PatientProfile[]>} A promise resolving to an array of all patient profiles.
+   */
+  async getAllPatients(options?: {
+    limit?: number;
+    startAfter?: string;
+  }): Promise<PatientProfile[]> {
+    console.log(`[PatientService.getAllPatients] Fetching patients with options:`, options);
+    return getAllPatientsUtil(this.db, options);
+  }
+
+  /**
+   * Gets all patients associated with a specific practitioner.
+   *
+   * @param {string} practitionerId - ID of the practitioner whose patients to retrieve
+   * @param {Object} options - Optional parameters for pagination
+   * @param {number} options.limit - Maximum number of profiles to return
+   * @param {string} options.startAfter - The ID of the document to start after (for pagination)
+   * @returns {Promise<PatientProfile[]>} A promise resolving to an array of patient profiles
+   */
+  async getPatientsByPractitioner(
+    practitionerId: string,
+    options?: {
+      limit?: number;
+      startAfter?: string;
+    },
+  ): Promise<PatientProfile[]> {
+    console.log(
+      `[PatientService.getPatientsByPractitioner] Fetching patients for practitioner: ${practitionerId}`,
+    );
+    return getPatientsByPractitionerUtil(this.db, practitionerId, options);
+  }
+
+  /**
+   * Gets all patients associated with a specific practitioner with their sensitive information.
+   *
+   * @param {string} practitionerId - ID of the practitioner whose patients to retrieve
+   * @param {Object} options - Optional parameters for pagination
+   * @param {number} options.limit - Maximum number of profiles to return
+   * @param {string} options.startAfter - The ID of the document to start after (for pagination)
+   * @returns {Promise<PatientProfileForDoctor[]>} A promise resolving to an array of patient profiles with sensitive info
+   */
+  async getPatientsByPractitionerWithDetails(
+    practitionerId: string,
+    options?: {
+      limit?: number;
+      startAfter?: string;
+    },
+  ): Promise<PatientProfileForDoctor[]> {
+    console.log(
+      `[PatientService.getPatientsByPractitionerWithDetails] Fetching detailed patient profiles for practitioner: ${practitionerId}`,
+    );
+    return getPatientsByPractitionerWithDetailsUtil(this.db, practitionerId, options);
+  }
+
+  /**
+   * Gets all patients associated with a specific clinic.
+   *
+   * @param {string} clinicId - ID of the clinic whose patients to retrieve
+   * @param {Object} options - Optional parameters for pagination
+   * @param {number} options.limit - Maximum number of profiles to return
+   * @param {string} options.startAfter - The ID of the document to start after (for pagination)
+   * @returns {Promise<PatientProfile[]>} A promise resolving to an array of patient profiles
+   */
+  async getPatientsByClinic(
+    clinicId: string,
+    options?: {
+      limit?: number;
+      startAfter?: string;
+    },
+  ): Promise<PatientProfile[]> {
+    console.log(`[PatientService.getPatientsByClinic] Fetching patients for clinic: ${clinicId}`);
+    return getPatientsByClinicUtil(this.db, clinicId, options);
+  }
+
+  /**
+   * Creates a token for inviting a patient to claim their profile.
+   *
+   * @param {CreatePatientTokenData} data - Data for creating the token.
+   * @param {string} createdBy - ID of the admin user creating the token.
+   * @returns {Promise<PatientToken>} The created token.
+   */
+  async createPatientToken(data: CreatePatientTokenData, createdBy: string): Promise<PatientToken> {
+    // We assume the 'createdBy' user is validated to be a clinic admin
+    // in the calling context (e.g., a cloud function or API endpoint).
+    return createPatientTokenUtil(
+      this.db,
+      data,
+      createdBy,
+      () => this.generateId(), // Pass the ID generation function
+    );
+  }
+
+  /**
+   * Validates a patient invitation token.
+   *
+   * @param {string} tokenString - The token string to validate.
+   * @returns {Promise<PatientToken | null>} The token if found and valid, otherwise null.
+   */
+  async validatePatientToken(tokenString: string): Promise<PatientToken | null> {
+    return validatePatientTokenUtil(this.db, tokenString);
+  }
+
+  /**
+   * Marks a patient invitation token as used.
+   *
+   * @param {string} tokenId - The ID of the token to mark as used.
+   * @param {string} patientId - The ID of the patient associated with the token.
+   * @param {string} userId - The ID of the user who is using the token.
+   * @returns {Promise<void>}
+   */
+  async markPatientTokenAsUsed(tokenId: string, patientId: string, userId: string): Promise<void> {
+    return markPatientTokenAsUsedUtil(this.db, tokenId, patientId, userId);
+  }
+
+  /**
+   * Retrieves all active invitation tokens for a specific clinic.
+   * NOTE: This should be protected and only exposed to authorized clinic admins.
+   *
+   * @param {string} clinicId - The ID of the clinic.
+   * @returns {Promise<PatientToken[]>} An array of active tokens for the clinic.
+   */
+  async getActiveInviteTokensByClinic(clinicId: string): Promise<PatientToken[]> {
+    return getActiveInviteTokensByClinicUtil(this.db, clinicId);
+  }
+
+  /**
+   * Retrieves all active invitation tokens for a specific patient.
+   * NOTE: This should be protected and only exposed to authorized clinic admins.
+   *
+   * @param {string} patientId - The ID of the patient.
+   * @returns {Promise<PatientToken[]>} An array of active tokens for the patient.
+   */
+  async getActiveInviteTokensByPatient(patientId: string): Promise<PatientToken[]> {
+    // Security check should be done in the calling context to ensure
+    // the admin has permission to view this patient's tokens.
+    return getActiveInviteTokensByPatientUtil(this.db, patientId);
+  }
+
+  async getAestheticAnalysis(patientId: string): Promise<AestheticAnalysis | null> {
+    const currentUser = await this.getCurrentUser();
+    return getAestheticAnalysisUtil(this.db, patientId, currentUser.uid, currentUser.roles);
+  }
+
+  async createAestheticAnalysis(
+    patientId: string,
+    data: CreateAestheticAnalysisData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdateAestheticAnalysisUtil(
+      this.db,
+      patientId,
+      data,
+      currentUser.uid,
+      currentUser.roles,
+      false
+    );
+  }
+
+  async updateAestheticAnalysis(
+    patientId: string,
+    data: UpdateAestheticAnalysisData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdateAestheticAnalysisUtil(
+      this.db,
+      patientId,
+      data,
+      currentUser.uid,
+      currentUser.roles,
+      true
+    );
+  }
+}