@blackcode_sa/metaestetics-api 1.13.4 → 1.13.5

package/src/services/calendar/utils/google-calendar.utils.ts

@@ -1,697 +1,697 @@
-/// <reference types="axios" />
-import { Firestore, Timestamp } from "firebase/firestore";
-import axios from "axios";
-import {
-  SyncedCalendar,
-  SyncedCalendarProvider,
-  UpdateSyncedCalendarData,
-} from "../../../types/calendar/synced-calendar.types";
-import {
-  CalendarEvent,
-  CalendarEventStatus,
-  CalendarEventType,
-  CalendarSyncStatus,
-} from "../../../types/calendar";
-import {
-  updateLastSyncedTimestampUtil,
-  updatePractitionerSyncedCalendarUtil,
-  updatePatientSyncedCalendarUtil,
-  updateClinicSyncedCalendarUtil,
-} from "./synced-calendar.utils";
-
-// API URL and client configuration - these should be environment variables in a real application
-export const GOOGLE_CALENDAR_API_URL = "https://www.googleapis.com/calendar/v3";
-const GOOGLE_OAUTH_URL = "https://oauth2.googleapis.com/token";
-const GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/auth";
-const CLIENT_ID = "your-client-id"; // Replace with your actual client ID
-const CLIENT_SECRET = "your-client-secret"; // Replace with your actual client secret
-const REDIRECT_URI = "your-redirect-uri"; // Replace with your actual redirect URI
-
-// Error interface for better error handling
-interface ApiError {
-  message: string;
-  status?: number;
-  response?: {
-    data?: any;
-    status?: number;
-  };
-}
-
-/**
- * Helper function for making API requests
- * @param method - HTTP method
- * @param url - Request URL
- * @param headers - Request headers
- * @param data - Request body data
- * @param params - URL query parameters
- * @returns Response data
- */
-export async function makeRequest(
-  method: string,
-  url: string,
-  headers: Record<string, string>,
-  data?: any,
-  params?: Record<string, string>
-): Promise<any> {
-  // Construct URL with query parameters if provided
-  const queryParams = params
-    ? "?" +
-      Object.entries(params)
-        .map(
-          ([key, value]) =>
-            `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
-        )
-        .join("&")
-    : "";
-
-  const finalUrl = url + queryParams;
-
-  // Example implementation with fetch
-  const options: RequestInit = {
-    method,
-    headers,
-    body: data ? JSON.stringify(data) : undefined,
-  };
-
-  const response = await fetch(finalUrl, options);
-
-  if (!response.ok) {
-    const error: any = new Error(
-      `Request failed with status ${response.status}`
-    );
-    error.response = response;
-    throw error;
-  }
-
-  return response.json();
-}
-
-/**
- * Authenticates with Google Calendar API
- * @param authCode - Authorization code from Google OAuth
- * @returns Access token and refresh token
- */
-export async function authenticateWithGoogleCalendarUtil(
-  authCode: string
-): Promise<{ accessToken: string; refreshToken: string; expiresIn: number }> {
-  try {
-    // Exchange authorization code for tokens
-    const data = {
-      code: authCode,
-      client_id: CLIENT_ID,
-      client_secret: CLIENT_SECRET,
-      redirect_uri: REDIRECT_URI,
-      grant_type: "authorization_code",
-    };
-
-    const response = await makeRequest(
-      "post",
-      GOOGLE_OAUTH_URL,
-      { "Content-Type": "application/json" },
-      data
-    );
-
-    return {
-      accessToken: response.access_token,
-      refreshToken: response.refresh_token,
-      expiresIn: response.expires_in,
-    };
-  } catch (error) {
-    const apiError = error as ApiError;
-    console.error(
-      "Error authenticating with Google Calendar:",
-      apiError.message || "Unknown error"
-    );
-    throw new Error(
-      `Failed to authenticate with Google Calendar: ${
-        apiError.message || "Unknown error"
-      }`
-    );
-  }
-}
-
-/**
- * Refreshes the Google Calendar API access token
- * @param refreshToken - Refresh token
- * @returns New access token and expiry
- */
-export async function refreshGoogleCalendarTokenUtil(
-  refreshToken: string
-): Promise<{ accessToken: string; expiresIn: number }> {
-  try {
-    // Use refresh token to get a new access token
-    const data = {
-      refresh_token: refreshToken,
-      client_id: CLIENT_ID,
-      client_secret: CLIENT_SECRET,
-      grant_type: "refresh_token",
-    };
-
-    const response = await makeRequest(
-      "post",
-      GOOGLE_OAUTH_URL,
-      { "Content-Type": "application/json" },
-      data
-    );
-
-    return {
-      accessToken: response.access_token,
-      expiresIn: response.expires_in,
-    };
-  } catch (error) {
-    const apiError = error as ApiError;
-    console.error(
-      "Error refreshing Google Calendar token:",
-      apiError.message || "Unknown error"
-    );
-    throw new Error(
-      `Failed to refresh Google Calendar token: ${
-        apiError.message || "Unknown error"
-      }`
-    );
-  }
-}
-
-/**
- * Lists available Google Calendars for a user
- * @param accessToken - Google API access token
- * @returns List of available calendars
- */
-export async function listGoogleCalendarsUtil(
-  accessToken: string
-): Promise<Array<{ id: string; name: string }>> {
-  try {
-    // Call Google Calendar API to list calendars
-    const response = await makeRequest(
-      "get",
-      `${GOOGLE_CALENDAR_API_URL}/users/me/calendarList`,
-      { Authorization: `Bearer ${accessToken}` }
-    );
-
-    // Map the response to our format
-    return response.items.map((calendar: any) => ({
-      id: calendar.id,
-      name: calendar.summary,
-    }));
-  } catch (error) {
-    const apiError = error as ApiError;
-    console.error(
-      "Error listing Google Calendars:",
-      apiError.message || "Unknown error"
-    );
-    throw new Error(
-      `Failed to list Google Calendars: ${apiError.message || "Unknown error"}`
-    );
-  }
-}
-
-/**
- * Ensures the synced calendar token is valid and refreshes if needed
- * @param db - Firestore instance
- * @param entityType - Type of entity (practitioner, patient, clinic)
- * @param entityId - ID of the entity
- * @param syncedCalendar - Synced calendar data
- * @returns Valid access token
- */
-async function ensureValidToken(
-  db: Firestore,
-  entityType: "practitioner" | "patient" | "clinic",
-  entityId: string,
-  syncedCalendar: SyncedCalendar
-): Promise<string> {
-  // Check if token is expired or will expire soon (within 5 minutes)
-  const expiryTime = syncedCalendar.tokenExpiry.toDate();
-  const now = new Date();
-  const fiveMinutesFromNow = new Date(now.getTime() + 5 * 60 * 1000);
-
-  if (expiryTime < fiveMinutesFromNow) {
-    // Token is expired or will expire soon, refresh it
-    const { accessToken, expiresIn } = await refreshGoogleCalendarTokenUtil(
-      syncedCalendar.refreshToken
-    );
-
-    // Calculate new expiry time
-    const tokenExpiry = new Date();
-    tokenExpiry.setSeconds(tokenExpiry.getSeconds() + expiresIn);
-
-    // Update the synced calendar with the new token
-    const updateData: Omit<UpdateSyncedCalendarData, "updatedAt"> = {
-      accessToken,
-      tokenExpiry: Timestamp.fromDate(tokenExpiry),
-    };
-
-    // Update the synced calendar in Firestore
-    switch (entityType) {
-      case "practitioner":
-        await updatePractitionerSyncedCalendarUtil(
-          db,
-          entityId,
-          syncedCalendar.id,
-          updateData
-        );
-        break;
-      case "patient":
-        await updatePatientSyncedCalendarUtil(
-          db,
-          entityId,
-          syncedCalendar.id,
-          updateData
-        );
-        break;
-      case "clinic":
-        await updateClinicSyncedCalendarUtil(
-          db,
-          entityId,
-          syncedCalendar.id,
-          updateData
-        );
-        break;
-    }
-
-    return accessToken;
-  }
-
-  // Token is still valid
-  return syncedCalendar.accessToken;
-}
-
-/**
- * Syncs events from our system to Google Calendar
- * @param db - Firestore instance
- * @param entityType - Type of entity (practitioner, patient, clinic)
- * @param entityId - ID of the entity
- * @param syncedCalendar - Synced calendar to use
- * @param events - Events to sync
- * @param existingSyncId - Optional existing sync ID for updating an event
- * @returns Result of the sync operation
- */
-export async function syncEventsToGoogleCalendarUtil(
-  db: Firestore,
-  entityType: "practitioner" | "patient" | "clinic",
-  entityId: string,
-  syncedCalendar: SyncedCalendar,
-  events: CalendarEvent[],
-  existingSyncId?: string
-): Promise<{
-  success: boolean;
-  syncedEvents: number;
-  errors: any[];
-  eventIds: string[];
-}> {
-  try {
-    // Refresh token if needed
-    const { accessToken } = await refreshGoogleCalendarTokenUtil(
-      syncedCalendar.refreshToken
-    );
-
-    let syncedCount = 0;
-    const errors: any[] = [];
-    const eventIds: string[] = [];
-
-    // Process each event
-    for (const event of events) {
-      try {
-        // For patients: Sync all INTERNAL events except CANCELED and REJECTED
-        // For doctors: Only sync INTERNAL events with CONFIRMED status
-        // For clinics: No longer syncing
-
-        // Skip events that are external (we don't sync external events back)
-        if (event.syncStatus === CalendarSyncStatus.EXTERNAL) {
-          continue;
-        }
-
-        // Apply entity-specific sync rules
-        if (
-          entityType === "practitioner" &&
-          event.status !== CalendarEventStatus.CONFIRMED
-        ) {
-          // For doctors, only sync CONFIRMED events
-          continue;
-        }
-
-        if (
-          entityType === "patient" &&
-          (event.status === CalendarEventStatus.CANCELED ||
-            event.status === CalendarEventStatus.REJECTED)
-        ) {
-          // For patients, don't sync CANCELED or REJECTED events
-          continue;
-        }
-
-        if (entityType === "clinic") {
-          // No longer syncing clinic events
-          continue;
-        }
-
-        // Convert our event to Google Calendar format
-        const googleEvent = convertCalendarEventToGoogleEventUtil(event);
-        const headers = {
-          Authorization: `Bearer ${accessToken}`,
-          "Content-Type": "application/json",
-        };
-
-        let responseId = "";
-
-        // Check if we have an existing sync ID to update
-        if (existingSyncId) {
-          // Update the existing event using the provided ID
-          const response = await makeRequest(
-            "put",
-            `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events/${existingSyncId}`,
-            headers,
-            googleEvent
-          );
-          responseId = response.id;
-        } else {
-          // Check if the event already has a synced calendar event ID for this calendar
-          const existingSync = event.syncedCalendarEventId?.find(
-            (sync) =>
-              sync.syncedCalendarProvider === SyncedCalendarProvider.GOOGLE &&
-              // We should check if this is the same calendar we're syncing with, but that information isn't stored
-              // For now, we'll just use the first Google Calendar sync ID
-              sync.syncedCalendarProvider === syncedCalendar.provider
-          );
-
-          if (existingSync) {
-            // Update existing event
-            const response = await makeRequest(
-              "put",
-              `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events/${existingSync.eventId}`,
-              headers,
-              googleEvent
-            );
-            responseId = response.id;
-          } else {
-            // Create new event
-            const response = await makeRequest(
-              "post",
-              `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events`,
-              headers,
-              googleEvent
-            );
-            responseId = response.id;
-          }
-        }
-
-        if (responseId) {
-          eventIds.push(responseId);
-          syncedCount++;
-        }
-      } catch (error) {
-        const apiError = error as ApiError;
-        errors.push({
-          eventId: event.id,
-          error: apiError.message || "Unknown error",
-          status: apiError.response?.status,
-        });
-      }
-    }
-
-    // Update the last synced timestamp
-    await updateLastSyncedTimestampUtil(
-      db,
-      entityType,
-      entityId,
-      syncedCalendar.id
-    );
-
-    return {
-      success: errors.length === 0,
-      syncedEvents: syncedCount,
-      errors,
-      eventIds,
-    };
-  } catch (error) {
-    console.error("Error syncing with Google Calendar:", error);
-    return {
-      success: false,
-      syncedEvents: 0,
-      errors: [{ error: (error as Error).message || "Unknown error" }],
-      eventIds: [],
-    };
-  }
-}
-
-/**
- * Fetches events from Google Calendar
- * @param db - Firestore instance
- * @param entityType - Type of entity (practitioner, patient, clinic)
- * @param entityId - ID of the entity
- * @param syncedCalendar - Synced calendar data
- * @param startDate - Start date for fetching events
- * @param endDate - End date for fetching events
- * @returns Events fetched from Google Calendar
- */
-export async function fetchEventsFromGoogleCalendarUtil(
-  db: Firestore,
-  entityType: "practitioner" | "patient" | "clinic",
-  entityId: string,
-  syncedCalendar: SyncedCalendar,
-  startDate: Date,
-  endDate: Date
-): Promise<any[]> {
-  try {
-    // Ensure we have a valid token
-    const accessToken = await ensureValidToken(
-      db,
-      entityType,
-      entityId,
-      syncedCalendar
-    );
-
-    // Format dates for Google Calendar API
-    const timeMin = startDate.toISOString();
-    const timeMax = endDate.toISOString();
-
-    // Call Google Calendar API to fetch events
-    const response = await makeRequest(
-      "get",
-      `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events`,
-      { Authorization: `Bearer ${accessToken}` },
-      undefined,
-      {
-        timeMin,
-        timeMax,
-        singleEvents: "true",
-        orderBy: "startTime",
-      }
-    );
-
-    // Update the last synced timestamp
-    await updateLastSyncedTimestampUtil(
-      db,
-      entityType,
-      entityId,
-      syncedCalendar.id
-    );
-
-    return response.items;
-  } catch (error) {
-    const apiError = error as ApiError;
-    console.error(
-      "Error fetching events from Google Calendar:",
-      apiError.message || "Unknown error"
-    );
-    throw new Error(
-      `Failed to fetch events from Google Calendar: ${
-        apiError.message || "Unknown error"
-      }`
-    );
-  }
-}
-
-/**
- * Converts a Google Calendar event to our system's format
- * @param googleEvent - Google Calendar event
- * @param entityId - ID of the entity (practitioner, patient, clinic)
- * @param entityType - Type of entity
- * @returns Converted calendar event
- */
-export function convertGoogleEventToCalendarEventUtil(
-  googleEvent: any,
-  entityId: string,
-  entityType: "practitioner" | "patient" | "clinic"
-): Partial<CalendarEvent> {
-  // Extract start and end times
-  const start = googleEvent.start.dateTime
-    ? new Date(googleEvent.start.dateTime)
-    : new Date(googleEvent.start.date);
-  const end = googleEvent.end.dateTime
-    ? new Date(googleEvent.end.dateTime)
-    : new Date(googleEvent.end.date);
-
-  // Create the calendar event
-  const calendarEvent: Partial<CalendarEvent> = {
-    eventName: googleEvent.summary || "External Event",
-    eventLocation: googleEvent.location,
-    eventTime: {
-      start: Timestamp.fromDate(start),
-      end: Timestamp.fromDate(end),
-    },
-    description: googleEvent.description || "",
-    // External events are always set as CONFIRMED - status updates will happen externally
-    status: CalendarEventStatus.CONFIRMED,
-    // All external events are marked as EXTERNAL to indicate they originated outside our system
-    syncStatus: CalendarSyncStatus.EXTERNAL,
-    // All external events are treated as BLOCKING events
-    eventType: CalendarEventType.BLOCKING,
-    // Store the original Google Calendar event ID
-    syncedCalendarEventId: [
-      {
-        eventId: googleEvent.id,
-        syncedCalendarProvider: SyncedCalendarProvider.GOOGLE,
-        syncedAt: Timestamp.now(),
-      },
-    ],
-  };
-
-  // Add entity-specific fields
-  switch (entityType) {
-    case "practitioner":
-      calendarEvent.practitionerProfileId = entityId;
-      break;
-    case "patient":
-      calendarEvent.patientProfileId = entityId;
-      break;
-    case "clinic":
-      calendarEvent.clinicBranchId = entityId;
-      break;
-  }
-
-  return calendarEvent;
-}
-
-/**
- * Converts our system's calendar event to Google Calendar format
- * @param calendarEvent - Our system's calendar event
- * @returns Google Calendar event
- */
-export function convertCalendarEventToGoogleEventUtil(
-  calendarEvent: CalendarEvent
-): any {
-  // Create the Google Calendar event
-  const googleEvent: any = {
-    summary: calendarEvent.eventName,
-    location: calendarEvent.eventLocation,
-    description: calendarEvent.description,
-    start: {
-      dateTime: calendarEvent.eventTime.start.toDate().toISOString(),
-      timeZone: "UTC",
-    },
-    end: {
-      dateTime: calendarEvent.eventTime.end.toDate().toISOString(),
-      timeZone: "UTC",
-    },
-    // Add reminders
-    reminders: {
-      useDefault: false,
-      overrides: [
-        { method: "email", minutes: 24 * 60 }, // 1 day before
-        { method: "popup", minutes: 30 }, // 30 minutes before
-      ],
-    },
-  };
-
-  // Add status mapping
-  switch (calendarEvent.status) {
-    case CalendarEventStatus.CONFIRMED:
-      googleEvent.status = "confirmed";
-      break;
-    case CalendarEventStatus.CANCELED:
-      googleEvent.status = "cancelled";
-      break;
-    case CalendarEventStatus.PENDING:
-      // Google Calendar doesn't have a direct equivalent for pending
-      // We'll use tentative as the closest match
-      googleEvent.status = "tentative";
-      break;
-    default:
-      googleEvent.status = "confirmed";
-  }
-
-  // Add attendees if this is an appointment
-  if (calendarEvent.eventType === CalendarEventType.APPOINTMENT) {
-    googleEvent.attendees = [];
-
-    // In a real implementation, you would fetch the email addresses
-    // of the practitioner and patient from their profiles
-    if (calendarEvent.practitionerProfileId) {
-      googleEvent.attendees.push({
-        email: "practitioner@example.com", // This would be fetched from the practitioner profile
-        displayName: "Dr. Practitioner", // This would be fetched from the practitioner profile
-        responseStatus: "accepted",
-      });
-    }
-
-    if (calendarEvent.patientProfileId) {
-      googleEvent.attendees.push({
-        email: "patient@example.com", // This would be fetched from the patient profile
-        displayName: "Patient", // This would be fetched from the patient profile
-        responseStatus: "needsAction",
-      });
-    }
-  }
-
-  return googleEvent;
-}
-
-/**
- * Deletes an event from Google Calendar
- * @param db - Firestore instance
- * @param entityType - Type of entity (practitioner, patient, clinic)
- * @param entityId - ID of the entity
- * @param syncedCalendar - Synced calendar data
- * @param eventId - ID of the event in Google Calendar
- * @returns Success status
- */
-export async function deleteGoogleCalendarEventUtil(
-  db: Firestore,
-  entityType: "practitioner" | "patient" | "clinic",
-  entityId: string,
-  syncedCalendar: SyncedCalendar,
-  eventId: string
-): Promise<boolean> {
-  try {
-    // Ensure we have a valid token
-    const accessToken = await ensureValidToken(
-      db,
-      entityType,
-      entityId,
-      syncedCalendar
-    );
-
-    // Delete the event from Google Calendar
-    await makeRequest(
-      "delete",
-      `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events/${eventId}`,
-      { Authorization: `Bearer ${accessToken}` }
-    );
-
-    return true;
-  } catch (error) {
-    const apiError = error as ApiError;
-    console.error(
-      "Error deleting event from Google Calendar:",
-      apiError.message || "Unknown error"
-    );
-    throw new Error(
-      `Failed to delete event from Google Calendar: ${
-        apiError.message || "Unknown error"
-      }`
-    );
-  }
-}
-
-/**
- * Gets the OAuth URL for Google Calendar
- * @param scopes - OAuth scopes to request
- * @returns OAuth URL
- */
-export function getGoogleCalendarOAuthUrlUtil(
-  scopes: string[] = ["https://www.googleapis.com/auth/calendar"]
-): string {
-  const scopeString = encodeURIComponent(scopes.join(" "));
-  return `https://accounts.google.com/o/oauth2/v2/auth?client_id=${CLIENT_ID}&redirect_uri=${encodeURIComponent(
-    REDIRECT_URI
-  )}&response_type=code&scope=${scopeString}&access_type=offline&prompt=consent`;
-}
+/// <reference types="axios" />
+import { Firestore, Timestamp } from "firebase/firestore";
+import axios from "axios";
+import {
+  SyncedCalendar,
+  SyncedCalendarProvider,
+  UpdateSyncedCalendarData,
+} from "../../../types/calendar/synced-calendar.types";
+import {
+  CalendarEvent,
+  CalendarEventStatus,
+  CalendarEventType,
+  CalendarSyncStatus,
+} from "../../../types/calendar";
+import {
+  updateLastSyncedTimestampUtil,
+  updatePractitionerSyncedCalendarUtil,
+  updatePatientSyncedCalendarUtil,
+  updateClinicSyncedCalendarUtil,
+} from "./synced-calendar.utils";
+
+// API URL and client configuration - these should be environment variables in a real application
+export const GOOGLE_CALENDAR_API_URL = "https://www.googleapis.com/calendar/v3";
+const GOOGLE_OAUTH_URL = "https://oauth2.googleapis.com/token";
+const GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/auth";
+const CLIENT_ID = "your-client-id"; // Replace with your actual client ID
+const CLIENT_SECRET = "your-client-secret"; // Replace with your actual client secret
+const REDIRECT_URI = "your-redirect-uri"; // Replace with your actual redirect URI
+
+// Error interface for better error handling
+interface ApiError {
+  message: string;
+  status?: number;
+  response?: {
+    data?: any;
+    status?: number;
+  };
+}
+
+/**
+ * Helper function for making API requests
+ * @param method - HTTP method
+ * @param url - Request URL
+ * @param headers - Request headers
+ * @param data - Request body data
+ * @param params - URL query parameters
+ * @returns Response data
+ */
+export async function makeRequest(
+  method: string,
+  url: string,
+  headers: Record<string, string>,
+  data?: any,
+  params?: Record<string, string>
+): Promise<any> {
+  // Construct URL with query parameters if provided
+  const queryParams = params
+    ? "?" +
+      Object.entries(params)
+        .map(
+          ([key, value]) =>
+            `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+        )
+        .join("&")
+    : "";
+
+  const finalUrl = url + queryParams;
+
+  // Example implementation with fetch
+  const options: RequestInit = {
+    method,
+    headers,
+    body: data ? JSON.stringify(data) : undefined,
+  };
+
+  const response = await fetch(finalUrl, options);
+
+  if (!response.ok) {
+    const error: any = new Error(
+      `Request failed with status ${response.status}`
+    );
+    error.response = response;
+    throw error;
+  }
+
+  return response.json();
+}
+
+/**
+ * Authenticates with Google Calendar API
+ * @param authCode - Authorization code from Google OAuth
+ * @returns Access token and refresh token
+ */
+export async function authenticateWithGoogleCalendarUtil(
+  authCode: string
+): Promise<{ accessToken: string; refreshToken: string; expiresIn: number }> {
+  try {
+    // Exchange authorization code for tokens
+    const data = {
+      code: authCode,
+      client_id: CLIENT_ID,
+      client_secret: CLIENT_SECRET,
+      redirect_uri: REDIRECT_URI,
+      grant_type: "authorization_code",
+    };
+
+    const response = await makeRequest(
+      "post",
+      GOOGLE_OAUTH_URL,
+      { "Content-Type": "application/json" },
+      data
+    );
+
+    return {
+      accessToken: response.access_token,
+      refreshToken: response.refresh_token,
+      expiresIn: response.expires_in,
+    };
+  } catch (error) {
+    const apiError = error as ApiError;
+    console.error(
+      "Error authenticating with Google Calendar:",
+      apiError.message || "Unknown error"
+    );
+    throw new Error(
+      `Failed to authenticate with Google Calendar: ${
+        apiError.message || "Unknown error"
+      }`
+    );
+  }
+}
+
+/**
+ * Refreshes the Google Calendar API access token
+ * @param refreshToken - Refresh token
+ * @returns New access token and expiry
+ */
+export async function refreshGoogleCalendarTokenUtil(
+  refreshToken: string
+): Promise<{ accessToken: string; expiresIn: number }> {
+  try {
+    // Use refresh token to get a new access token
+    const data = {
+      refresh_token: refreshToken,
+      client_id: CLIENT_ID,
+      client_secret: CLIENT_SECRET,
+      grant_type: "refresh_token",
+    };
+
+    const response = await makeRequest(
+      "post",
+      GOOGLE_OAUTH_URL,
+      { "Content-Type": "application/json" },
+      data
+    );
+
+    return {
+      accessToken: response.access_token,
+      expiresIn: response.expires_in,
+    };
+  } catch (error) {
+    const apiError = error as ApiError;
+    console.error(
+      "Error refreshing Google Calendar token:",
+      apiError.message || "Unknown error"
+    );
+    throw new Error(
+      `Failed to refresh Google Calendar token: ${
+        apiError.message || "Unknown error"
+      }`
+    );
+  }
+}
+
+/**
+ * Lists available Google Calendars for a user
+ * @param accessToken - Google API access token
+ * @returns List of available calendars
+ */
+export async function listGoogleCalendarsUtil(
+  accessToken: string
+): Promise<Array<{ id: string; name: string }>> {
+  try {
+    // Call Google Calendar API to list calendars
+    const response = await makeRequest(
+      "get",
+      `${GOOGLE_CALENDAR_API_URL}/users/me/calendarList`,
+      { Authorization: `Bearer ${accessToken}` }
+    );
+
+    // Map the response to our format
+    return response.items.map((calendar: any) => ({
+      id: calendar.id,
+      name: calendar.summary,
+    }));
+  } catch (error) {
+    const apiError = error as ApiError;
+    console.error(
+      "Error listing Google Calendars:",
+      apiError.message || "Unknown error"
+    );
+    throw new Error(
+      `Failed to list Google Calendars: ${apiError.message || "Unknown error"}`
+    );
+  }
+}
+
+/**
+ * Ensures the synced calendar token is valid and refreshes if needed
+ * @param db - Firestore instance
+ * @param entityType - Type of entity (practitioner, patient, clinic)
+ * @param entityId - ID of the entity
+ * @param syncedCalendar - Synced calendar data
+ * @returns Valid access token
+ */
+async function ensureValidToken(
+  db: Firestore,
+  entityType: "practitioner" | "patient" | "clinic",
+  entityId: string,
+  syncedCalendar: SyncedCalendar
+): Promise<string> {
+  // Check if token is expired or will expire soon (within 5 minutes)
+  const expiryTime = syncedCalendar.tokenExpiry.toDate();
+  const now = new Date();
+  const fiveMinutesFromNow = new Date(now.getTime() + 5 * 60 * 1000);
+
+  if (expiryTime < fiveMinutesFromNow) {
+    // Token is expired or will expire soon, refresh it
+    const { accessToken, expiresIn } = await refreshGoogleCalendarTokenUtil(
+      syncedCalendar.refreshToken
+    );
+
+    // Calculate new expiry time
+    const tokenExpiry = new Date();
+    tokenExpiry.setSeconds(tokenExpiry.getSeconds() + expiresIn);
+
+    // Update the synced calendar with the new token
+    const updateData: Omit<UpdateSyncedCalendarData, "updatedAt"> = {
+      accessToken,
+      tokenExpiry: Timestamp.fromDate(tokenExpiry),
+    };
+
+    // Update the synced calendar in Firestore
+    switch (entityType) {
+      case "practitioner":
+        await updatePractitionerSyncedCalendarUtil(
+          db,
+          entityId,
+          syncedCalendar.id,
+          updateData
+        );
+        break;
+      case "patient":
+        await updatePatientSyncedCalendarUtil(
+          db,
+          entityId,
+          syncedCalendar.id,
+          updateData
+        );
+        break;
+      case "clinic":
+        await updateClinicSyncedCalendarUtil(
+          db,
+          entityId,
+          syncedCalendar.id,
+          updateData
+        );
+        break;
+    }
+
+    return accessToken;
+  }
+
+  // Token is still valid
+  return syncedCalendar.accessToken;
+}
+
+/**
+ * Syncs events from our system to Google Calendar
+ * @param db - Firestore instance
+ * @param entityType - Type of entity (practitioner, patient, clinic)
+ * @param entityId - ID of the entity
+ * @param syncedCalendar - Synced calendar to use
+ * @param events - Events to sync
+ * @param existingSyncId - Optional existing sync ID for updating an event
+ * @returns Result of the sync operation
+ */
+export async function syncEventsToGoogleCalendarUtil(
+  db: Firestore,
+  entityType: "practitioner" | "patient" | "clinic",
+  entityId: string,
+  syncedCalendar: SyncedCalendar,
+  events: CalendarEvent[],
+  existingSyncId?: string
+): Promise<{
+  success: boolean;
+  syncedEvents: number;
+  errors: any[];
+  eventIds: string[];
+}> {
+  try {
+    // Refresh token if needed
+    const { accessToken } = await refreshGoogleCalendarTokenUtil(
+      syncedCalendar.refreshToken
+    );
+
+    let syncedCount = 0;
+    const errors: any[] = [];
+    const eventIds: string[] = [];
+
+    // Process each event
+    for (const event of events) {
+      try {
+        // For patients: Sync all INTERNAL events except CANCELED and REJECTED
+        // For doctors: Only sync INTERNAL events with CONFIRMED status
+        // For clinics: No longer syncing
+
+        // Skip events that are external (we don't sync external events back)
+        if (event.syncStatus === CalendarSyncStatus.EXTERNAL) {
+          continue;
+        }
+
+        // Apply entity-specific sync rules
+        if (
+          entityType === "practitioner" &&
+          event.status !== CalendarEventStatus.CONFIRMED
+        ) {
+          // For doctors, only sync CONFIRMED events
+          continue;
+        }
+
+        if (
+          entityType === "patient" &&
+          (event.status === CalendarEventStatus.CANCELED ||
+            event.status === CalendarEventStatus.REJECTED)
+        ) {
+          // For patients, don't sync CANCELED or REJECTED events
+          continue;
+        }
+
+        if (entityType === "clinic") {
+          // No longer syncing clinic events
+          continue;
+        }
+
+        // Convert our event to Google Calendar format
+        const googleEvent = convertCalendarEventToGoogleEventUtil(event);
+        const headers = {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json",
+        };
+
+        let responseId = "";
+
+        // Check if we have an existing sync ID to update
+        if (existingSyncId) {
+          // Update the existing event using the provided ID
+          const response = await makeRequest(
+            "put",
+            `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events/${existingSyncId}`,
+            headers,
+            googleEvent
+          );
+          responseId = response.id;
+        } else {
+          // Check if the event already has a synced calendar event ID for this calendar
+          const existingSync = event.syncedCalendarEventId?.find(
+            (sync) =>
+              sync.syncedCalendarProvider === SyncedCalendarProvider.GOOGLE &&
+              // We should check if this is the same calendar we're syncing with, but that information isn't stored
+              // For now, we'll just use the first Google Calendar sync ID
+              sync.syncedCalendarProvider === syncedCalendar.provider
+          );
+
+          if (existingSync) {
+            // Update existing event
+            const response = await makeRequest(
+              "put",
+              `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events/${existingSync.eventId}`,
+              headers,
+              googleEvent
+            );
+            responseId = response.id;
+          } else {
+            // Create new event
+            const response = await makeRequest(
+              "post",
+              `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events`,
+              headers,
+              googleEvent
+            );
+            responseId = response.id;
+          }
+        }
+
+        if (responseId) {
+          eventIds.push(responseId);
+          syncedCount++;
+        }
+      } catch (error) {
+        const apiError = error as ApiError;
+        errors.push({
+          eventId: event.id,
+          error: apiError.message || "Unknown error",
+          status: apiError.response?.status,
+        });
+      }
+    }
+
+    // Update the last synced timestamp
+    await updateLastSyncedTimestampUtil(
+      db,
+      entityType,
+      entityId,
+      syncedCalendar.id
+    );
+
+    return {
+      success: errors.length === 0,
+      syncedEvents: syncedCount,
+      errors,
+      eventIds,
+    };
+  } catch (error) {
+    console.error("Error syncing with Google Calendar:", error);
+    return {
+      success: false,
+      syncedEvents: 0,
+      errors: [{ error: (error as Error).message || "Unknown error" }],
+      eventIds: [],
+    };
+  }
+}
+
+/**
+ * Fetches events from Google Calendar
+ * @param db - Firestore instance
+ * @param entityType - Type of entity (practitioner, patient, clinic)
+ * @param entityId - ID of the entity
+ * @param syncedCalendar - Synced calendar data
+ * @param startDate - Start date for fetching events
+ * @param endDate - End date for fetching events
+ * @returns Events fetched from Google Calendar
+ */
+export async function fetchEventsFromGoogleCalendarUtil(
+  db: Firestore,
+  entityType: "practitioner" | "patient" | "clinic",
+  entityId: string,
+  syncedCalendar: SyncedCalendar,
+  startDate: Date,
+  endDate: Date
+): Promise<any[]> {
+  try {
+    // Ensure we have a valid token
+    const accessToken = await ensureValidToken(
+      db,
+      entityType,
+      entityId,
+      syncedCalendar
+    );
+
+    // Format dates for Google Calendar API
+    const timeMin = startDate.toISOString();
+    const timeMax = endDate.toISOString();
+
+    // Call Google Calendar API to fetch events
+    const response = await makeRequest(
+      "get",
+      `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events`,
+      { Authorization: `Bearer ${accessToken}` },
+      undefined,
+      {
+        timeMin,
+        timeMax,
+        singleEvents: "true",
+        orderBy: "startTime",
+      }
+    );
+
+    // Update the last synced timestamp
+    await updateLastSyncedTimestampUtil(
+      db,
+      entityType,
+      entityId,
+      syncedCalendar.id
+    );
+
+    return response.items;
+  } catch (error) {
+    const apiError = error as ApiError;
+    console.error(
+      "Error fetching events from Google Calendar:",
+      apiError.message || "Unknown error"
+    );
+    throw new Error(
+      `Failed to fetch events from Google Calendar: ${
+        apiError.message || "Unknown error"
+      }`
+    );
+  }
+}
+
+/**
+ * Converts a Google Calendar event to our system's format
+ * @param googleEvent - Google Calendar event
+ * @param entityId - ID of the entity (practitioner, patient, clinic)
+ * @param entityType - Type of entity
+ * @returns Converted calendar event
+ */
+export function convertGoogleEventToCalendarEventUtil(
+  googleEvent: any,
+  entityId: string,
+  entityType: "practitioner" | "patient" | "clinic"
+): Partial<CalendarEvent> {
+  // Extract start and end times
+  const start = googleEvent.start.dateTime
+    ? new Date(googleEvent.start.dateTime)
+    : new Date(googleEvent.start.date);
+  const end = googleEvent.end.dateTime
+    ? new Date(googleEvent.end.dateTime)
+    : new Date(googleEvent.end.date);
+
+  // Create the calendar event
+  const calendarEvent: Partial<CalendarEvent> = {
+    eventName: googleEvent.summary || "External Event",
+    eventLocation: googleEvent.location,
+    eventTime: {
+      start: Timestamp.fromDate(start),
+      end: Timestamp.fromDate(end),
+    },
+    description: googleEvent.description || "",
+    // External events are always set as CONFIRMED - status updates will happen externally
+    status: CalendarEventStatus.CONFIRMED,
+    // All external events are marked as EXTERNAL to indicate they originated outside our system
+    syncStatus: CalendarSyncStatus.EXTERNAL,
+    // All external events are treated as BLOCKING events
+    eventType: CalendarEventType.BLOCKING,
+    // Store the original Google Calendar event ID
+    syncedCalendarEventId: [
+      {
+        eventId: googleEvent.id,
+        syncedCalendarProvider: SyncedCalendarProvider.GOOGLE,
+        syncedAt: Timestamp.now(),
+      },
+    ],
+  };
+
+  // Add entity-specific fields
+  switch (entityType) {
+    case "practitioner":
+      calendarEvent.practitionerProfileId = entityId;
+      break;
+    case "patient":
+      calendarEvent.patientProfileId = entityId;
+      break;
+    case "clinic":
+      calendarEvent.clinicBranchId = entityId;
+      break;
+  }
+
+  return calendarEvent;
+}
+
+/**
+ * Converts our system's calendar event to Google Calendar format
+ * @param calendarEvent - Our system's calendar event
+ * @returns Google Calendar event
+ */
+export function convertCalendarEventToGoogleEventUtil(
+  calendarEvent: CalendarEvent
+): any {
+  // Create the Google Calendar event
+  const googleEvent: any = {
+    summary: calendarEvent.eventName,
+    location: calendarEvent.eventLocation,
+    description: calendarEvent.description,
+    start: {
+      dateTime: calendarEvent.eventTime.start.toDate().toISOString(),
+      timeZone: "UTC",
+    },
+    end: {
+      dateTime: calendarEvent.eventTime.end.toDate().toISOString(),
+      timeZone: "UTC",
+    },
+    // Add reminders
+    reminders: {
+      useDefault: false,
+      overrides: [
+        { method: "email", minutes: 24 * 60 }, // 1 day before
+        { method: "popup", minutes: 30 }, // 30 minutes before
+      ],
+    },
+  };
+
+  // Add status mapping
+  switch (calendarEvent.status) {
+    case CalendarEventStatus.CONFIRMED:
+      googleEvent.status = "confirmed";
+      break;
+    case CalendarEventStatus.CANCELED:
+      googleEvent.status = "cancelled";
+      break;
+    case CalendarEventStatus.PENDING:
+      // Google Calendar doesn't have a direct equivalent for pending
+      // We'll use tentative as the closest match
+      googleEvent.status = "tentative";
+      break;
+    default:
+      googleEvent.status = "confirmed";
+  }
+
+  // Add attendees if this is an appointment
+  if (calendarEvent.eventType === CalendarEventType.APPOINTMENT) {
+    googleEvent.attendees = [];
+
+    // In a real implementation, you would fetch the email addresses
+    // of the practitioner and patient from their profiles
+    if (calendarEvent.practitionerProfileId) {
+      googleEvent.attendees.push({
+        email: "practitioner@example.com", // This would be fetched from the practitioner profile
+        displayName: "Dr. Practitioner", // This would be fetched from the practitioner profile
+        responseStatus: "accepted",
+      });
+    }
+
+    if (calendarEvent.patientProfileId) {
+      googleEvent.attendees.push({
+        email: "patient@example.com", // This would be fetched from the patient profile
+        displayName: "Patient", // This would be fetched from the patient profile
+        responseStatus: "needsAction",
+      });
+    }
+  }
+
+  return googleEvent;
+}
+
+/**
+ * Deletes an event from Google Calendar
+ * @param db - Firestore instance
+ * @param entityType - Type of entity (practitioner, patient, clinic)
+ * @param entityId - ID of the entity
+ * @param syncedCalendar - Synced calendar data
+ * @param eventId - ID of the event in Google Calendar
+ * @returns Success status
+ */
+export async function deleteGoogleCalendarEventUtil(
+  db: Firestore,
+  entityType: "practitioner" | "patient" | "clinic",
+  entityId: string,
+  syncedCalendar: SyncedCalendar,
+  eventId: string
+): Promise<boolean> {
+  try {
+    // Ensure we have a valid token
+    const accessToken = await ensureValidToken(
+      db,
+      entityType,
+      entityId,
+      syncedCalendar
+    );
+
+    // Delete the event from Google Calendar
+    await makeRequest(
+      "delete",
+      `${GOOGLE_CALENDAR_API_URL}/calendars/${syncedCalendar.calendarId}/events/${eventId}`,
+      { Authorization: `Bearer ${accessToken}` }
+    );
+
+    return true;
+  } catch (error) {
+    const apiError = error as ApiError;
+    console.error(
+      "Error deleting event from Google Calendar:",
+      apiError.message || "Unknown error"
+    );
+    throw new Error(
+      `Failed to delete event from Google Calendar: ${
+        apiError.message || "Unknown error"
+      }`
+    );
+  }
+}
+
+/**
+ * Gets the OAuth URL for Google Calendar
+ * @param scopes - OAuth scopes to request
+ * @returns OAuth URL
+ */
+export function getGoogleCalendarOAuthUrlUtil(
+  scopes: string[] = ["https://www.googleapis.com/auth/calendar"]
+): string {
+  const scopeString = encodeURIComponent(scopes.join(" "));
+  return `https://accounts.google.com/o/oauth2/v2/auth?client_id=${CLIENT_ID}&redirect_uri=${encodeURIComponent(
+    REDIRECT_URI
+  )}&response_type=code&scope=${scopeString}&access_type=offline&prompt=consent`;
+}