@blackcode_sa/metaestetics-api 1.13.5 → 1.13.6

package/src/services/clinic/clinic.service.ts

@@ -1,708 +1,708 @@
-import {
-  collection,
-  doc,
-  getDoc,
-  getDocs,
-  query,
-  where,
-  updateDoc,
-  setDoc,
-  deleteDoc,
-  Timestamp,
-  serverTimestamp,
-  GeoPoint,
-  QueryConstraint,
-  FieldValue,
-  writeBatch,
-  arrayUnion,
-  arrayRemove,
-} from "firebase/firestore";
-import { getFunctions, httpsCallable } from "firebase/functions";
-import tzlookup from "tz-lookup";
-import { BaseService } from "../base.service";
-import {
-  Clinic,
-  CreateClinicData,
-  CLINICS_COLLECTION,
-  ClinicTag,
-  ClinicTags,
-  ClinicGroup,
-  CLINIC_GROUPS_COLLECTION,
-  ClinicBranchSetupData,
-  CLINIC_ADMINS_COLLECTION,
-  DoctorInfo,
-} from "../../types/clinic";
-// Correct imports
-import { ProcedureSummaryInfo } from "../../types/procedure";
-import { ClinicInfo } from "../../types/profile";
-import { ClinicGroupService } from "./clinic-group.service";
-import { ClinicAdminService } from "./clinic-admin.service";
-import {
-  geohashForLocation,
-  geohashQueryBounds,
-  distanceBetween,
-} from "geofire-common";
-import {
-  clinicSchema,
-  createClinicSchema,
-  updateClinicSchema,
-  clinicBranchSetupSchema,
-} from "../../validations/clinic.schema";
-import { z } from "zod";
-import { Auth } from "firebase/auth";
-import { Firestore } from "firebase/firestore";
-import { FirebaseApp } from "firebase/app";
-import * as ClinicUtils from "./utils/clinic.utils";
-import * as TagUtils from "./utils/tag.utils";
-import * as SearchUtils from "./utils/search.utils";
-import * as AdminUtils from "./utils/admin.utils";
-import * as FilterUtils from "./utils/filter.utils";
-import { ClinicReviewInfo } from "../../types/reviews";
-import { PRACTITIONERS_COLLECTION } from "../../types/practitioner";
-import { MediaService, MediaAccessLevel } from "../media/media.service";
-
-export class ClinicService extends BaseService {
-  private clinicGroupService: ClinicGroupService;
-  private clinicAdminService: ClinicAdminService;
-  private mediaService: MediaService;
-  private functions: any;
-
-  constructor(
-    db: Firestore,
-    auth: Auth,
-    app: FirebaseApp,
-    clinicGroupService: ClinicGroupService,
-    clinicAdminService: ClinicAdminService,
-    mediaService: MediaService
-  ) {
-    super(db, auth, app);
-    this.clinicAdminService = clinicAdminService;
-    this.clinicGroupService = clinicGroupService;
-    this.mediaService = mediaService;
-    this.functions = getFunctions(app, "europe-west6"); // All functions now in europe-west6
-  }
-
-  /**
-   * Get timezone from coordinates using tz-lookup library
-   * @param lat Latitude
-   * @param lng Longitude
-   * @returns IANA timezone string
-   */
-  private getTimezone(lat: number, lng: number): string | null {
-    try {
-      const timezone = tzlookup(lat, lng);
-      return timezone || null;
-    } catch (error) {
-      console.error("[CLINIC_SERVICE] Error getting timezone:", error);
-      return null;
-    }
-  }
-
-  /**
-   * Process media resource (string URL or File object)
-   * @param media String URL or File object
-   * @param ownerId Owner ID for the media (usually clinicId)
-   * @param collectionName Collection name for organizing files
-   * @returns URL string after processing
-   */
-  private async processMedia(
-    media: string | File | Blob | null | undefined,
-    ownerId: string,
-    collectionName: string
-  ): Promise<string | null> {
-    if (!media) return null;
-
-    // If already a string URL, return it directly
-    if (typeof media === "string") {
-      return media;
-    }
-
-    // If it's a File, upload it using MediaService
-    if (media instanceof File || media instanceof Blob) {
-      console.log(
-        `[ClinicService] Uploading ${collectionName} media for ${ownerId}`
-      );
-      const metadata = await this.mediaService.uploadMedia(
-        media,
-        ownerId,
-        MediaAccessLevel.PUBLIC,
-        collectionName
-      );
-      return metadata.url;
-    }
-
-    return null;
-  }
-
-  /**
-   * Process array of media resources (strings or Files)
-   * @param mediaArray Array of string URLs or File objects
-   * @param ownerId Owner ID for the media
-   * @param collectionName Collection name for organizing files
-   * @returns Array of URL strings after processing
-   */
-  private async processMediaArray(
-    mediaArray: (string | File | Blob)[] | undefined,
-    ownerId: string,
-    collectionName: string
-  ): Promise<string[]> {
-    if (!mediaArray || mediaArray.length === 0) return [];
-
-    const result: string[] = [];
-
-    for (const media of mediaArray) {
-      const processedUrl = await this.processMedia(
-        media,
-        ownerId,
-        collectionName
-      );
-      if (processedUrl) {
-        result.push(processedUrl);
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Process photos with tags array
-   * @param photosWithTags Array of objects containing media and tag
-   * @param ownerId Owner ID for the media
-   * @param collectionName Collection name for organizing files
-   * @returns Processed array with URL strings
-   */
-  private async processPhotosWithTags(
-    photosWithTags: { url: string | File | Blob; tag: string }[] | undefined,
-    ownerId: string,
-    collectionName: string
-  ): Promise<{ url: string; tag: string }[]> {
-    if (!photosWithTags || photosWithTags.length === 0) return [];
-
-    const result: { url: string; tag: string }[] = [];
-
-    for (const item of photosWithTags) {
-      const processedUrl = await this.processMedia(
-        item.url,
-        ownerId,
-        collectionName
-      );
-      if (processedUrl) {
-        result.push({
-          url: processedUrl,
-          tag: item.tag,
-        });
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Creates a new clinic.
-   * Handles both URL strings and File uploads for media fields.
-   */
-  async createClinic(
-    data: CreateClinicData,
-    creatorAdminId: string
-  ): Promise<Clinic> {
-    try {
-      // Generate ID first so we can use it for media uploads
-      const clinicId = this.generateId();
-
-      // Validate data - this now works because mediaResourceSchema has been updated to support Files/Blobs
-      const validatedData = createClinicSchema.parse(data);
-
-      const group = await this.clinicGroupService.getClinicGroup(
-        validatedData.clinicGroupId
-      );
-      if (!group) {
-        throw new Error(
-          `Clinic group ${validatedData.clinicGroupId} not found`
-        );
-      }
-
-      // Process media fields - convert File/Blob objects to URLs
-      const logoUrl = await this.processMedia(
-        validatedData.logo,
-        clinicId,
-        "clinic-logos"
-      );
-      const coverPhotoUrl = await this.processMedia(
-        validatedData.coverPhoto,
-        clinicId,
-        "clinic-cover-photos"
-      );
-      const featuredPhotos = await this.processMediaArray(
-        validatedData.featuredPhotos,
-        clinicId,
-        "clinic-featured-photos"
-      );
-      const photosWithTags = await this.processPhotosWithTags(
-        validatedData.photosWithTags,
-        clinicId,
-        "clinic-gallery"
-      );
-
-      const location = validatedData.location;
-      const hash = geohashForLocation([location.latitude, location.longitude]);
-      const tz = this.getTimezone(location.latitude, location.longitude);
-      console.log("🏥 Clinic timezone:", tz);
-      const defaultReviewInfo: ClinicReviewInfo = {
-        totalReviews: 0,
-        averageRating: 0,
-        cleanliness: 0,
-        facilities: 0,
-        staffFriendliness: 0,
-        waitingTime: 0,
-        accessibility: 0,
-        recommendationPercentage: 0,
-      };
-
-      const clinicData: Omit<Clinic, "createdAt" | "updatedAt"> & {
-        createdAt: FieldValue;
-        updatedAt: FieldValue;
-      } = {
-        id: clinicId,
-        clinicGroupId: validatedData.clinicGroupId,
-        name: validatedData.name,
-        nameLower: validatedData.name.toLowerCase(), // Add this line
-        description: validatedData.description,
-        location: { ...location, geohash: hash, tz },
-        contactInfo: validatedData.contactInfo,
-        workingHours: validatedData.workingHours,
-        tags: validatedData.tags,
-        featuredPhotos: featuredPhotos,
-        coverPhoto: coverPhotoUrl,
-        photosWithTags: photosWithTags,
-        doctors: validatedData.doctors || [],
-        procedures: validatedData.procedures || [],
-        doctorsInfo: [],
-        proceduresInfo: validatedData.proceduresInfo || [],
-        reviewInfo: defaultReviewInfo,
-        admins: [creatorAdminId],
-        isActive:
-          validatedData.isActive !== undefined ? validatedData.isActive : true,
-        isVerified:
-          validatedData.isVerified !== undefined
-            ? validatedData.isVerified
-            : false,
-        logo: logoUrl,
-        createdAt: serverTimestamp(),
-        updatedAt: serverTimestamp(),
-      };
-
-      // We can validate the final object with URLs using clinicSchema which also supports mediaResourceSchema
-      // However, we need to be careful with timestamps
-      // The validation below is optional and can be uncommented if needed
-      /*
-      clinicSchema.parse({
-        ...clinicData,
-        createdAt: Timestamp.now(),
-        updatedAt: Timestamp.now(),
-      });
-      */
-
-      const batch = writeBatch(this.db);
-      const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
-      batch.set(clinicRef, clinicData);
-
-      const adminRef = doc(this.db, CLINIC_ADMINS_COLLECTION, creatorAdminId);
-      batch.update(adminRef, {
-        clinicsManaged: arrayUnion(clinicId),
-        updatedAt: serverTimestamp(),
-      });
-
-      await batch.commit();
-      console.log(`[ClinicService] Clinic created successfully: ${clinicId}`);
-
-      const savedClinic = await this.getClinic(clinicId);
-      if (!savedClinic) throw new Error("Failed to retrieve created clinic");
-      return savedClinic;
-    } catch (error) {
-      if (error instanceof z.ZodError) {
-        throw new Error("Invalid clinic data: " + error.message);
-      }
-      console.error("Error creating clinic:", error);
-      throw error;
-    }
-  }
-
-  /**
-   * Updates a clinic.
-   * Handles both URL strings and File uploads for media fields.
-   */
-  async updateClinic(
-    clinicId: string,
-    data: Partial<CreateClinicData>,
-    adminId: string
-  ): Promise<Clinic> {
-    try {
-      // First check if clinic exists
-      const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
-      const clinicDoc = await getDoc(clinicRef);
-
-      if (!clinicDoc.exists()) {
-        throw new Error(`Clinic ${clinicId} not found`);
-      }
-
-      const currentClinic = clinicDoc.data() as Clinic;
-
-      // Validate update data - this works because updateClinicSchema supports Files/Blobs
-      const validatedData = updateClinicSchema.parse(data);
-
-      const updatePayload: Record<string, any> = {};
-
-      // Process media fields if provided
-      if (validatedData.logo !== undefined) {
-        updatePayload.logo = await this.processMedia(
-          validatedData.logo,
-          clinicId,
-          "clinic-logos"
-        );
-      }
-
-      if (validatedData.coverPhoto !== undefined) {
-        updatePayload.coverPhoto = await this.processMedia(
-          validatedData.coverPhoto,
-          clinicId,
-          "clinic-cover-photos"
-        );
-      }
-
-      if (validatedData.featuredPhotos !== undefined) {
-        updatePayload.featuredPhotos = await this.processMediaArray(
-          validatedData.featuredPhotos,
-          clinicId,
-          "clinic-featured-photos"
-        );
-      }
-
-      if (validatedData.photosWithTags !== undefined) {
-        updatePayload.photosWithTags = await this.processPhotosWithTags(
-          validatedData.photosWithTags,
-          clinicId,
-          "clinic-gallery"
-        );
-      }
-
-      // Process non-media fields
-      const fieldsToUpdate = [
-        "name",
-        "description",
-        "contactInfo",
-        "workingHours",
-        "tags",
-        "doctors",
-        "procedures",
-        "proceduresInfo",
-        "isActive",
-        "isVerified",
-      ];
-
-      for (const field of fieldsToUpdate) {
-        if (validatedData[field as keyof typeof validatedData] !== undefined) {
-          updatePayload[field] =
-            validatedData[field as keyof typeof validatedData];
-        }
-      }
-
-      // Always update nameLower if name is changed
-      if (validatedData.name) {
-        updatePayload.nameLower = validatedData.name.toLowerCase();
-      }
-
-      // Handle location update with geohash
-      if (validatedData.location) {
-        const loc = validatedData.location;
-        const tz = this.getTimezone(loc.latitude, loc.longitude);
-        updatePayload.location = {
-          ...loc,
-          geohash: geohashForLocation([loc.latitude, loc.longitude]),
-          tz,
-        };
-      }
-
-      // Add timestamp
-      updatePayload.updatedAt = serverTimestamp();
-
-      // Update the clinic
-      await updateDoc(clinicRef, updatePayload);
-      console.log(`[ClinicService] Clinic ${clinicId} updated successfully`);
-
-      // Return the updated clinic
-      const updatedClinic = await this.getClinic(clinicId);
-      if (!updatedClinic) throw new Error("Failed to retrieve updated clinic");
-      return updatedClinic;
-    } catch (error) {
-      if (error instanceof z.ZodError) {
-        throw new Error("Invalid clinic update data: " + error.message);
-      }
-      console.error(`Error updating clinic ${clinicId}:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Deactivates a clinic.
-   */
-  async deactivateClinic(clinicId: string, adminId: string): Promise<void> {
-    // Permission check omitted
-    const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
-    await updateDoc(clinicRef, {
-      isActive: false,
-      updatedAt: serverTimestamp(),
-    });
-  }
-
-  /**
-   * Activates a clinic.
-   */
-  async activateClinic(clinicId: string, adminId: string): Promise<void> {
-    // Permission check omitted
-    const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
-    await updateDoc(clinicRef, {
-      isActive: true,
-      updatedAt: serverTimestamp(),
-    });
-  }
-
-  /**
-   * Dohvata kliniku po ID-u
-   */
-  async getClinic(clinicId: string): Promise<Clinic | null> {
-    return ClinicUtils.getClinic(this.db, clinicId);
-  }
-
-  /**
-   * Dohvata sve klinike u grupi
-   */
-  async getClinicsByGroup(groupId: string): Promise<Clinic[]> {
-    return ClinicUtils.getClinicsByGroup(this.db, groupId);
-  }
-
-  /**
-   * Pretražuje klinike u određenom radijusu
-   */
-  async findClinicsInRadius(
-    center: { latitude: number; longitude: number },
-    radiusInKm: number,
-    filters?: {
-      procedures?: string[];
-      tags?: ClinicTag[];
-      // Add other relevant filters based on Clinic/ProcedureSummaryInfo fields
-    }
-  ): Promise<Clinic[]> {
-    return SearchUtils.findClinicsInRadius(
-      this.db,
-      center,
-      radiusInKm,
-      filters
-    );
-  }
-
-  async addTags(
-    clinicId: string,
-    adminId: string,
-    newTags: {
-      tags?: ClinicTag[];
-    }
-  ): Promise<Clinic> {
-    return TagUtils.addTags(
-      this.db,
-      clinicId,
-      adminId,
-      newTags,
-      this.clinicAdminService,
-      this.app
-    );
-  }
-
-  async removeTags(
-    clinicId: string,
-    adminId: string,
-    tagsToRemove: {
-      tags?: ClinicTag[];
-    }
-  ): Promise<Clinic> {
-    return TagUtils.removeTags(
-      this.db,
-      clinicId,
-      adminId,
-      tagsToRemove,
-      this.clinicAdminService,
-      this.app
-    );
-  }
-
-  async getClinicsByAdmin(
-    adminId: string,
-    options?: {
-      isActive?: boolean;
-      includeGroupClinics?: boolean; // ako je true i admin je owner, uključuje sve klinike grupe
-    }
-  ): Promise<Clinic[]> {
-    return ClinicUtils.getClinicsByAdmin(
-      this.db,
-      adminId,
-      options,
-      this.clinicAdminService,
-      this.clinicGroupService
-    );
-  }
-
-  async getActiveClinicsByAdmin(adminId: string): Promise<Clinic[]> {
-    return ClinicUtils.getActiveClinicsByAdmin(
-      this.db,
-      adminId,
-      this.clinicAdminService,
-      this.clinicGroupService
-    );
-  }
-
-  /**
-   * Creates a clinic branch from setup data.
-   * Handles both URL strings and File uploads for media fields.
-   */
-  async createClinicBranch(
-    clinicGroupId: string,
-    setupData: ClinicBranchSetupData,
-    adminId: string
-  ): Promise<Clinic> {
-    console.log("[CLINIC_SERVICE] Starting clinic branch creation", {
-      clinicGroupId,
-      adminId,
-    });
-
-    // Verify clinic group exists
-    const clinicGroup = await this.clinicGroupService.getClinicGroup(
-      clinicGroupId
-    );
-    if (!clinicGroup) {
-      console.error("[CLINIC_SERVICE] Clinic group not found", {
-        clinicGroupId,
-      });
-      throw new Error(`Clinic group with ID ${clinicGroupId} not found`);
-    }
-    console.log("[CLINIC_SERVICE] Clinic group verified");
-
-    // Validate branch setup data first
-    const validatedSetupData = clinicBranchSetupSchema.parse(setupData);
-
-    // Convert validated setup data to CreateClinicData
-    const createClinicData: CreateClinicData = {
-      clinicGroupId,
-      name: validatedSetupData.name,
-      description: validatedSetupData.description,
-      location: validatedSetupData.location,
-      contactInfo: validatedSetupData.contactInfo,
-      workingHours: validatedSetupData.workingHours,
-      tags: validatedSetupData.tags || [],
-      // Pass the media fields which can be string URLs or File objects
-      logo: validatedSetupData.logo,
-      coverPhoto: validatedSetupData.coverPhoto,
-      featuredPhotos: validatedSetupData.featuredPhotos,
-      photosWithTags: validatedSetupData.photosWithTags,
-      doctors: [],
-      procedures: [],
-      admins: [adminId],
-      isActive: true,
-      isVerified: false,
-    };
-
-    console.log("[CLINIC_SERVICE] Creating clinic branch", {
-      name: createClinicData.name,
-      hasLogo: !!createClinicData.logo,
-      hasCoverPhoto: !!createClinicData.coverPhoto,
-    });
-
-    // Use createClinic which now handles validation and media uploads
-    const clinic = await this.createClinic(createClinicData, adminId);
-
-    console.log("[CLINIC_SERVICE] Clinic branch created successfully", {
-      clinicId: clinic.id,
-    });
-    return clinic;
-  }
-
-  async getClinicById(clinicId: string): Promise<Clinic | null> {
-    return ClinicUtils.getClinicById(this.db, clinicId);
-  }
-
-  async getAllClinics(
-    pagination?: number,
-    lastDoc?: any
-  ): Promise<{ clinics: Clinic[]; lastDoc: any }> {
-    return ClinicUtils.getAllClinics(this.db, pagination, lastDoc);
-  }
-
-  async getAllClinicsInRange(
-    center: { latitude: number; longitude: number },
-    rangeInKm: number,
-    pagination?: number,
-    lastDoc?: any
-  ): Promise<{ clinics: (Clinic & { distance: number })[]; lastDoc: any }> {
-    return ClinicUtils.getAllClinicsInRange(
-      this.db,
-      center,
-      rangeInKm,
-      pagination,
-      lastDoc
-    );
-  }
-
-  /**
-   * Get clinics based on multiple filtering criteria
-   *
-   * @param filters - Various filters to apply
-   * @returns Filtered clinics and the last document for pagination
-   */
-  async getClinicsByFilters(filters: {
-    center?: { latitude: number; longitude: number };
-    radiusInKm?: number;
-    tags?: ClinicTag[];
-    procedureFamily?: string;
-    procedureCategory?: string;
-    procedureSubcategory?: string;
-    procedureTechnology?: string;
-    minRating?: number;
-    maxRating?: number;
-    nameSearch?: string;
-    pagination?: number;
-    lastDoc?: any;
-    isActive?: boolean;
-  }): Promise<{
-    clinics: (Clinic & { distance?: number })[];
-    lastDoc: any;
-  }> {
-    return FilterUtils.getClinicsByFilters(this.db, filters);
-  }
-
-  /**
-   * Gets all clinics with minimal info for map display (id, name, address, latitude, longitude)
-   * This is optimized for mobile map usage to reduce payload size.
-   * @returns Array of minimal clinic info for map
-   */
-  async getClinicsForMap(): Promise<
-    {
-      id: string;
-      name: string;
-      address: string;
-      latitude: number | undefined;
-      longitude: number | undefined;
-    }[]
-  > {
-    const clinicsRef = collection(this.db, CLINICS_COLLECTION);
-    const snapshot = await getDocs(clinicsRef);
-    const clinicsForMap = snapshot.docs.map((doc) => {
-      const data = doc.data();
-      return {
-        id: doc.id,
-        name: data.name,
-        address: data.location?.address || "",
-        latitude: data.location?.latitude,
-        longitude: data.location?.longitude,
-      };
-    });
-    return clinicsForMap;
-  }
-}
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  query,
+  where,
+  updateDoc,
+  setDoc,
+  deleteDoc,
+  Timestamp,
+  serverTimestamp,
+  GeoPoint,
+  QueryConstraint,
+  FieldValue,
+  writeBatch,
+  arrayUnion,
+  arrayRemove,
+} from "firebase/firestore";
+import { getFunctions, httpsCallable } from "firebase/functions";
+import tzlookup from "tz-lookup";
+import { BaseService } from "../base.service";
+import {
+  Clinic,
+  CreateClinicData,
+  CLINICS_COLLECTION,
+  ClinicTag,
+  ClinicTags,
+  ClinicGroup,
+  CLINIC_GROUPS_COLLECTION,
+  ClinicBranchSetupData,
+  CLINIC_ADMINS_COLLECTION,
+  DoctorInfo,
+} from "../../types/clinic";
+// Correct imports
+import { ProcedureSummaryInfo } from "../../types/procedure";
+import { ClinicInfo } from "../../types/profile";
+import { ClinicGroupService } from "./clinic-group.service";
+import { ClinicAdminService } from "./clinic-admin.service";
+import {
+  geohashForLocation,
+  geohashQueryBounds,
+  distanceBetween,
+} from "geofire-common";
+import {
+  clinicSchema,
+  createClinicSchema,
+  updateClinicSchema,
+  clinicBranchSetupSchema,
+} from "../../validations/clinic.schema";
+import { z } from "zod";
+import { Auth } from "firebase/auth";
+import { Firestore } from "firebase/firestore";
+import { FirebaseApp } from "firebase/app";
+import * as ClinicUtils from "./utils/clinic.utils";
+import * as TagUtils from "./utils/tag.utils";
+import * as SearchUtils from "./utils/search.utils";
+import * as AdminUtils from "./utils/admin.utils";
+import * as FilterUtils from "./utils/filter.utils";
+import { ClinicReviewInfo } from "../../types/reviews";
+import { PRACTITIONERS_COLLECTION } from "../../types/practitioner";
+import { MediaService, MediaAccessLevel } from "../media/media.service";
+
+export class ClinicService extends BaseService {
+  private clinicGroupService: ClinicGroupService;
+  private clinicAdminService: ClinicAdminService;
+  private mediaService: MediaService;
+  private functions: any;
+
+  constructor(
+    db: Firestore,
+    auth: Auth,
+    app: FirebaseApp,
+    clinicGroupService: ClinicGroupService,
+    clinicAdminService: ClinicAdminService,
+    mediaService: MediaService
+  ) {
+    super(db, auth, app);
+    this.clinicAdminService = clinicAdminService;
+    this.clinicGroupService = clinicGroupService;
+    this.mediaService = mediaService;
+    this.functions = getFunctions(app, "europe-west6"); // All functions now in europe-west6
+  }
+
+  /**
+   * Get timezone from coordinates using tz-lookup library
+   * @param lat Latitude
+   * @param lng Longitude
+   * @returns IANA timezone string
+   */
+  private getTimezone(lat: number, lng: number): string | null {
+    try {
+      const timezone = tzlookup(lat, lng);
+      return timezone || null;
+    } catch (error) {
+      console.error("[CLINIC_SERVICE] Error getting timezone:", error);
+      return null;
+    }
+  }
+
+  /**
+   * Process media resource (string URL or File object)
+   * @param media String URL or File object
+   * @param ownerId Owner ID for the media (usually clinicId)
+   * @param collectionName Collection name for organizing files
+   * @returns URL string after processing
+   */
+  private async processMedia(
+    media: string | File | Blob | null | undefined,
+    ownerId: string,
+    collectionName: string
+  ): Promise<string | null> {
+    if (!media) return null;
+
+    // If already a string URL, return it directly
+    if (typeof media === "string") {
+      return media;
+    }
+
+    // If it's a File, upload it using MediaService
+    if (media instanceof File || media instanceof Blob) {
+      console.log(
+        `[ClinicService] Uploading ${collectionName} media for ${ownerId}`
+      );
+      const metadata = await this.mediaService.uploadMedia(
+        media,
+        ownerId,
+        MediaAccessLevel.PUBLIC,
+        collectionName
+      );
+      return metadata.url;
+    }
+
+    return null;
+  }
+
+  /**
+   * Process array of media resources (strings or Files)
+   * @param mediaArray Array of string URLs or File objects
+   * @param ownerId Owner ID for the media
+   * @param collectionName Collection name for organizing files
+   * @returns Array of URL strings after processing
+   */
+  private async processMediaArray(
+    mediaArray: (string | File | Blob)[] | undefined,
+    ownerId: string,
+    collectionName: string
+  ): Promise<string[]> {
+    if (!mediaArray || mediaArray.length === 0) return [];
+
+    const result: string[] = [];
+
+    for (const media of mediaArray) {
+      const processedUrl = await this.processMedia(
+        media,
+        ownerId,
+        collectionName
+      );
+      if (processedUrl) {
+        result.push(processedUrl);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Process photos with tags array
+   * @param photosWithTags Array of objects containing media and tag
+   * @param ownerId Owner ID for the media
+   * @param collectionName Collection name for organizing files
+   * @returns Processed array with URL strings
+   */
+  private async processPhotosWithTags(
+    photosWithTags: { url: string | File | Blob; tag: string }[] | undefined,
+    ownerId: string,
+    collectionName: string
+  ): Promise<{ url: string; tag: string }[]> {
+    if (!photosWithTags || photosWithTags.length === 0) return [];
+
+    const result: { url: string; tag: string }[] = [];
+
+    for (const item of photosWithTags) {
+      const processedUrl = await this.processMedia(
+        item.url,
+        ownerId,
+        collectionName
+      );
+      if (processedUrl) {
+        result.push({
+          url: processedUrl,
+          tag: item.tag,
+        });
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Creates a new clinic.
+   * Handles both URL strings and File uploads for media fields.
+   */
+  async createClinic(
+    data: CreateClinicData,
+    creatorAdminId: string
+  ): Promise<Clinic> {
+    try {
+      // Generate ID first so we can use it for media uploads
+      const clinicId = this.generateId();
+
+      // Validate data - this now works because mediaResourceSchema has been updated to support Files/Blobs
+      const validatedData = createClinicSchema.parse(data);
+
+      const group = await this.clinicGroupService.getClinicGroup(
+        validatedData.clinicGroupId
+      );
+      if (!group) {
+        throw new Error(
+          `Clinic group ${validatedData.clinicGroupId} not found`
+        );
+      }
+
+      // Process media fields - convert File/Blob objects to URLs
+      const logoUrl = await this.processMedia(
+        validatedData.logo,
+        clinicId,
+        "clinic-logos"
+      );
+      const coverPhotoUrl = await this.processMedia(
+        validatedData.coverPhoto,
+        clinicId,
+        "clinic-cover-photos"
+      );
+      const featuredPhotos = await this.processMediaArray(
+        validatedData.featuredPhotos,
+        clinicId,
+        "clinic-featured-photos"
+      );
+      const photosWithTags = await this.processPhotosWithTags(
+        validatedData.photosWithTags,
+        clinicId,
+        "clinic-gallery"
+      );
+
+      const location = validatedData.location;
+      const hash = geohashForLocation([location.latitude, location.longitude]);
+      const tz = this.getTimezone(location.latitude, location.longitude);
+      console.log("🏥 Clinic timezone:", tz);
+      const defaultReviewInfo: ClinicReviewInfo = {
+        totalReviews: 0,
+        averageRating: 0,
+        cleanliness: 0,
+        facilities: 0,
+        staffFriendliness: 0,
+        waitingTime: 0,
+        accessibility: 0,
+        recommendationPercentage: 0,
+      };
+
+      const clinicData: Omit<Clinic, "createdAt" | "updatedAt"> & {
+        createdAt: FieldValue;
+        updatedAt: FieldValue;
+      } = {
+        id: clinicId,
+        clinicGroupId: validatedData.clinicGroupId,
+        name: validatedData.name,
+        nameLower: validatedData.name.toLowerCase(), // Add this line
+        description: validatedData.description,
+        location: { ...location, geohash: hash, tz },
+        contactInfo: validatedData.contactInfo,
+        workingHours: validatedData.workingHours,
+        tags: validatedData.tags,
+        featuredPhotos: featuredPhotos,
+        coverPhoto: coverPhotoUrl,
+        photosWithTags: photosWithTags,
+        doctors: validatedData.doctors || [],
+        procedures: validatedData.procedures || [],
+        doctorsInfo: [],
+        proceduresInfo: validatedData.proceduresInfo || [],
+        reviewInfo: defaultReviewInfo,
+        admins: [creatorAdminId],
+        isActive:
+          validatedData.isActive !== undefined ? validatedData.isActive : true,
+        isVerified:
+          validatedData.isVerified !== undefined
+            ? validatedData.isVerified
+            : false,
+        logo: logoUrl,
+        createdAt: serverTimestamp(),
+        updatedAt: serverTimestamp(),
+      };
+
+      // We can validate the final object with URLs using clinicSchema which also supports mediaResourceSchema
+      // However, we need to be careful with timestamps
+      // The validation below is optional and can be uncommented if needed
+      /*
+      clinicSchema.parse({
+        ...clinicData,
+        createdAt: Timestamp.now(),
+        updatedAt: Timestamp.now(),
+      });
+      */
+
+      const batch = writeBatch(this.db);
+      const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
+      batch.set(clinicRef, clinicData);
+
+      const adminRef = doc(this.db, CLINIC_ADMINS_COLLECTION, creatorAdminId);
+      batch.update(adminRef, {
+        clinicsManaged: arrayUnion(clinicId),
+        updatedAt: serverTimestamp(),
+      });
+
+      await batch.commit();
+      console.log(`[ClinicService] Clinic created successfully: ${clinicId}`);
+
+      const savedClinic = await this.getClinic(clinicId);
+      if (!savedClinic) throw new Error("Failed to retrieve created clinic");
+      return savedClinic;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw new Error("Invalid clinic data: " + error.message);
+      }
+      console.error("Error creating clinic:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Updates a clinic.
+   * Handles both URL strings and File uploads for media fields.
+   */
+  async updateClinic(
+    clinicId: string,
+    data: Partial<CreateClinicData>,
+    adminId: string
+  ): Promise<Clinic> {
+    try {
+      // First check if clinic exists
+      const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
+      const clinicDoc = await getDoc(clinicRef);
+
+      if (!clinicDoc.exists()) {
+        throw new Error(`Clinic ${clinicId} not found`);
+      }
+
+      const currentClinic = clinicDoc.data() as Clinic;
+
+      // Validate update data - this works because updateClinicSchema supports Files/Blobs
+      const validatedData = updateClinicSchema.parse(data);
+
+      const updatePayload: Record<string, any> = {};
+
+      // Process media fields if provided
+      if (validatedData.logo !== undefined) {
+        updatePayload.logo = await this.processMedia(
+          validatedData.logo,
+          clinicId,
+          "clinic-logos"
+        );
+      }
+
+      if (validatedData.coverPhoto !== undefined) {
+        updatePayload.coverPhoto = await this.processMedia(
+          validatedData.coverPhoto,
+          clinicId,
+          "clinic-cover-photos"
+        );
+      }
+
+      if (validatedData.featuredPhotos !== undefined) {
+        updatePayload.featuredPhotos = await this.processMediaArray(
+          validatedData.featuredPhotos,
+          clinicId,
+          "clinic-featured-photos"
+        );
+      }
+
+      if (validatedData.photosWithTags !== undefined) {
+        updatePayload.photosWithTags = await this.processPhotosWithTags(
+          validatedData.photosWithTags,
+          clinicId,
+          "clinic-gallery"
+        );
+      }
+
+      // Process non-media fields
+      const fieldsToUpdate = [
+        "name",
+        "description",
+        "contactInfo",
+        "workingHours",
+        "tags",
+        "doctors",
+        "procedures",
+        "proceduresInfo",
+        "isActive",
+        "isVerified",
+      ];
+
+      for (const field of fieldsToUpdate) {
+        if (validatedData[field as keyof typeof validatedData] !== undefined) {
+          updatePayload[field] =
+            validatedData[field as keyof typeof validatedData];
+        }
+      }
+
+      // Always update nameLower if name is changed
+      if (validatedData.name) {
+        updatePayload.nameLower = validatedData.name.toLowerCase();
+      }
+
+      // Handle location update with geohash
+      if (validatedData.location) {
+        const loc = validatedData.location;
+        const tz = this.getTimezone(loc.latitude, loc.longitude);
+        updatePayload.location = {
+          ...loc,
+          geohash: geohashForLocation([loc.latitude, loc.longitude]),
+          tz,
+        };
+      }
+
+      // Add timestamp
+      updatePayload.updatedAt = serverTimestamp();
+
+      // Update the clinic
+      await updateDoc(clinicRef, updatePayload);
+      console.log(`[ClinicService] Clinic ${clinicId} updated successfully`);
+
+      // Return the updated clinic
+      const updatedClinic = await this.getClinic(clinicId);
+      if (!updatedClinic) throw new Error("Failed to retrieve updated clinic");
+      return updatedClinic;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw new Error("Invalid clinic update data: " + error.message);
+      }
+      console.error(`Error updating clinic ${clinicId}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Deactivates a clinic.
+   */
+  async deactivateClinic(clinicId: string, adminId: string): Promise<void> {
+    // Permission check omitted
+    const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
+    await updateDoc(clinicRef, {
+      isActive: false,
+      updatedAt: serverTimestamp(),
+    });
+  }
+
+  /**
+   * Activates a clinic.
+   */
+  async activateClinic(clinicId: string, adminId: string): Promise<void> {
+    // Permission check omitted
+    const clinicRef = doc(this.db, CLINICS_COLLECTION, clinicId);
+    await updateDoc(clinicRef, {
+      isActive: true,
+      updatedAt: serverTimestamp(),
+    });
+  }
+
+  /**
+   * Dohvata kliniku po ID-u
+   */
+  async getClinic(clinicId: string): Promise<Clinic | null> {
+    return ClinicUtils.getClinic(this.db, clinicId);
+  }
+
+  /**
+   * Dohvata sve klinike u grupi
+   */
+  async getClinicsByGroup(groupId: string): Promise<Clinic[]> {
+    return ClinicUtils.getClinicsByGroup(this.db, groupId);
+  }
+
+  /**
+   * Pretražuje klinike u određenom radijusu
+   */
+  async findClinicsInRadius(
+    center: { latitude: number; longitude: number },
+    radiusInKm: number,
+    filters?: {
+      procedures?: string[];
+      tags?: ClinicTag[];
+      // Add other relevant filters based on Clinic/ProcedureSummaryInfo fields
+    }
+  ): Promise<Clinic[]> {
+    return SearchUtils.findClinicsInRadius(
+      this.db,
+      center,
+      radiusInKm,
+      filters
+    );
+  }
+
+  async addTags(
+    clinicId: string,
+    adminId: string,
+    newTags: {
+      tags?: ClinicTag[];
+    }
+  ): Promise<Clinic> {
+    return TagUtils.addTags(
+      this.db,
+      clinicId,
+      adminId,
+      newTags,
+      this.clinicAdminService,
+      this.app
+    );
+  }
+
+  async removeTags(
+    clinicId: string,
+    adminId: string,
+    tagsToRemove: {
+      tags?: ClinicTag[];
+    }
+  ): Promise<Clinic> {
+    return TagUtils.removeTags(
+      this.db,
+      clinicId,
+      adminId,
+      tagsToRemove,
+      this.clinicAdminService,
+      this.app
+    );
+  }
+
+  async getClinicsByAdmin(
+    adminId: string,
+    options?: {
+      isActive?: boolean;
+      includeGroupClinics?: boolean; // ako je true i admin je owner, uključuje sve klinike grupe
+    }
+  ): Promise<Clinic[]> {
+    return ClinicUtils.getClinicsByAdmin(
+      this.db,
+      adminId,
+      options,
+      this.clinicAdminService,
+      this.clinicGroupService
+    );
+  }
+
+  async getActiveClinicsByAdmin(adminId: string): Promise<Clinic[]> {
+    return ClinicUtils.getActiveClinicsByAdmin(
+      this.db,
+      adminId,
+      this.clinicAdminService,
+      this.clinicGroupService
+    );
+  }
+
+  /**
+   * Creates a clinic branch from setup data.
+   * Handles both URL strings and File uploads for media fields.
+   */
+  async createClinicBranch(
+    clinicGroupId: string,
+    setupData: ClinicBranchSetupData,
+    adminId: string
+  ): Promise<Clinic> {
+    console.log("[CLINIC_SERVICE] Starting clinic branch creation", {
+      clinicGroupId,
+      adminId,
+    });
+
+    // Verify clinic group exists
+    const clinicGroup = await this.clinicGroupService.getClinicGroup(
+      clinicGroupId
+    );
+    if (!clinicGroup) {
+      console.error("[CLINIC_SERVICE] Clinic group not found", {
+        clinicGroupId,
+      });
+      throw new Error(`Clinic group with ID ${clinicGroupId} not found`);
+    }
+    console.log("[CLINIC_SERVICE] Clinic group verified");
+
+    // Validate branch setup data first
+    const validatedSetupData = clinicBranchSetupSchema.parse(setupData);
+
+    // Convert validated setup data to CreateClinicData
+    const createClinicData: CreateClinicData = {
+      clinicGroupId,
+      name: validatedSetupData.name,
+      description: validatedSetupData.description,
+      location: validatedSetupData.location,
+      contactInfo: validatedSetupData.contactInfo,
+      workingHours: validatedSetupData.workingHours,
+      tags: validatedSetupData.tags || [],
+      // Pass the media fields which can be string URLs or File objects
+      logo: validatedSetupData.logo,
+      coverPhoto: validatedSetupData.coverPhoto,
+      featuredPhotos: validatedSetupData.featuredPhotos,
+      photosWithTags: validatedSetupData.photosWithTags,
+      doctors: [],
+      procedures: [],
+      admins: [adminId],
+      isActive: true,
+      isVerified: false,
+    };
+
+    console.log("[CLINIC_SERVICE] Creating clinic branch", {
+      name: createClinicData.name,
+      hasLogo: !!createClinicData.logo,
+      hasCoverPhoto: !!createClinicData.coverPhoto,
+    });
+
+    // Use createClinic which now handles validation and media uploads
+    const clinic = await this.createClinic(createClinicData, adminId);
+
+    console.log("[CLINIC_SERVICE] Clinic branch created successfully", {
+      clinicId: clinic.id,
+    });
+    return clinic;
+  }
+
+  async getClinicById(clinicId: string): Promise<Clinic | null> {
+    return ClinicUtils.getClinicById(this.db, clinicId);
+  }
+
+  async getAllClinics(
+    pagination?: number,
+    lastDoc?: any
+  ): Promise<{ clinics: Clinic[]; lastDoc: any }> {
+    return ClinicUtils.getAllClinics(this.db, pagination, lastDoc);
+  }
+
+  async getAllClinicsInRange(
+    center: { latitude: number; longitude: number },
+    rangeInKm: number,
+    pagination?: number,
+    lastDoc?: any
+  ): Promise<{ clinics: (Clinic & { distance: number })[]; lastDoc: any }> {
+    return ClinicUtils.getAllClinicsInRange(
+      this.db,
+      center,
+      rangeInKm,
+      pagination,
+      lastDoc
+    );
+  }
+
+  /**
+   * Get clinics based on multiple filtering criteria
+   *
+   * @param filters - Various filters to apply
+   * @returns Filtered clinics and the last document for pagination
+   */
+  async getClinicsByFilters(filters: {
+    center?: { latitude: number; longitude: number };
+    radiusInKm?: number;
+    tags?: ClinicTag[];
+    procedureFamily?: string;
+    procedureCategory?: string;
+    procedureSubcategory?: string;
+    procedureTechnology?: string;
+    minRating?: number;
+    maxRating?: number;
+    nameSearch?: string;
+    pagination?: number;
+    lastDoc?: any;
+    isActive?: boolean;
+  }): Promise<{
+    clinics: (Clinic & { distance?: number })[];
+    lastDoc: any;
+  }> {
+    return FilterUtils.getClinicsByFilters(this.db, filters);
+  }
+
+  /**
+   * Gets all clinics with minimal info for map display (id, name, address, latitude, longitude)
+   * This is optimized for mobile map usage to reduce payload size.
+   * @returns Array of minimal clinic info for map
+   */
+  async getClinicsForMap(): Promise<
+    {
+      id: string;
+      name: string;
+      address: string;
+      latitude: number | undefined;
+      longitude: number | undefined;
+    }[]
+  > {
+    const clinicsRef = collection(this.db, CLINICS_COLLECTION);
+    const snapshot = await getDocs(clinicsRef);
+    const clinicsForMap = snapshot.docs.map((doc) => {
+      const data = doc.data();
+      return {
+        id: doc.id,
+        name: data.name,
+        address: data.location?.address || "",
+        latitude: data.location?.latitude,
+        longitude: data.location?.longitude,
+      };
+    });
+    return clinicsForMap;
+  }
+}