@blackcode_sa/metaestetics-api 1.15.16 → 1.15.17-staging.0

package/src/services/appointment/utils/form-initialization.utils.ts

@@ -1,516 +1,516 @@
-import { Firestore, collection, doc, addDoc, deleteDoc, getDocs, query, where, serverTimestamp, getDoc, updateDoc } from 'firebase/firestore';
-import {
-  DocumentTemplate,
-  FilledDocumentStatus,
-  DOCTOR_FORMS_SUBCOLLECTION,
-  USER_FORMS_SUBCOLLECTION,
-  DOCUMENTATION_TEMPLATES_COLLECTION,
-  FilledDocument,
-} from '../../../types/documentation-templates';
-import {
-  APPOINTMENTS_COLLECTION,
-  LinkedFormInfo,
-} from '../../../types/appointment';
-import { TechnologyDocumentationTemplate } from '../../../backoffice/types/technology.types';
-
-export interface InitializeExtendedProcedureFormsResult {
-  initializedFormsInfo: LinkedFormInfo[];
-  pendingUserFormsIds: string[];
-  allLinkedFormIds: string[];
-}
-
-/**
- * Determines if a form template is procedure-specific or general/shared
- * Uses explicit tags first, then falls back to heuristics
- * 
- * Priority order:
- * 1. "procedure-specific" tag → always procedure-specific
- * 2. "shared" tag → always shared
- * 3. Consent-related tags ("consent", "consent-form") → procedure-specific
- * 4. Title contains "consent" → procedure-specific
- * 5. Default → shared (general forms)
- * 
- * @param template DocumentTemplate to check
- * @returns true if procedure-specific, false if general/shared
- */
-function isProcedureSpecificForm(template: DocumentTemplate): boolean {
-  const tags = template.tags || [];
-  const titleLower = template.title.toLowerCase();
-  
-  // Priority 1: Explicit "procedure-specific" tag → always procedure-specific
-  if (tags.includes('procedure-specific')) {
-    return true;
-  }
-  
-  // Priority 2: Explicit "shared" tag → always shared
-  if (tags.includes('shared')) {
-    return false;
-  }
-  
-  // Priority 3: Consent-related tags → procedure-specific
-  if (tags.some(tag => {
-    const tagLower = tag.toLowerCase();
-    return tagLower.includes('consent') || tagLower === 'consent-form';
-  })) {
-    return true;
-  }
-  
-  // Priority 4: Check title for "consent" → procedure-specific
-  if (titleLower.includes('consent')) {
-    return true;
-  }
-  
-  // Priority 5: Default → shared (general forms)
-  return false;
-}
-
-/**
- * Checks if a form with the given templateId already exists in the appointment
- * @param db Firestore instance
- * @param appointmentId Appointment ID
- * @param templateId Template ID to check
- * @param isUserForm Whether to check user-forms or doctor-forms subcollection
- * @returns Existing FilledDocument or null if not found
- */
-async function findExistingFormByTemplate(
-  db: Firestore,
-  appointmentId: string,
-  templateId: string,
-  isUserForm: boolean
-): Promise<FilledDocument | null> {
-  const formSubcollection = isUserForm
-    ? USER_FORMS_SUBCOLLECTION
-    : DOCTOR_FORMS_SUBCOLLECTION;
-  
-  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
-  const formsCollectionRef = collection(appointmentRef, formSubcollection);
-  
-  const q = query(
-    formsCollectionRef,
-    where('templateId', '==', templateId)
-  );
-  
-  const querySnapshot = await getDocs(q);
-  
-  if (querySnapshot.empty) {
-    return null;
-  }
-  
-  // Return the first matching form (should only be one for general forms)
-  const docSnap = querySnapshot.docs[0];
-  const data = docSnap.data() as FilledDocument;
-  
-  // Ensure id is populated from Firestore document ID if not in data
-  if (!data.id) {
-    data.id = docSnap.id;
-  }
-  
-  return data;
-}
-
-/**
- * Initializes forms for an extended procedure using client-side Firestore
- * Similar to DocumentManagerAdminService but for client-side usage
- * @param db Firestore instance
- * @param appointmentId Appointment ID
- * @param procedureId Procedure ID for forms
- * @param technologyTemplates Technology documentation templates
- * @param patientId Patient ID
- * @param practitionerId Practitioner ID
- * @param clinicId Clinic ID
- * @returns Form initialization result
- */
-export async function initializeFormsForExtendedProcedure(
-  db: Firestore,
-  appointmentId: string,
-  procedureId: string,
-  technologyTemplates: TechnologyDocumentationTemplate[],
-  patientId: string,
-  practitionerId: string,
-  clinicId: string
-): Promise<InitializeExtendedProcedureFormsResult> {
-  const initializedFormsInfo: LinkedFormInfo[] = [];
-  const pendingUserFormsIds: string[] = [];
-  const allLinkedFormIds: string[] = [];
-
-  if (!technologyTemplates || technologyTemplates.length === 0) {
-    console.log(
-      `[FormInit] No document templates to initialize for extended procedure ${procedureId} in appointment ${appointmentId}.`
-    );
-    return {
-      initializedFormsInfo,
-      pendingUserFormsIds,
-      allLinkedFormIds,
-    };
-  }
-
-  // Fetch all template documents
-  const templateIds = technologyTemplates.map((t) => t.templateId);
-  
-  // Note: Client-side Firestore doesn't support 'in' queries with more than 10 items
-  // We'll fetch templates one by one for now (can be optimized later)
-  const templatesMap = new Map<string, DocumentTemplate>();
-  
-  for (const templateId of templateIds) {
-    try {
-      const templateDoc = doc(db, DOCUMENTATION_TEMPLATES_COLLECTION, templateId);
-      const templateSnap = await getDoc(templateDoc);
-      
-      if (templateSnap.exists()) {
-        templatesMap.set(templateId, templateSnap.data() as DocumentTemplate);
-      } else {
-        console.warn(
-          `[FormInit] Template ${templateId} not found in Firestore.`
-        );
-      }
-    } catch (error) {
-      console.error(`[FormInit] Error fetching template ${templateId}:`, error);
-    }
-  }
-
-  // Initialize forms for each template (both user forms and doctor forms for extended procedures)
-  for (const templateRef of technologyTemplates) {
-    const template = templatesMap.get(templateRef.templateId);
-    if (!template) {
-      console.warn(
-        `[FormInit] Template ${templateRef.templateId} not found in Firestore.`
-      );
-      continue;
-    }
-
-    const isRequired = templateRef.isRequired;
-    const isUserForm = templateRef.isUserForm || false;
-    const formSubcollectionPath = isUserForm
-      ? USER_FORMS_SUBCOLLECTION
-      : DOCTOR_FORMS_SUBCOLLECTION;
-
-    // Check if form is procedure-specific or general/shared
-    const isProcedureSpecific = isProcedureSpecificForm(template);
-
-    // For general/shared forms, check if form already exists in appointment
-    let existingForm: FilledDocument | null = null;
-    if (!isProcedureSpecific) {
-      try {
-        existingForm = await findExistingFormByTemplate(
-          db,
-          appointmentId,
-          templateRef.templateId,
-          isUserForm
-        );
-        
-        if (existingForm) {
-          console.log(
-            `[FormInit] Found existing shared form ${existingForm.id} (template: ${template.id}) for appointment ${appointmentId}. Reusing instead of creating duplicate.`
-          );
-          
-          // Reuse existing form - add to linkedForms but don't create new document
-          // Note: We still add it to allLinkedFormIds to ensure it's tracked,
-          // but we don't add it again if it's already in the appointment's linkedForms
-          // (This will be handled by the caller merging the arrays)
-          
-          const linkedForm: LinkedFormInfo = {
-            formId: existingForm.id,
-            templateId: template.id,
-            templateVersion: template.version,
-            title: template.title,
-            isUserForm: isUserForm,
-            isRequired: isRequired,
-            sortingOrder: templateRef.sortingOrder,
-            status: existingForm.status || FilledDocumentStatus.PENDING,
-            path: `${APPOINTMENTS_COLLECTION}/${appointmentId}/${formSubcollectionPath}/${existingForm.id}`,
-            procedureId: procedureId, // Track which procedure this form belongs to
-          };
-          initializedFormsInfo.push(linkedForm);
-          
-          // Add to allLinkedFormIds if not already present (to avoid duplicates)
-          if (!allLinkedFormIds.includes(existingForm.id)) {
-            allLinkedFormIds.push(existingForm.id);
-          }
-          
-          // Add to pendingUserFormsIds if it's a required user form and not already completed
-          if (isUserForm && isRequired && existingForm.status === FilledDocumentStatus.PENDING) {
-            if (!pendingUserFormsIds.includes(existingForm.id)) {
-              pendingUserFormsIds.push(existingForm.id);
-            }
-          }
-          
-          continue; // Skip creating new form, reuse existing one
-        }
-      } catch (error) {
-        console.warn(
-          `[FormInit] Error checking for existing form (template: ${templateRef.templateId}):`,
-          error
-        );
-        // Continue to create new form if check fails
-      }
-    }
-
-    // Create new form document (either procedure-specific or general form not found)
-    const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
-    const formsCollectionRef = collection(appointmentRef, formSubcollectionPath);
-    
-    const filledDocumentData = {
-      templateId: templateRef.templateId,
-      templateVersion: template.version,
-      isUserForm: isUserForm,
-      isRequired: isRequired,
-      appointmentId: appointmentId,
-      procedureId: procedureId,
-      patientId: patientId,
-      practitionerId: practitionerId,
-      clinicId: clinicId,
-      createdAt: serverTimestamp(),
-      updatedAt: serverTimestamp(),
-      values: {},
-      status: FilledDocumentStatus.PENDING,
-    };
-
-    try {
-      const docRef = await addDoc(formsCollectionRef, filledDocumentData);
-      const filledDocumentId = docRef.id;
-
-      // Update the document to include the id field in the data (for consistency)
-      await updateDoc(docRef, { id: filledDocumentId });
-
-      // Add to pendingUserFormsIds if it's a required user form
-      if (isUserForm && isRequired) {
-        pendingUserFormsIds.push(filledDocumentId);
-      }
-
-      allLinkedFormIds.push(filledDocumentId);
-
-      const linkedForm: LinkedFormInfo = {
-        formId: filledDocumentId,
-        templateId: template.id,
-        templateVersion: template.version,
-        title: template.title,
-        isUserForm: isUserForm,
-        isRequired: isRequired,
-        sortingOrder: templateRef.sortingOrder,
-        status: FilledDocumentStatus.PENDING,
-        path: docRef.path,
-        procedureId: procedureId, // Track which procedure this form belongs to
-      };
-      initializedFormsInfo.push(linkedForm);
-
-      const formType = isProcedureSpecific ? 'procedure-specific' : 'general/shared';
-      console.log(
-        `[FormInit] Created ${formType} FilledDocument ${filledDocumentId} (template: ${template.id}, isUserForm: ${isUserForm}) for extended procedure ${procedureId} in appointment ${appointmentId}.`
-      );
-    } catch (error) {
-      console.error(
-        `[FormInit] Error creating form for template ${templateRef.templateId}:`,
-        error
-      );
-    }
-  }
-
-  return { initializedFormsInfo, pendingUserFormsIds, allLinkedFormIds };
-}
-
-/**
- * Removes all forms associated with a specific procedure from an appointment
- * Only removes procedure-specific forms. Shared forms are kept if still referenced by other procedures.
- * Removes both user forms and doctor forms
- * @param db Firestore instance
- * @param appointmentId Appointment ID
- * @param procedureId Procedure ID to remove forms for
- * @returns Array of removed form IDs
- */
-export async function removeFormsForExtendedProcedure(
-  db: Firestore,
-  appointmentId: string,
-  procedureId: string
-): Promise<string[]> {
-  const removedFormIds: string[] = [];
-
-  // Get appointment to check linkedForms
-  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
-  const appointmentSnap = await getDoc(appointmentRef);
-  
-  if (!appointmentSnap.exists()) {
-    console.warn(
-      `[FormInit] Appointment ${appointmentId} not found when removing forms for procedure ${procedureId}.`
-    );
-    return removedFormIds;
-  }
-
-  const appointment = appointmentSnap.data() as any;
-  const linkedForms = appointment.linkedForms || [];
-  
-  // Get all procedure IDs (main + extended) to check if shared forms are still referenced
-  const mainProcedureId = appointment.procedureId;
-  const extendedProcedureIds = appointment.metadata?.extendedProcedures?.map(
-    (ep: any) => ep.procedureId
-  ) || [];
-  const allProcedureIds = [mainProcedureId, ...extendedProcedureIds].filter(Boolean);
-  const remainingProcedureIds = allProcedureIds.filter((id: string) => id !== procedureId);
-
-  // Helper function to check if form appears multiple times in linkedForms (indicating it's shared)
-  const isFormSharedAndReferenced = (formId: string): boolean => {
-    const formEntries = linkedForms.filter((form: LinkedFormInfo) => form.formId === formId);
-    // If form appears multiple times in linkedForms, it's shared across procedures
-    return formEntries.length > 1;
-  };
-
-  // Remove from doctor forms subcollection
-  const doctorFormsRef = collection(appointmentRef, DOCTOR_FORMS_SUBCOLLECTION);
-  const doctorFormsQuery = query(
-    doctorFormsRef,
-    where('procedureId', '==', procedureId)
-  );
-  const doctorFormsSnap = await getDocs(doctorFormsQuery);
-
-  for (const formDoc of doctorFormsSnap.docs) {
-    try {
-      const formData = formDoc.data() as FilledDocument;
-      
-      // Fetch template to check if form is shared
-      let isShared = false;
-      if (formData.templateId) {
-        try {
-          const templateDoc = doc(db, DOCUMENTATION_TEMPLATES_COLLECTION, formData.templateId);
-          const templateSnap = await getDoc(templateDoc);
-          if (templateSnap.exists()) {
-            const template = templateSnap.data() as DocumentTemplate;
-            isShared = !isProcedureSpecificForm(template);
-          }
-        } catch (error) {
-          console.warn(
-            `[FormInit] Could not check template for form ${formDoc.id}, assuming procedure-specific:`,
-            error
-          );
-        }
-      }
-
-      // Only delete procedure-specific forms
-      // Shared forms are kept even if procedureId matches, as they may be used by other procedures
-      if (!isShared) {
-        await deleteDoc(formDoc.ref);
-        removedFormIds.push(formDoc.id);
-        console.log(
-          `[FormInit] Removed procedure-specific doctor form ${formDoc.id} for extended procedure ${procedureId} from appointment ${appointmentId}.`
-        );
-      } else {
-        // Check if form is still referenced by other procedures (appears multiple times in linkedForms)
-        if (isFormSharedAndReferenced(formDoc.id)) {
-          console.log(
-            `[FormInit] Skipped deletion of shared doctor form ${formDoc.id} - still referenced by other procedures.`
-          );
-        } else {
-          // Shared form but only referenced by this procedure (shouldn't happen, but handle it)
-          await deleteDoc(formDoc.ref);
-          removedFormIds.push(formDoc.id);
-          console.log(
-            `[FormInit] Removed shared doctor form ${formDoc.id} - no longer referenced by other procedures.`
-          );
-        }
-      }
-    } catch (error) {
-      console.error(
-        `[FormInit] Error removing doctor form ${formDoc.id}:`,
-        error
-      );
-    }
-  }
-
-  // Remove from user forms subcollection
-  const userFormsRef = collection(appointmentRef, USER_FORMS_SUBCOLLECTION);
-  const userFormsQuery = query(
-    userFormsRef,
-    where('procedureId', '==', procedureId)
-  );
-  const userFormsSnap = await getDocs(userFormsQuery);
-
-  for (const formDoc of userFormsSnap.docs) {
-    try {
-      const formData = formDoc.data() as FilledDocument;
-      
-      // Fetch template to check if form is shared
-      let isShared = false;
-      if (formData.templateId) {
-        try {
-          const templateDoc = doc(db, DOCUMENTATION_TEMPLATES_COLLECTION, formData.templateId);
-          const templateSnap = await getDoc(templateDoc);
-          if (templateSnap.exists()) {
-            const template = templateSnap.data() as DocumentTemplate;
-            isShared = !isProcedureSpecificForm(template);
-          }
-        } catch (error) {
-          console.warn(
-            `[FormInit] Could not check template for form ${formDoc.id}, assuming procedure-specific:`,
-            error
-          );
-        }
-      }
-
-      // Only delete procedure-specific forms
-      // Shared forms are kept even if procedureId matches, as they may be used by other procedures
-      if (!isShared) {
-        await deleteDoc(formDoc.ref);
-        removedFormIds.push(formDoc.id);
-        console.log(
-          `[FormInit] Removed procedure-specific user form ${formDoc.id} for extended procedure ${procedureId} from appointment ${appointmentId}.`
-        );
-      } else {
-        // Check if form is still referenced by other procedures (appears multiple times in linkedForms)
-        if (isFormSharedAndReferenced(formDoc.id)) {
-          console.log(
-            `[FormInit] Skipped deletion of shared user form ${formDoc.id} - still referenced by other procedures.`
-          );
-        } else {
-          // Shared form but only referenced by this procedure (shouldn't happen, but handle it)
-          await deleteDoc(formDoc.ref);
-          removedFormIds.push(formDoc.id);
-          console.log(
-            `[FormInit] Removed shared user form ${formDoc.id} - no longer referenced by other procedures.`
-          );
-        }
-      }
-    } catch (error) {
-      console.error(
-        `[FormInit] Error removing user form ${formDoc.id}:`,
-        error
-      );
-    }
-  }
-
-  return removedFormIds;
-}
-
-/**
- * Gets all forms associated with a specific procedure in an appointment
- * @param db Firestore instance
- * @param appointmentId Appointment ID
- * @param procedureId Procedure ID
- * @returns Array of form IDs
- */
-export async function getFormsForExtendedProcedure(
-  db: Firestore,
-  appointmentId: string,
-  procedureId: string
-): Promise<string[]> {
-  const formIds: string[] = [];
-
-  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
-
-  // Query doctor forms for this procedure
-  const doctorFormsRef = collection(appointmentRef, DOCTOR_FORMS_SUBCOLLECTION);
-  const doctorFormsQuery = query(
-    doctorFormsRef,
-    where('procedureId', '==', procedureId)
-  );
-  const doctorFormsSnap = await getDocs(doctorFormsQuery);
-  doctorFormsSnap.docs.forEach(doc => formIds.push(doc.id));
-
-  // Query user forms for this procedure
-  const userFormsRef = collection(appointmentRef, USER_FORMS_SUBCOLLECTION);
-  const userFormsQuery = query(
-    userFormsRef,
-    where('procedureId', '==', procedureId)
-  );
-  const userFormsSnap = await getDocs(userFormsQuery);
-  userFormsSnap.docs.forEach(doc => formIds.push(doc.id));
-
-  return formIds;
-}
+import { Firestore, collection, doc, addDoc, deleteDoc, getDocs, query, where, serverTimestamp, getDoc, updateDoc } from 'firebase/firestore';
+import {
+  DocumentTemplate,
+  FilledDocumentStatus,
+  DOCTOR_FORMS_SUBCOLLECTION,
+  USER_FORMS_SUBCOLLECTION,
+  DOCUMENTATION_TEMPLATES_COLLECTION,
+  FilledDocument,
+} from '../../../types/documentation-templates';
+import {
+  APPOINTMENTS_COLLECTION,
+  LinkedFormInfo,
+} from '../../../types/appointment';
+import { TechnologyDocumentationTemplate } from '../../../backoffice/types/technology.types';
+
+export interface InitializeExtendedProcedureFormsResult {
+  initializedFormsInfo: LinkedFormInfo[];
+  pendingUserFormsIds: string[];
+  allLinkedFormIds: string[];
+}
+
+/**
+ * Determines if a form template is procedure-specific or general/shared
+ * Uses explicit tags first, then falls back to heuristics
+ * 
+ * Priority order:
+ * 1. "procedure-specific" tag → always procedure-specific
+ * 2. "shared" tag → always shared
+ * 3. Consent-related tags ("consent", "consent-form") → procedure-specific
+ * 4. Title contains "consent" → procedure-specific
+ * 5. Default → shared (general forms)
+ * 
+ * @param template DocumentTemplate to check
+ * @returns true if procedure-specific, false if general/shared
+ */
+function isProcedureSpecificForm(template: DocumentTemplate): boolean {
+  const tags = template.tags || [];
+  const titleLower = template.title.toLowerCase();
+  
+  // Priority 1: Explicit "procedure-specific" tag → always procedure-specific
+  if (tags.includes('procedure-specific')) {
+    return true;
+  }
+  
+  // Priority 2: Explicit "shared" tag → always shared
+  if (tags.includes('shared')) {
+    return false;
+  }
+  
+  // Priority 3: Consent-related tags → procedure-specific
+  if (tags.some(tag => {
+    const tagLower = tag.toLowerCase();
+    return tagLower.includes('consent') || tagLower === 'consent-form';
+  })) {
+    return true;
+  }
+  
+  // Priority 4: Check title for "consent" → procedure-specific
+  if (titleLower.includes('consent')) {
+    return true;
+  }
+  
+  // Priority 5: Default → shared (general forms)
+  return false;
+}
+
+/**
+ * Checks if a form with the given templateId already exists in the appointment
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param templateId Template ID to check
+ * @param isUserForm Whether to check user-forms or doctor-forms subcollection
+ * @returns Existing FilledDocument or null if not found
+ */
+async function findExistingFormByTemplate(
+  db: Firestore,
+  appointmentId: string,
+  templateId: string,
+  isUserForm: boolean
+): Promise<FilledDocument | null> {
+  const formSubcollection = isUserForm
+    ? USER_FORMS_SUBCOLLECTION
+    : DOCTOR_FORMS_SUBCOLLECTION;
+  
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  const formsCollectionRef = collection(appointmentRef, formSubcollection);
+  
+  const q = query(
+    formsCollectionRef,
+    where('templateId', '==', templateId)
+  );
+  
+  const querySnapshot = await getDocs(q);
+  
+  if (querySnapshot.empty) {
+    return null;
+  }
+  
+  // Return the first matching form (should only be one for general forms)
+  const docSnap = querySnapshot.docs[0];
+  const data = docSnap.data() as FilledDocument;
+  
+  // Ensure id is populated from Firestore document ID if not in data
+  if (!data.id) {
+    data.id = docSnap.id;
+  }
+  
+  return data;
+}
+
+/**
+ * Initializes forms for an extended procedure using client-side Firestore
+ * Similar to DocumentManagerAdminService but for client-side usage
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param procedureId Procedure ID for forms
+ * @param technologyTemplates Technology documentation templates
+ * @param patientId Patient ID
+ * @param practitionerId Practitioner ID
+ * @param clinicId Clinic ID
+ * @returns Form initialization result
+ */
+export async function initializeFormsForExtendedProcedure(
+  db: Firestore,
+  appointmentId: string,
+  procedureId: string,
+  technologyTemplates: TechnologyDocumentationTemplate[],
+  patientId: string,
+  practitionerId: string,
+  clinicId: string
+): Promise<InitializeExtendedProcedureFormsResult> {
+  const initializedFormsInfo: LinkedFormInfo[] = [];
+  const pendingUserFormsIds: string[] = [];
+  const allLinkedFormIds: string[] = [];
+
+  if (!technologyTemplates || technologyTemplates.length === 0) {
+    console.log(
+      `[FormInit] No document templates to initialize for extended procedure ${procedureId} in appointment ${appointmentId}.`
+    );
+    return {
+      initializedFormsInfo,
+      pendingUserFormsIds,
+      allLinkedFormIds,
+    };
+  }
+
+  // Fetch all template documents
+  const templateIds = technologyTemplates.map((t) => t.templateId);
+  
+  // Note: Client-side Firestore doesn't support 'in' queries with more than 10 items
+  // We'll fetch templates one by one for now (can be optimized later)
+  const templatesMap = new Map<string, DocumentTemplate>();
+  
+  for (const templateId of templateIds) {
+    try {
+      const templateDoc = doc(db, DOCUMENTATION_TEMPLATES_COLLECTION, templateId);
+      const templateSnap = await getDoc(templateDoc);
+      
+      if (templateSnap.exists()) {
+        templatesMap.set(templateId, templateSnap.data() as DocumentTemplate);
+      } else {
+        console.warn(
+          `[FormInit] Template ${templateId} not found in Firestore.`
+        );
+      }
+    } catch (error) {
+      console.error(`[FormInit] Error fetching template ${templateId}:`, error);
+    }
+  }
+
+  // Initialize forms for each template (both user forms and doctor forms for extended procedures)
+  for (const templateRef of technologyTemplates) {
+    const template = templatesMap.get(templateRef.templateId);
+    if (!template) {
+      console.warn(
+        `[FormInit] Template ${templateRef.templateId} not found in Firestore.`
+      );
+      continue;
+    }
+
+    const isRequired = templateRef.isRequired;
+    const isUserForm = templateRef.isUserForm || false;
+    const formSubcollectionPath = isUserForm
+      ? USER_FORMS_SUBCOLLECTION
+      : DOCTOR_FORMS_SUBCOLLECTION;
+
+    // Check if form is procedure-specific or general/shared
+    const isProcedureSpecific = isProcedureSpecificForm(template);
+
+    // For general/shared forms, check if form already exists in appointment
+    let existingForm: FilledDocument | null = null;
+    if (!isProcedureSpecific) {
+      try {
+        existingForm = await findExistingFormByTemplate(
+          db,
+          appointmentId,
+          templateRef.templateId,
+          isUserForm
+        );
+        
+        if (existingForm) {
+          console.log(
+            `[FormInit] Found existing shared form ${existingForm.id} (template: ${template.id}) for appointment ${appointmentId}. Reusing instead of creating duplicate.`
+          );
+          
+          // Reuse existing form - add to linkedForms but don't create new document
+          // Note: We still add it to allLinkedFormIds to ensure it's tracked,
+          // but we don't add it again if it's already in the appointment's linkedForms
+          // (This will be handled by the caller merging the arrays)
+          
+          const linkedForm: LinkedFormInfo = {
+            formId: existingForm.id,
+            templateId: template.id,
+            templateVersion: template.version,
+            title: template.title,
+            isUserForm: isUserForm,
+            isRequired: isRequired,
+            sortingOrder: templateRef.sortingOrder,
+            status: existingForm.status || FilledDocumentStatus.PENDING,
+            path: `${APPOINTMENTS_COLLECTION}/${appointmentId}/${formSubcollectionPath}/${existingForm.id}`,
+            procedureId: procedureId, // Track which procedure this form belongs to
+          };
+          initializedFormsInfo.push(linkedForm);
+          
+          // Add to allLinkedFormIds if not already present (to avoid duplicates)
+          if (!allLinkedFormIds.includes(existingForm.id)) {
+            allLinkedFormIds.push(existingForm.id);
+          }
+          
+          // Add to pendingUserFormsIds if it's a required user form and not already completed
+          if (isUserForm && isRequired && existingForm.status === FilledDocumentStatus.PENDING) {
+            if (!pendingUserFormsIds.includes(existingForm.id)) {
+              pendingUserFormsIds.push(existingForm.id);
+            }
+          }
+          
+          continue; // Skip creating new form, reuse existing one
+        }
+      } catch (error) {
+        console.warn(
+          `[FormInit] Error checking for existing form (template: ${templateRef.templateId}):`,
+          error
+        );
+        // Continue to create new form if check fails
+      }
+    }
+
+    // Create new form document (either procedure-specific or general form not found)
+    const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+    const formsCollectionRef = collection(appointmentRef, formSubcollectionPath);
+    
+    const filledDocumentData = {
+      templateId: templateRef.templateId,
+      templateVersion: template.version,
+      isUserForm: isUserForm,
+      isRequired: isRequired,
+      appointmentId: appointmentId,
+      procedureId: procedureId,
+      patientId: patientId,
+      practitionerId: practitionerId,
+      clinicId: clinicId,
+      createdAt: serverTimestamp(),
+      updatedAt: serverTimestamp(),
+      values: {},
+      status: FilledDocumentStatus.PENDING,
+    };
+
+    try {
+      const docRef = await addDoc(formsCollectionRef, filledDocumentData);
+      const filledDocumentId = docRef.id;
+
+      // Update the document to include the id field in the data (for consistency)
+      await updateDoc(docRef, { id: filledDocumentId });
+
+      // Add to pendingUserFormsIds if it's a required user form
+      if (isUserForm && isRequired) {
+        pendingUserFormsIds.push(filledDocumentId);
+      }
+
+      allLinkedFormIds.push(filledDocumentId);
+
+      const linkedForm: LinkedFormInfo = {
+        formId: filledDocumentId,
+        templateId: template.id,
+        templateVersion: template.version,
+        title: template.title,
+        isUserForm: isUserForm,
+        isRequired: isRequired,
+        sortingOrder: templateRef.sortingOrder,
+        status: FilledDocumentStatus.PENDING,
+        path: docRef.path,
+        procedureId: procedureId, // Track which procedure this form belongs to
+      };
+      initializedFormsInfo.push(linkedForm);
+
+      const formType = isProcedureSpecific ? 'procedure-specific' : 'general/shared';
+      console.log(
+        `[FormInit] Created ${formType} FilledDocument ${filledDocumentId} (template: ${template.id}, isUserForm: ${isUserForm}) for extended procedure ${procedureId} in appointment ${appointmentId}.`
+      );
+    } catch (error) {
+      console.error(
+        `[FormInit] Error creating form for template ${templateRef.templateId}:`,
+        error
+      );
+    }
+  }
+
+  return { initializedFormsInfo, pendingUserFormsIds, allLinkedFormIds };
+}
+
+/**
+ * Removes all forms associated with a specific procedure from an appointment
+ * Only removes procedure-specific forms. Shared forms are kept if still referenced by other procedures.
+ * Removes both user forms and doctor forms
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param procedureId Procedure ID to remove forms for
+ * @returns Array of removed form IDs
+ */
+export async function removeFormsForExtendedProcedure(
+  db: Firestore,
+  appointmentId: string,
+  procedureId: string
+): Promise<string[]> {
+  const removedFormIds: string[] = [];
+
+  // Get appointment to check linkedForms
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  const appointmentSnap = await getDoc(appointmentRef);
+  
+  if (!appointmentSnap.exists()) {
+    console.warn(
+      `[FormInit] Appointment ${appointmentId} not found when removing forms for procedure ${procedureId}.`
+    );
+    return removedFormIds;
+  }
+
+  const appointment = appointmentSnap.data() as any;
+  const linkedForms = appointment.linkedForms || [];
+  
+  // Get all procedure IDs (main + extended) to check if shared forms are still referenced
+  const mainProcedureId = appointment.procedureId;
+  const extendedProcedureIds = appointment.metadata?.extendedProcedures?.map(
+    (ep: any) => ep.procedureId
+  ) || [];
+  const allProcedureIds = [mainProcedureId, ...extendedProcedureIds].filter(Boolean);
+  const remainingProcedureIds = allProcedureIds.filter((id: string) => id !== procedureId);
+
+  // Helper function to check if form appears multiple times in linkedForms (indicating it's shared)
+  const isFormSharedAndReferenced = (formId: string): boolean => {
+    const formEntries = linkedForms.filter((form: LinkedFormInfo) => form.formId === formId);
+    // If form appears multiple times in linkedForms, it's shared across procedures
+    return formEntries.length > 1;
+  };
+
+  // Remove from doctor forms subcollection
+  const doctorFormsRef = collection(appointmentRef, DOCTOR_FORMS_SUBCOLLECTION);
+  const doctorFormsQuery = query(
+    doctorFormsRef,
+    where('procedureId', '==', procedureId)
+  );
+  const doctorFormsSnap = await getDocs(doctorFormsQuery);
+
+  for (const formDoc of doctorFormsSnap.docs) {
+    try {
+      const formData = formDoc.data() as FilledDocument;
+      
+      // Fetch template to check if form is shared
+      let isShared = false;
+      if (formData.templateId) {
+        try {
+          const templateDoc = doc(db, DOCUMENTATION_TEMPLATES_COLLECTION, formData.templateId);
+          const templateSnap = await getDoc(templateDoc);
+          if (templateSnap.exists()) {
+            const template = templateSnap.data() as DocumentTemplate;
+            isShared = !isProcedureSpecificForm(template);
+          }
+        } catch (error) {
+          console.warn(
+            `[FormInit] Could not check template for form ${formDoc.id}, assuming procedure-specific:`,
+            error
+          );
+        }
+      }
+
+      // Only delete procedure-specific forms
+      // Shared forms are kept even if procedureId matches, as they may be used by other procedures
+      if (!isShared) {
+        await deleteDoc(formDoc.ref);
+        removedFormIds.push(formDoc.id);
+        console.log(
+          `[FormInit] Removed procedure-specific doctor form ${formDoc.id} for extended procedure ${procedureId} from appointment ${appointmentId}.`
+        );
+      } else {
+        // Check if form is still referenced by other procedures (appears multiple times in linkedForms)
+        if (isFormSharedAndReferenced(formDoc.id)) {
+          console.log(
+            `[FormInit] Skipped deletion of shared doctor form ${formDoc.id} - still referenced by other procedures.`
+          );
+        } else {
+          // Shared form but only referenced by this procedure (shouldn't happen, but handle it)
+          await deleteDoc(formDoc.ref);
+          removedFormIds.push(formDoc.id);
+          console.log(
+            `[FormInit] Removed shared doctor form ${formDoc.id} - no longer referenced by other procedures.`
+          );
+        }
+      }
+    } catch (error) {
+      console.error(
+        `[FormInit] Error removing doctor form ${formDoc.id}:`,
+        error
+      );
+    }
+  }
+
+  // Remove from user forms subcollection
+  const userFormsRef = collection(appointmentRef, USER_FORMS_SUBCOLLECTION);
+  const userFormsQuery = query(
+    userFormsRef,
+    where('procedureId', '==', procedureId)
+  );
+  const userFormsSnap = await getDocs(userFormsQuery);
+
+  for (const formDoc of userFormsSnap.docs) {
+    try {
+      const formData = formDoc.data() as FilledDocument;
+      
+      // Fetch template to check if form is shared
+      let isShared = false;
+      if (formData.templateId) {
+        try {
+          const templateDoc = doc(db, DOCUMENTATION_TEMPLATES_COLLECTION, formData.templateId);
+          const templateSnap = await getDoc(templateDoc);
+          if (templateSnap.exists()) {
+            const template = templateSnap.data() as DocumentTemplate;
+            isShared = !isProcedureSpecificForm(template);
+          }
+        } catch (error) {
+          console.warn(
+            `[FormInit] Could not check template for form ${formDoc.id}, assuming procedure-specific:`,
+            error
+          );
+        }
+      }
+
+      // Only delete procedure-specific forms
+      // Shared forms are kept even if procedureId matches, as they may be used by other procedures
+      if (!isShared) {
+        await deleteDoc(formDoc.ref);
+        removedFormIds.push(formDoc.id);
+        console.log(
+          `[FormInit] Removed procedure-specific user form ${formDoc.id} for extended procedure ${procedureId} from appointment ${appointmentId}.`
+        );
+      } else {
+        // Check if form is still referenced by other procedures (appears multiple times in linkedForms)
+        if (isFormSharedAndReferenced(formDoc.id)) {
+          console.log(
+            `[FormInit] Skipped deletion of shared user form ${formDoc.id} - still referenced by other procedures.`
+          );
+        } else {
+          // Shared form but only referenced by this procedure (shouldn't happen, but handle it)
+          await deleteDoc(formDoc.ref);
+          removedFormIds.push(formDoc.id);
+          console.log(
+            `[FormInit] Removed shared user form ${formDoc.id} - no longer referenced by other procedures.`
+          );
+        }
+      }
+    } catch (error) {
+      console.error(
+        `[FormInit] Error removing user form ${formDoc.id}:`,
+        error
+      );
+    }
+  }
+
+  return removedFormIds;
+}
+
+/**
+ * Gets all forms associated with a specific procedure in an appointment
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param procedureId Procedure ID
+ * @returns Array of form IDs
+ */
+export async function getFormsForExtendedProcedure(
+  db: Firestore,
+  appointmentId: string,
+  procedureId: string
+): Promise<string[]> {
+  const formIds: string[] = [];
+
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+
+  // Query doctor forms for this procedure
+  const doctorFormsRef = collection(appointmentRef, DOCTOR_FORMS_SUBCOLLECTION);
+  const doctorFormsQuery = query(
+    doctorFormsRef,
+    where('procedureId', '==', procedureId)
+  );
+  const doctorFormsSnap = await getDocs(doctorFormsQuery);
+  doctorFormsSnap.docs.forEach(doc => formIds.push(doc.id));
+
+  // Query user forms for this procedure
+  const userFormsRef = collection(appointmentRef, USER_FORMS_SUBCOLLECTION);
+  const userFormsQuery = query(
+    userFormsRef,
+    where('procedureId', '==', procedureId)
+  );
+  const userFormsSnap = await getDocs(userFormsQuery);
+  userFormsSnap.docs.forEach(doc => formIds.push(doc.id));
+
+  return formIds;
+}