Automations 101: The Absolute Guide

function doPost(e) {
  const data = JSON.parse(e.postData.contents);
  const sheet = SpreadsheetApp.openById('SHEET_ID').getSheetByName('Leads');
  sheet.appendRow([data.name, data.phone, data.email, data.service, new Date()]);
  MailApp.sendEmail('rep@company.com', 'New Lead', `Name: ${data.name} Phone: ${data.phone}`);
  return ContentService.createTextOutput('OK');
}

// In Make's "Custom webhook" module
const rawPayload = req.body;
const normalized = {
  event_type: rawPayload.event || 'lead_submitted',
  contact: {
    name: rawPayload.name || rawPayload.contact_name || '',
    phone: rawPayload.phone || rawPayload.caller_number || '',
    email: rawPayload.email || '',
    service_type: rawPayload.service_type || rawPayload.project_type || '',
    budget_range: rawPayload.budget_range || null,
    timeline: rawPayload.timeline || null,
  },
  source: rawPayload.utm_source || rawPayload.source || 'direct',
  campaign: rawPayload.utm_campaign,
  gclid: rawPayload.gclid,
  timestamp: new Date().toISOString(),
  idempotency_key: `${rawPayload.phone || rawPayload.email}_${Date.now()}`
};
return normalized;

// Search for existing contact by phone (primary) or email (fallback)
const searchUrl = `https://rest.gohighlevel.com/v1/contacts/lookup?phone=${encodeURIComponent(contact.phone)}`;
const existing = await fetch(searchUrl, {
  headers: { 'Authorization': 'Bearer YOUR_GHL_API_KEY' }
}).then(res => res.json());

if (existing.contacts && existing.contacts.length > 0) {
  // Merge: add new source tag, update custom fields, preserve oldest timestamp
  const mergePayload = {
    tags: [`source:${contact.source}`],
    customField: {
      source: contact.source,
      campaign: contact.campaign,
      last_contact: new Date().toISOString()
    }
  };
  await fetch(`https://rest.gohighlevel.com/v1/contacts/${existing.contacts[0].id}`, {
    method: 'PUT',
    headers: { 'Authorization': 'Bearer YOUR_GHL_API_KEY', 'Content-Type': 'application/json' },
    body: JSON.stringify(mergePayload)
  });
  await logToAirtable({ event_type: 'duplicate_merged', contact_id: existing.contacts[0].id });
  return; // Stop, do not create new contact
}

const createPayload = {
  name: contact.name,
  phone: contact.phone,
  email: contact.email,
  customField: {
    source: contact.source,
    campaign: contact.campaign,
    service_type: contact.service_type,
    budget_range: contact.budget_range,
    timeline: contact.timeline,
    lead_score: 0,
  },
  tags: [`source:${contact.source}`, 'lead:new']
};
const newContact = await fetch('https://rest.gohighlevel.com/v1/contacts/', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer YOUR_GHL_API_KEY', 'Content-Type': 'application/json' },
  body: JSON.stringify(createPayload)
}).then(res => res.json());

// Idempotency: check if auto:welcome_sent tag exists
const tagsUrl = `https://rest.gohighlevel.com/v1/contacts/${newContact.id}/tags`;
const existingTags = await fetch(tagsUrl, {
  headers: { 'Authorization': 'Bearer YOUR_GHL_API_KEY' }
}).then(res => res.json());

if (!existingTags.tags.includes('auto:welcome_sent') && contact.sms_consent !== false) {
  const smsPayload = {
    message: `Hi ${contact.name}, thanks for reaching out! A specialist will contact you within 5 minutes.`,
    from: 'YOUR_GHL_NUMBER'
  };
  await fetch(`https://rest.gohighlevel.com/v1/contacts/${newContact.id}/sms`, {
    method: 'POST',
    headers: { 'Authorization': 'Bearer YOUR_GHL_API_KEY', 'Content-Type': 'application/json' },
    body: JSON.stringify(smsPayload)
  });
  // Add idempotency tag
  await fetch(`https://rest.gohighlevel.com/v1/contacts/${newContact.id}/tags`, {
    method: 'POST',
    headers: { 'Authorization': 'Bearer YOUR_GHL_API_KEY' },
    body: JSON.stringify({ tags: ['auto:welcome_sent'] })
  });
} else if (!contact.sms_consent) {
  // Send email instead
  await sendWelcomeEmail(contact);
}

const dueDate = new Date(Date.now() + 5 * 60000).toISOString(); // 5 minutes
const taskPayload = {
  title: `Call lead ${contact.name} – ${contact.service_type || 'inquiry'}`,
  assignedTo: 'round_robin', // GHL will assign based on territory or workload
  dueDate: dueDate,
  priority: (contact.source === 'google' || contact.budget_range === 'high') ? 'high' : 'normal',
  description: `Phone: ${contact.phone} | Email: ${contact.email} | Source: ${contact.source} | Campaign: ${contact.campaign}`
};
await fetch('https://rest.gohighlevel.com/v1/tasks', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer YOUR_GHL_API_KEY' },
  body: JSON.stringify(taskPayload)
});

await fetch(`https://rest.gohighlevel.com/v1/contacts/${newContact.id}/stage`, {
  method: 'PUT',
  headers: { 'Authorization': 'Bearer YOUR_GHL_API_KEY' },
  body: JSON.stringify({ stageId: 'YOUR_CONTACTED_STAGE_ID' })
});

async function logToAirtable(event) {
  const airtableUrl = 'https://api.airtable.com/v0/YOUR_BASE_ID/event_log';
  await fetch(airtableUrl, {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_AIRTABLE_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      fields: {
        event_type: event.event_type,
        contact_id: event.contact_id || newContact.id,
        timestamp: new Date().toISOString(),
        source: contact.source,
        outcome: 'success',
        metadata: JSON.stringify({ pattern: 'Pattern 1', attempt: 1 })
      }
    })
  });
}

if (contact.source === 'google' || contact.budget_range === 'high') {
  await fetch('YOUR_SLACK_WEBHOOK', {
    method: 'POST',
    body: JSON.stringify({
      text: `🔥 Hot lead from ${contact.source}: ${contact.name} – ${contact.service_type || 'inquiry'}\nCRM: https://gohighlevel.com/contact/${newContact.id}`
    })
  });
}

const tags = await getContactTags(contactId);
if (tags.includes('auto:welcome_sent') || tags.includes('manual:lead_creation')) {
  console.log('Lead already processed or manually created; skipping intake automation.');
  return;
}

function findDuplicates() {
  var sheet = SpreadsheetApp.getActiveSheet();
  var data = sheet.getDataRange().getValues();
  var phones = data.map(row => row[1]); // assuming phone in column B
  for (var i = 1; i < data.length; i++) {
    var phone = data[i][1];
    var count = phones.filter(p => p === phone).length;
    if (count > 1) sheet.getRange(i+1, 1, 1, data[0].length).setBackground('#FFCCCC');
  }
}

// Called on every lead creation attempt
async function findExistingContact(contact) {
  // Primary: search by phone
  let phoneUrl = `https://rest.gohighlevel.com/v1/contacts/lookup?phone=${encodeURIComponent(contact.phone)}`;
  let phoneRes = await fetch(phoneUrl, {
    headers: { 'Authorization': 'Bearer YOUR_GHL_API_KEY' }
  });
  let phoneData = await phoneRes.json();
  if (phoneData.contacts && phoneData.contacts.length > 0) {
    return { match: true, contact: phoneData.contacts[0], method: 'phone' };
  }
  
  // Fallback: search by email
  let emailUrl = `https://rest.gohighlevel.com/v1/contacts/lookup?email=${encodeURIComponent(contact.email)}`;
  let emailRes = await fetch(emailUrl, {
    headers: { 'Authorization': 'Bearer YOUR_GHL_API_KEY' }
  });
  let emailData = await emailRes.json();
  if (emailData.contacts && emailData.contacts.length > 0) {
    return { match: true, contact: emailData.contacts[0], method: 'email' };
  }
  
  return { match: false };
}

async function mergeContact(existing, newContactData) {
  // 1. Preserve oldest created_at
  const existingCreated = new Date(existing.createdAt);
  const newCreated = new Date(newContactData.createdAt || Date.now());
  const finalCreated = existingCreated < newCreated ? existing.createdAt : newContactData.createdAt;
  
  // 2. Merge source tags
  let existingSources = existing.customField?.source ? existing.customField.source.split(',') : [];
  if (!existingSources.includes(newContactData.source)) {
    existingSources.push(newContactData.source);
  }
  const mergedSources = existingSources.join(',');
  
  // 3. Determine most advanced stage
  const stageOrder = ['NEW_LEAD', 'CONTACTED', 'QUALIFIED', 'APPOINTMENT_BOOKED', 'APPOINTMENT_COMPLETED', 'ESTIMATE_SENT', 'DECISION_PENDING', 'CLOSED_WON', 'CLOSED_LOST'];
  const existingStageIndex = stageOrder.indexOf(existing.stage);
  const newStageIndex = stageOrder.indexOf(newContactData.stage || 'NEW_LEAD');
  const finalStage = existingStageIndex >= newStageIndex ? existing.stage : newContactData.stage;
  
  // 4. Merge tags (unique)
  const existingTags = existing.tags || [];
  const newTags = newContactData.tags || [];
  const mergedTags = [...new Set([...existingTags, ...newTags])];
  
  // 5. Update CRM
  const updatePayload = {
    id: existing.id,
    customField: {
      ...existing.customField,
      source: mergedSources,
      last_contacted: new Date().toISOString()
    },
    stage: finalStage,
    tags: mergedTags
  };
  // Only update created_at if we need to preserve the oldest (GHL may not allow overwrite; instead store in custom field)
  updatePayload.customField.original_created_at = finalCreated;
  
  await fetch(`https://rest.gohighlevel.com/v1/contacts/${existing.id}`, {
    method: 'PUT',
    headers: { 'Authorization': 'Bearer YOUR_GHL_API_KEY', 'Content-Type': 'application/json' },
    body: JSON.stringify(updatePayload)
  });
  
  // 6. Suppress duplicate welcome SMS: add tag auto:welcome_sent if the new lead would have triggered it
  if (newContactData.sms_consent && !existingTags.includes('auto:welcome_sent')) {
    await fetch(`https://rest.gohighlevel.com/v1/contacts/${existing.id}/tags`, {
      method: 'POST',
      headers: { 'Authorization': 'Bearer YOUR_GHL_API_KEY' },
      body: JSON.stringify({ tags: ['auto:welcome_sent'] })
    });
  }
  
  return { merged: true, contactId: existing.id };
}

// If phone and email searches return different contacts
if (phoneData.contacts && emailData.contacts && phoneData.contacts[0].id !== emailData.contacts[0].id) {
  // Queue for manual review
  const reviewTask = {
    title: `Potential duplicate: phone contact ${phoneData.contacts[0].id} vs email contact ${emailData.contacts[0].id}`,
    assignedTo: 'ops_queue',
    dueDate: new Date(Date.now() + 24 * 60 * 60000).toISOString(),
    description: `Phone: ${contact.phone}, Email: ${contact.email}. Please review and merge manually.`
  };
  await fetch('https://rest.gohighlevel.com/v1/tasks', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer YOUR_GHL_API_KEY' },
    body: JSON.stringify(reviewTask)
  });
  await logToAirtable({ event_type: 'duplicate_low_confidence', contact_data: contact });
}

// Get all contacts updated in last 7 days
const allContacts = await fetch('https://rest.gohighlevel.com/v1/contacts/?limit=100&updatedAt=last_7_days', {
  headers: { 'Authorization': 'Bearer YOUR_GHL_API_KEY' }
}).then(res => res.json());

// Group by phone and email
const phoneMap = new Map();
allContacts.contacts.forEach(contact => {
  if (contact.phone) {
    if (!phoneMap.has(contact.phone)) phoneMap.set(contact.phone, []);
    phoneMap.get(contact.phone).push(contact);
  }
});

// For each group with >1 contact, apply merge logic
for (let [phone, contacts] of phoneMap.entries()) {
  if (contacts.length > 1) {
    // Sort by created_at, oldest first
    contacts.sort((a,b) => new Date(a.createdAt) - new Date(b.createdAt));
    const primary = contacts[0];
    const duplicates = contacts.slice(1);
    for (let dup of duplicates) {
      await mergeContact(primary, dup);
      // Optionally delete duplicate contact after merge
    }
  }
}

async function logMerge(primaryId, duplicateId, method) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/event_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer YOUR_AIRTABLE_API_KEY', 'Content-Type': 'application/json' },
    body: JSON.stringify({
      fields: {
        event_type: 'duplicate_merged',
        contact_id: primaryId,
        secondary_contact_id: duplicateId,
        merge_method: method, // 'phone_exact', 'email_exact', 'manual', 'auto_audit'
        timestamp: new Date().toISOString(),
        outcome: 'success'
      }
    })
  });
}

// Custom JavaScript in GHL button
const primaryId = input.primaryContactId;
const secondaryId = input.secondaryContactId;
await fetch(`https://rest.gohighlevel.com/v1/contacts/${primaryId}/tasks?assignTo=${secondaryId}`, {
  method: 'PATCH',
  headers: { 'Authorization': 'Bearer GHL_API_KEY' }
});
await fetch(`https://rest.gohighlevel.com/v1/contacts/${secondaryId}`, {
  method: 'DELETE',
  headers: { 'Authorization': 'Bearer GHL_API_KEY' }
});
await logToAirtable({ event_type: 'manual_merge' });

# In GHL pipeline settings: 
# Round Robin Assignment: enabled
# Assignment order: sequential or random
# Users: rep1@company.com, rep2@company.com, rep3@company.com

async function getTerritoryRep(zipCode) {
  const airtableUrl = 'https://api.airtable.com/v0/YOUR_BASE_ID/territory_rules';
  const response = await fetch(airtableUrl, {
    headers: { 'Authorization': 'Bearer YOUR_AIRTABLE_API_KEY' }
  });
  const records = await response.json();
  // Find matching zip prefix
  for (let rule of records.records) {
    const range = rule.fields.zip_prefix.split('-');
    if (range.length === 2) {
      const min = parseInt(range[0]);
      const max = parseInt(range[1]);
      const zip = parseInt(zipCode);
      if (zip >= min && zip <= max) {
        return rule.fields.rep_email;
      }
    } else if (rule.fields.zip_prefix === '*') {
      return { type: 'round_robin' };
    }
  }
  return { type: 'round_robin' };
}

async function getNextRoundRobinRep() {
  // Fetch reps with current open tasks and capacity
  const repsUrl = 'https://api.airtable.com/v0/YOUR_BASE_ID/rep_capacity?sort%5B0%5D%5Bfield%5D=last_assigned_at&sort%5B0%5D%5Bdirection%5D=asc';
  const reps = await fetch(repsUrl, {
    headers: { 'Authorization': 'Bearer YOUR_AIRTABLE_API_KEY' }
  }).then(res => res.json());
  
  // Filter reps under capacity
  const availableReps = reps.records.filter(rep => 
    rep.fields.current_open_tasks < rep.fields.max_capacity
  );
  
  if (availableReps.length === 0) {
    // No available reps – escalate
    await escalateNoAvailableRep();
    return { error: 'no_available_rep' };
  }
  
  // Round‑robin: pick the one with oldest last_assigned_at
  const selected = availableReps[0]; // already sorted by last_assigned_at asc
  return selected.fields.rep_email;
}

async function assignLeadToRep(contactId, repEmail) {
  // GHL: update custom field 'assigned_rep' and optionally assign task
  const updatePayload = {
    customField: {
      assigned_rep: repEmail
    },
    tags: [`rep:${repEmail}`]
  };
  await fetch(`https://rest.gohighlevel.com/v1/contacts/${contactId}`, {
    method: 'PUT',
    headers: { 'Authorization': 'Bearer GHL_API_KEY', 'Content-Type': 'application/json' },
    body: JSON.stringify(updatePayload)
  });
  
  // Create task assigned to that rep
  const taskPayload = {
    title: `New lead assigned: follow up within 5 min`,
    assignedTo: repEmail,
    dueDate: new Date(Date.now() + 5*60000).toISOString(),
    contactId: contactId
  };
  await fetch('https://rest.gohighlevel.com/v1/tasks', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer GHL_API_KEY' },
    body: JSON.stringify(taskPayload)
  });
}

async function escalateNoAvailableRep() {
  // Create ops task
  const task = {
    title: 'No available sales rep – lead unassigned',
    assignedTo: 'ops_manager@company.com',
    dueDate: new Date(Date.now() + 60*60000).toISOString(),
    description: 'All reps at capacity. Review rep capacity table and reassign.'
  };
  await fetch('https://rest.gohighlevel.com/v1/tasks', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer GHL_API_KEY' },
    body: JSON.stringify(task)
  });
  // Send Slack alert to ops channel
  await fetch('SLACK_WEBHOOK_URL', {
    method: 'POST',
    body: JSON.stringify({ text: '🚨 No available sales rep for new lead. Please adjust capacity.' })
  });
}

async function logAssignment(contactId, repEmail, method, territoryInfo = null) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/assignment_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY', 'Content-Type': 'application/json' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        assigned_rep: repEmail,
        assignment_method: method, // 'territory', 'round_robin', 'manual_override'
        territory: territoryInfo,
        timestamp: new Date().toISOString()
      }
    })
  });
}

async function incrementRepTaskCount(repEmail) {
  // Find rep record in Airtable, increment current_open_tasks by 1
  const findUrl = `https://api.airtable.com/v0/YOUR_BASE_ID/rep_capacity?filterByFormula={rep_email}="${repEmail}"`;
  const record = await fetch(findUrl, { headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' } }).then(r => r.json());
  if (record.records.length) {
    const recordId = record.records[0].id;
    const currentCount = record.records[0].fields.current_open_tasks;
    await fetch(`https://api.airtable.com/v0/YOUR_BASE_ID/rep_capacity/${recordId}`, {
      method: 'PATCH',
      headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY', 'Content-Type': 'application/json' },
      body: JSON.stringify({ fields: { current_open_tasks: currentCount + 1, last_assigned_at: new Date().toISOString() } })
    });
  }
}

// Reassign button in GHL
const newRep = input.newRepEmail;
const contactId = input.contactId;
// Remove old rep tag
await removeTag(contactId, `rep:${currentRep}`);
// Add new rep tag
await addTag(contactId, `rep:${newRep}`);
// Update assigned_rep custom field
await updateCustomField(contactId, 'assigned_rep', newRep);
// Log override
await logToAirtable({ event_type: 'manual_reassignment', old_rep: currentRep, new_rep: newRep });

// GHL workflow custom logic (pseudocode)
IF reply_text CONTAINS (“budget” OR “$” OR “price”) 
  THEN add tag “intent:maybe”
  create task “Check qualification for lead”
ELSE add tag “intent:low”

// In Make webhook from GHL
const leadReply = {
  contact_id: rawPayload.contact_id,
  message: rawPayload.message_text,
  channel: rawPayload.channel, // 'sms', 'email', 'chat'
  current_stage: rawPayload.stage,
  service_type: rawPayload.service_type || 'unknown',
  previous_qualification_attempts: rawPayload.qualification_attempts || 0,
  timestamp: new Date().toISOString()
};

You are a lead qualification assistant for a home improvement company. 
Extract the following fields from the customer's message:
- budget_range: one of "low" (<$5k), "medium" ($5k-$15k), "high" (>$15k), or "unknown"
- timeline: one of "0-30d", "30-90d", "90+d", or "unknown"
- authority: one of "homeowner", "spouse", "renter", "investor", or "unknown"
- need: integer 1-5 (1 = just exploring, 5 = urgent/need done ASAP), or null if not specified
- overall_intent: "high", "medium", or "low"
- confidence: float 0-1

Output ONLY valid JSON. Do not include any other text.

Customer message: {message}
Service type: {service_type}

async function classifyLead(message, serviceType, retries = 3) {
  const prompt = `Customer message: ${message}\nService type: ${serviceType}`;
  const response = await fetch('https://api.openai.com/v1/chat/completions', {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${OPENAI_API_KEY}`, 'Content-Type': 'application/json' },
    body: JSON.stringify({
      model: 'gpt-4o-mini',
      messages: [
        { role: 'system', content: SYSTEM_PROMPT },
        { role: 'user', content: prompt }
      ],
      temperature: 0,
      max_tokens: 200
    })
  });
  if (!response.ok && retries > 0) {
    await new Promise(resolve => setTimeout(resolve, 2000));
    return classifyLead(message, serviceType, retries - 1);
  }
  const data = await response.json();
  const result = JSON.parse(data.choices[0].message.content);
  return result;
}

function calculateScore(budget, timeline, authority, need, source, engagement) {
  let score = 0;
  // Budget
  if (budget === 'high') score += 30;
  else if (budget === 'medium') score += 15;
  // Timeline
  if (timeline === '0-30d') score += 30;
  else if (timeline === '30-90d') score += 15;
  // Authority
  if (authority === 'homeowner') score += 20;
  else if (authority === 'spouse') score += 10;
  // Need (1-5)
  if (need >= 4) score += 20;
  else if (need === 3) score += 10;
  // Source bonus
  if (source === 'referral') score += 15;
  else if (source === 'google') score += 10;
  else if (source === 'facebook') score += 5;
  // Engagement signals
  if (engagement.has_replied) score += 5;
  if (engagement.estimate_opened) score += 10;
  return Math.min(score, 100);
}

async function processClassification(leadId, message) {
  let result;
  try {
    result = await classifyLead(message, serviceType);
  } catch (error) {
    // Fallback to rule‑based
    result = ruleBasedFallback(message);
  }
  
  if (result.confidence < 0.6) {
    // Low confidence: create task for human review
    await createTask(leadId, 'Manual qualification needed – AI low confidence');
    await logEvent(leadId, 'ai_low_confidence', result);
    return;
  }
  
  const score = calculateScore(
    result.budget_range, result.timeline, result.authority, result.need,
    leadSource, { has_replied: true, estimate_opened: false }
  );
  
  if (score >= 70) {
    await updateCRM(leadId, { lead_score: score, intent: 'high' });
    await changeStage(leadId, 'QUALIFIED');
    await sendBookingLink(leadId);
  } 
  else if (score >= 40 && score < 70) {
    // Medium intent – send clarifying question
    await sendClarifyingSMS(leadId, result.missing_fields);
    await incrementQualificationAttempt(leadId);
    // If already attempted twice, move to human
    if (attempts >= 2) {
      await createTask(leadId, 'Clarification failed – manual review');
      await changeStage(leadId, 'REACTIVATION');
    }
  }
  else {
    // Low intent
    await updateCRM(leadId, { lead_score: score, intent: 'low' });
    await addToNurtureSequence(leadId);
  }
  
  await logToAirtable(leadId, 'ai_classification', result, score);
}

function ruleBasedFallback(message) {
  const msg = message.toLowerCase();
  let intent = 'medium';
  let budget_range = 'unknown';
  let timeline = 'unknown';
  let authority = 'unknown';
  let need = null;
  
  if (msg.includes('budget') || msg.includes('$') || msg.includes('price')) budget_range = 'medium';
  if (msg.includes('urgent') || msg.includes('asap') || msg.includes('immediately')) timeline = '0-30d';
  if (msg.includes('homeowner') || msg.includes('own the home')) authority = 'homeowner';
  if (msg.includes('just looking') || msg.includes('exploring')) intent = 'low';
  if (msg.includes('ready to book') || msg.includes('start next week')) intent = 'high';
  
  return {
    budget_range, timeline, authority, need,
    overall_intent: intent,
    confidence: 0.5, // low confidence, but better than nothing
    is_fallback: true
  };
}

async function sendClarifyingSMS(leadId, missingFields) {
  const phone = await getLeadPhone(leadId);
  let question = '';
  if (missingFields.includes('budget')) question += ' What is your rough budget? (Low under $5k, Medium $5k-$15k, High over $15k)';
  if (missingFields.includes('timeline')) question += ' When are you hoping to start? (0-30 days, 30-90 days, 90+ days)';
  if (missingFields.includes('authority')) question += ' Are you the homeowner? (Yes/No)';
  
  const sms = `Thanks. To help you better:${question} Reply with your answers.`;
  await sendSMS(phone, sms);
  await addTag(leadId, 'auto:clarification_sent');
  // Start 24h timer – if no reply, move to reactivation
  await startTimer(leadId, 'clarification_timeout', 24 * 60 * 60);
}

async function logToAirtable(leadId, eventType, aiResult, score) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/event_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        event_type: eventType,
        contact_id: leadId,
        timestamp: new Date().toISOString(),
        metadata: JSON.stringify({ ai_result: aiResult, score: score })
      }
    })
  });
}

const tags = await getContactTags(leadId);
if (tags.includes('auto:qualification_processed') || tags.includes('manual:override_qualification')) {
  console.log('Qualification already processed or manually overridden; skipping.');
  return;
}

// GHL workflow action
const calendarLink = 'https://calendly.com/company/discovery-call';
sendSMS(contact.phone, `Book your consultation here: ${calendarLink}`);
sendEmail(contact.email, `Click here to schedule: ${calendarLink}`);

function generateBookingLink(leadId, serviceType, repId) {
  // Create a unique, time‑bounded token for security
  const token = createJWT({ leadId, exp: Date.now() + 7*24*60*60*1000 });
  // Use GHL’s native booking link with pre‑filled fields
  return `https://app.gohighlevel.com/booking/${repId}?leadId=${leadId}&service=${encodeURIComponent(serviceType)}&token=${token}`;
}

async function sendBookingInvite(leadId, phone, email, serviceType, repId) {
  const link = generateBookingLink(leadId, serviceType, repId);
  const sms = `Great news, ${name}! You qualify for a free consultation. Pick a time: ${link} (Booking takes 30 seconds)`;
  const emailSubject = `Book your ${serviceType} consultation`;
  const emailBody = `Click here to schedule: ${link}`;
  
  // Send SMS if consent exists
  const tags = await getContactTags(leadId);
  if (!tags.includes('sms:opt_out')) {
    await sendSMS(phone, sms);
  }
  // Always send email (CAN‑SPAM allows transactional)
  await sendEmail(email, emailSubject, emailBody);
  
  // Idempotency: mark as sent
  await addTag(leadId, 'auto:booking_invite_sent');
}

// When an appointment is created in GHL
const webhookPayload = {
  event: 'appointment.created',
  contact_id: payload.contactId,
  appointment_id: payload.appointmentId,
  start_time: payload.startTime,
  end_time: payload.endTime,
  timezone: payload.timezone,
  location: payload.location
};

async function processBooking(webhookPayload) {
  const contactId = webhookPayload.contact_id;
  
  // Update CRM
  await updateCRM(contactId, {
    appointment_time: webhookPayload.start_time,
    appointment_timezone: webhookPayload.timezone,
    appointment_id: webhookPayload.appointment_id
  });
  await changeStage(contactId, 'APPOINTMENT_BOOKED');
  
  // Send confirmation message
  const start = new Date(webhookPayload.start_time);
  const formattedDate = start.toLocaleString('en-US', { 
    timeZone: webhookPayload.timezone,
    weekday: 'short', month: 'short', day: 'numeric', hour: 'numeric', minute: 'numeric'
  });
  const confirmSMS = `Confirmed! Your consultation is on ${formattedDate} ${webhookPayload.timezone}. Location: ${webhookPayload.location}. Add to calendar: [calendar link] To reschedule, reply RESCHEDULE.`;
  await sendSMS(contactPhone, confirmSMS);
  
  // Cancel the 48h booking timer (if still running)
  await cancelTimer(contactId, 'booking_timer');
  
  // Log to Airtable
  await logEvent(contactId, 'appointment_booked', webhookPayload);
}

async function scheduleCustomReminders(appointmentId, startTime, timezone, phone) {
  const localStart = new Date(startTime);
  const reminderTimes = [24*60*60, 3*60*60, 1*60*60]; // seconds before
  
  for (let secondsBefore of reminderTimes) {
    const reminderTime = new Date(localStart.getTime() - secondsBefore * 1000);
    const now = new Date();
    if (reminderTime > now) {
      // Schedule webhook via Make (or use GHL’s built‑in)
      await scheduleMessage(reminderTime, phone, generateReminderMessage(secondsBefore));
    }
  }
}

async function checkForNoShow(appointmentId) {
  const appointment = await getAppointment(appointmentId);
  const endTime = new Date(appointment.end_time);
  const now = new Date();
  const gracePeriod = 30 * 60 * 1000; // 30 minutes
  
  if (now > new Date(endTime.getTime() + gracePeriod) && appointment.status !== 'completed') {
    // No‑show detected
    const contactId = appointment.contact_id;
    await sendSMS(contactPhone, 'We missed you! Click here to reschedule: [reschedule link]');
    await changeStage(contactId, 'REACTIVATION');
    await addTag(contactId, 'no_show');
    await createTask(contactId, 'Follow up with no‑show lead – offer reschedule');
    await logEvent(contactId, 'appointment_no_show', { appointment_id: appointmentId });
  }
}

// Triggered by lead replying “RESCHEDULE” to confirmation SMS
async function handleReschedule(contactId, currentAppointmentId) {
  // Generate a new booking link with same rep
  const newLink = generateBookingLink(contactId, serviceType, repId);
  await sendSMS(contactPhone, `Reschedule here: ${newLink}`);
  // Cancel old appointment (GHL API)
  await cancelAppointment(currentAppointmentId);
  await addTag(contactId, 'reschedule_requested');
}

async function handleCancellation(contactId, appointmentId) {
  await sendSMS(contactPhone, 'Your appointment has been cancelled. To rebook, reply BOOK.');
  await cancelAppointment(appointmentId);
  await changeStage(contactId, 'QUALIFIED'); // Allow rebooking
  await logEvent(contactId, 'appointment_cancelled');
}

async function logAppointmentEvent(contactId, eventType, details) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/event_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        event_type: eventType, // 'appointment_booked', 'appointment_reminder_sent', 'appointment_no_show', 'appointment_rescheduled'
        contact_id: contactId,
        timestamp: new Date().toISOString(),
        metadata: JSON.stringify(details)
      }
    })
  });
}

const tags = await getContactTags(leadId);
if (tags.includes('auto:booking_invite_sent') || tags.includes('manual:booking')) {
  console.log('Booking already processed; skipping invitation.');
  return;
}

# GHL appointment settings
Reminders: 24h before appointment
Channel: Email only
Template: "Reminder: Your appointment is on {date} at {time}."

async function scheduleConfirmationRequest(appointmentId, contactId, startTime, timezone, phone, email) {
  const localStart = new Date(startTime);
  const confirmRequestTime = new Date(localStart.getTime() - 48 * 60 * 60 * 1000);
  const now = new Date();
  
  if (confirmRequestTime > now) {
    // Schedule webhook via Make (or use GHL’s delayed actions)
    await scheduleMessage(confirmRequestTime, contactId, 'confirm_request');
  } else {
    // Already less than 48h before, send immediately
    await sendConfirmationRequest(contactId, phone, email, localStart, timezone);
  }
}

async function sendConfirmationRequest(contactId, phone, email, startTime, timezone) {
  const formatted = startTime.toLocaleString('en-US', { timeZone: timezone, weekday: 'short', month: 'short', day: 'numeric', hour: 'numeric', minute: 'numeric' });
  const sms = `Reminder: Your consultation is on ${formatted}. Reply YES to confirm or RESCHEDULE.`;
  const emailSubject = `Confirm your consultation – ${formatted}`;
  const emailBody = `Please reply to this email with "YES" to confirm, or click here to reschedule: [reschedule link]`;
  
  if (!hasOptedOutSMS(contactId)) await sendSMS(phone, sms);
  await sendEmail(email, emailSubject, emailBody);
  
  // Start timer: if no confirmation in 24h, send second reminder
  await startTimer(contactId, 'confirm_reminder', 24 * 60 * 60);
}

async function handleConfirmation(contactId, replyText) {
  const lower = replyText.toLowerCase();
  if (lower.includes('yes') || lower.includes('confirm') || lower === 'y') {
    await addTag(contactId, 'appointment:confirmed');
    await updateCustomField(contactId, 'appointment_confirmed', true);
    await cancelTimer(contactId, 'confirm_reminder'); // cancel second reminder
    await logEvent(contactId, 'appointment_confirmed');
    // Optionally send thank you
    await sendSMS(contactPhone, 'Thanks for confirming! We look forward to seeing you.');
  } 
  else if (lower.includes('reschedule') || lower.includes('change')) {
    await handleReschedule(contactId);
  }
}

async function sendSecondReminder(contactId, startTime, timezone, phone, email) {
  const tags = await getContactTags(contactId);
  if (tags.includes('appointment:confirmed')) return; // already confirmed
  
  const formatted = startTime.toLocaleString('en-US', { timeZone: timezone });
  const sms = `Reminder: Your consultation is tomorrow at ${formatted}. Reply YES to confirm or RESCHEDULE.`;
  const emailSubject = `Tomorrow: Your consultation at ${formatted}`;
  await sendSMS(phone, sms);
  await sendEmail(email, emailSubject, `Please confirm by replying YES to this email.`);
  await logEvent(contactId, 'reminder_24h_sent');
}

async function sendFinalReminders(contactId, startTime, timezone, phone, email, location) {
  const tags = await getContactTags(contactId);
  const confirmed = tags.includes('appointment:confirmed');
  
  // 3h before
  const threeHourReminder = new Date(startTime.getTime() - 3 * 60 * 60 * 1000);
  await scheduleMessage(threeHourReminder, contactId, async () => {
    const sms = `Reminder: Your appointment is in 3 hours at ${location}. Call us at XXX if you need to reschedule.`;
    await sendSMS(phone, sms);
    await logEvent(contactId, 'reminder_3h_sent');
  });
  
  // 1h before (with meeting link if virtual)
  const oneHourReminder = new Date(startTime.getTime() - 1 * 60 * 60 * 1000);
  await scheduleMessage(oneHourReminder, contactId, async () => {
    const link = location.includes('virtual') ? ` Join here: ${meetingLink}` : '';
    const sms = `Your appointment starts in 1 hour.${link} Reply HELP for assistance.`;
    await sendSMS(phone, sms);
    await sendEmail(email, 'Your appointment starts soon', `Join here: ${meetingLink || 'We will call you.'}`);
    await logEvent(contactId, 'reminder_1h_sent');
  });
}

async function checkNoShow(appointmentId, contactId, endTime) {
  const graceMinutes = 30;
  const checkTime = new Date(endTime.getTime() + graceMinutes * 60 * 1000);
  await scheduleMessage(checkTime, contactId, async () => {
    const status = await getAppointmentStatus(appointmentId);
    if (status !== 'completed' && status !== 'cancelled') {
      // No‑show
      await addTag(contactId, 'no_show');
      await changeStage(contactId, 'REACTIVATION');
      await sendSMS(contactPhone, 'We missed you. Click here to reschedule: [reschedule link]');
      await createTask(contactId, 'No‑show lead – follow up to reschedule');
      await logEvent(contactId, 'appointment_no_show');
    }
  });
}

async function logReminder(contactId, reminderType, channel, status) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/reminder_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        reminder_type: reminderType, // 'confirmation_request', '24h_reminder', '3h_reminder', '1h_reminder'
        channel: channel, // 'sms', 'email'
        status: status, // 'sent', 'failed', 'confirmed'
        timestamp: new Date().toISOString()
      }
    })
  });
}

await cancelTimer(contactId, 'confirm_reminder');
await cancelTimer(contactId, 'reminder_24h');
await cancelTimer(contactId, 'reminder_3h');
await cancelTimer(contactId, 'reminder_1h');

// No automation. Rep uses a spreadsheet to track attendance.

// When appointment is created, schedule a no‑show check
async function scheduleNoShowCheck(appointmentId, endTime, contactId) {
  const graceMinutes = 30;
  const checkTime = new Date(new Date(endTime).getTime() + graceMinutes * 60 * 1000);
  // Use Make's scheduled webhook or GHL's "Wait" step
  await scheduleWebhook(checkTime, 'no_show_check', { appointmentId, contactId });
}

async function checkNoShow(payload) {
  const { appointmentId, contactId } = payload;
  const appointment = await getAppointment(appointmentId);
  
  // If already marked completed or canceled, exit
  if (appointment.status === 'completed' || appointment.status === 'cancelled') return;
  
  // No‑show confirmed
  await addTag(contactId, 'no_show');
  await changeStage(contactId, 'REACTIVATION');
  
  // Send immediate reschedule SMS
  const rescheduleLink = generateRescheduleLink(contactId, appointment.repId);
  const sms = `We missed you at your ${appointment.serviceType} consultation. Click here to reschedule: ${rescheduleLink}`;
  await sendSMS(contactPhone, sms);
  
  // Create task for rep (one follow‑up)
  await createTask(contactId, `No‑show lead – follow up to reschedule`, appointment.repId, 60);
  
  // Log event
  await logNoShow(contactId, appointmentId);
  
  // Start 24h timer for reschedule window
  await startRescheduleTimer(contactId, 24 * 60 * 60);
}

function generateRescheduleLink(contactId, repId) {
  const token = createJWT({ contactId, repId, exp: Date.now() + 7*24*60*60*1000 });
  return `https://app.gohighlevel.com/booking/${repId}?reschedule=true&leadId=${contactId}&token=${token}`;
}

async function handleReschedule(leadId, newTimeSlot, repId) {
  // Remove no‑show tag
  await removeTag(leadId, 'no_show');
  // Move stage back to APPOINTMENT_BOOKED
  await changeStage(leadId, 'APPOINTMENT_BOOKED');
  // Create new appointment
  const newAppointment = await createAppointment(leadId, repId, newTimeSlot);
  // Cancel the old task
  await cancelTasksForLead(leadId, 'No‑show lead – follow up');
  // Send confirmation
  await sendSMS(contactPhone, `Rescheduled! Your new consultation is on ${newTimeSlot.formatted}.`);
  await logEvent(leadId, 'rescheduled_after_no_show', { old_appointment: oldId, new_appointment: newAppointment.id });
  // Cancel the 24h reschedule timer
  await cancelTimer(leadId, 'reschedule_window');
}

async function escalateNoReschedule(contactId) {
  const tags = await getContactTags(contactId);
  if (!tags.includes('no_show')) return; // already rescheduled
  
  // Send second SMS
  await sendSMS(contactPhone, `Last chance to reschedule your consultation: [reschedule link] This offer expires in 7 days.`);
  
  // Reassign task to manager
  await reassignTask(contactId, 'No‑show lead – follow up', 'sales_manager@company.com');
  
  // Start 7‑day timer
  await startTimer(contactId, 'final_no_show_archive', 7 * 24 * 60 * 60);
}

async function archiveNoShow(contactId) {
  const tags = await getContactTags(contactId);
  if (!tags.includes('no_show')) return;
  
  await changeStage(contactId, 'CLOSED_LOST');
  await updateCustomField(contactId, 'loss_reason', 'no_show');
  
  // Schedule reactivation after 90 days
  const reactivationDate = new Date();
  reactivationDate.setDate(reactivationDate.getDate() + 90);
  await updateCustomField(contactId, 'reactivation_date', reactivationDate.toISOString());
  
  await logEvent(contactId, 'no_show_archived', { reason: 'no_reschedule_within_7d' });
}

async function logNoShow(contactId, appointmentId) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/no_show_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        appointment_id: appointmentId,
        no_show_time: new Date().toISOString(),
        rescheduled: false,
        archived: false
      }
    })
  });
}

const tags = await getContactTags(contactId);
if (tags.includes('manual:reschedule') || tags.includes('manual:no_show_override')) {
  console.log('Lead manually rescheduled; skipping auto‑reschedule flow.');
  return;
}

// Google Apps Script for mail merge (manual trigger)
function generateEstimate() {
  const doc = DocumentApp.openById('TEMPLATE_ID');
  const body = doc.getBody();
  body.replaceText('{{name}}', leadName);
  body.replaceText('{{amount}}', estimateAmount);
  const pdf = doc.getAs('application/pdf');
  DriveApp.createFile(pdf).setName(`Estimate_${leadName}.pdf`);
  // Manual email sending
}

async function getLeadData(contactId) {
  const response = await fetch(`https://rest.gohighlevel.com/v1/contacts/${contactId}`, {
    headers: { 'Authorization': 'Bearer GHL_API_KEY' }
  });
  const contact = await response.json();
  return {
    name: contact.name,
    phone: contact.phone,
    email: contact.email,
    service_type: contact.customField.service_type,
    estimate_amount: contact.customField.estimate_amount,
    estimate_options: contact.customField.estimate_options || [],
    created_at: contact.createdAt
  };
}

<!-- estimate_template.html -->
<html>
<body>
  <h1>Estimate for {{name}}</h1>
  <p>Service: {{service_type}}</p>
  <p>Total: ${{estimate_amount}}</p>
  <ul>
  {{#each estimate_options}}
    <li>{{this}}</li>
  {{/each}}
  </ul>
  <p>Valid until: {{expiry_date}}</p>
</body>
</html>

const Handlebars = require('handlebars');
const fs = require('fs');
const puppeteer = require('puppeteer');

async function populateTemplate(leadData) {
  const templateHtml = fs.readFileSync('estimate_template.html', 'utf8');
  const template = Handlebars.compile(templateHtml);
  
  // Add calculated fields
  leadData.expiry_date = new Date();
  leadData.expiry_date.setDate(leadData.expiry_date.getDate() + 30);
  
  const populatedHtml = template(leadData);
  return populatedHtml;
}

async function htmlToPdf(html, outputPath) {
  const browser = await puppeteer.launch({ headless: true });
  const page = await browser.newPage();
  await page.setContent(html, { waitUntil: 'networkidle0' });
  await page.pdf({ path: outputPath, format: 'A4' });
  await browser.close();
}

const { Storage } = require('@google-cloud/storage');
const storage = new Storage({ keyFilename: 'service-account-key.json' });
const bucket = storage.bucket('estimates-bucket');

async function uploadAndGetSignedUrl(contactId, pdfPath) {
  const filePath = `estimates/${contactId}_${Date.now()}.pdf`;
  await bucket.upload(pdfPath, { destination: filePath });
  
  // Generate signed URL valid for 30 days
  const [url] = await bucket.file(filePath).getSignedUrl({
    version: 'v4',
    action: 'read',
    expires: Date.now() + 30 * 24 * 60 * 60 * 1000
  });
  return url;
}

async function attachEstimateLink(contactId, documentUrl) {
  await fetch(`https://rest.gohighlevel.com/v1/contacts/${contactId}`, {
    method: 'PUT',
    headers: { 'Authorization': 'Bearer GHL_API_KEY', 'Content-Type': 'application/json' },
    body: JSON.stringify({
      customField: {
        estimate_document_link: documentUrl,
        estimate_sent_at: new Date().toISOString()
      }
    })
  });
  // Change stage to ESTIMATE_SENT (if not already)
  await changeStage(contactId, 'ESTIMATE_SENT');
}

async function sendEstimateDelivery(contactId, phone, email, documentUrl) {
  const sms = `Your estimate is ready: ${documentUrl}`;
  const emailSubject = `Your estimate for ${service_type} is ready`;
  const emailBody = `Click here to view your estimate: ${documentUrl}. This link expires in 30 days.`;
  
  if (!hasOptedOutSMS(contactId)) await sendSMS(phone, sms);
  await sendEmail(email, emailSubject, emailBody);
}

async function logDocumentGeneration(contactId, documentUrl, templateVersion) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/event_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        event_type: 'estimate_generated',
        contact_id: contactId,
        document_url: documentUrl,
        template_version: templateVersion,
        timestamp: new Date().toISOString()
      }
    })
  });
}

const tags = await getContactTags(contactId);
const hasDoc = await getCustomField(contactId, 'estimate_document_link');
if (tags.includes('auto:estimate_processed') || (hasDoc && tags.includes('manual:estimate_created'))) {
  console.log('Estimate already generated manually; skipping automation.');
  return;
}

function getTrackingPixelUrl(contactId, estimateId) {
  return `https://track.yourdomain.com/pixel?contact=${contactId}&estimate=${estimateId}&type=open`;
}

function generateWrappedLink(contactId, estimateId, destination, action) {
  // destination could be 'accept_estimate', 'financing_link', 'faq', etc.
  return `https://track.yourdomain.com/click?contact=${contactId}&estimate=${estimateId}&action=${action}&to=${encodeURIComponent(destination)}`;
}

const express = require('express');
const app = express();

// Tracking pixel (1x1 transparent gif)
app.get('/pixel', async (req, res) => {
  const { contact, estimate, type } = req.query;
  // Asynchronously log without blocking response
  logOpenEvent(contact, estimate, type);
  // Send 1x1 transparent gif
  res.set('Content-Type', 'image/gif');
  res.send(Buffer.from('R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7', 'base64'));
});

// Click tracker
app.get('/click', async (req, res) => {
  const { contact, estimate, action, to } = req.query;
  await logClickEvent(contact, estimate, action);
  // Redirect to original destination
  res.redirect(302, decodeURIComponent(to));
});

async function logOpenEvent(contactId, estimateId, type) {
  // Update CRM: increment open_count, set estimate_opened = true
  await updateGHLContact(contactId, {
    estimate_opened: true,
    estimate_open_count: `increment` // custom logic
  });
  
  // Log to Airtable
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/event_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        event_type: 'estimate_opened',
        contact_id: contactId,
        estimate_id: estimateId,
        timestamp: new Date().toISOString()
      }
    })
  });
  
  // Check if open count > threshold (e.g., 3) and no decision yet
  const openCount = await getOpenCount(contactId);
  if (openCount > 3) {
    const stage = await getContactStage(contactId);
    if (stage === 'ESTIMATE_SENT' || stage === 'DECISION_PENDING') {
      await createTask(contactId, 'Lead opened estimate 3+ times – may need clarification');
    }
  }
}

async function logClickEvent(contactId, estimateId, action) {
  await updateGHLContact(contactId, {
    [`click_${action}`]: true,
    last_click_at: new Date().toISOString()
  });
  
  // Trigger specific action based on action type
  switch(action) {
    case 'accept':
      await autoAcceptEstimate(contactId, estimateId);
      break;
    case 'financing':
      await sendFinancingBreakdown(contactId);
      break;
    case 'question':
      await createTask(contactId, 'Lead clicked question link – follow up');
      break;
  }
  
  // Log to Airtable
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/click_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        estimate_id: estimateId,
        action: action,
        timestamp: new Date().toISOString()
      }
    })
  });
}

// After logging, send webhook to Make for further processing (e.g., update workflow)
await fetch('https://hook.make.com/your_webhook', {
  method: 'POST',
  body: JSON.stringify({ contactId, estimateId, event: 'opened' })
});

<!-- In estimate email -->
<img src="https://track.yourdomain.com/pixel?contact={{contactId}}&estimate={{estimateId}}" width="1" height="1" />
<a href="https://track.yourdomain.com/click?contact={{contactId}}&estimate={{estimateId}}&action=accept&to=https://yourapp.com/accept">Accept Estimate</a>
<a href="https://track.yourdomain.com/click?contact={{contactId}}&estimate={{estimateId}}&action=financing&to=https://lender.com/apply">Financing Options</a>

async function startDecisionTimer(contactId, estimateAmount, serviceType) {
  // Store timer start in custom field
  await updateCustomField(contactId, 'decision_timer_start', new Date().toISOString());
  
  // Schedule follow‑up steps using GHL workflow wait steps or Make timers
  const steps = [
    { delayHours: 1, messageType: 'gentle' },
    { delayHours: 24, messageType: 'reminder' },
    { delayHours: 48, messageType: 'urgency' },
    { delayHours: 72, messageType: 'final' }
  ];
  
  for (const step of steps) {
    const triggerTime = new Date(Date.now() + step.delayHours * 60 * 60 * 1000);
    await scheduleMessage(triggerTime, contactId, `follow_up_${step.delayHours}h`, { messageType: step.messageType });
  }
}

async function sendFollowUp(contactId, intervalHours, messageType) {
  const lead = await getLeadData(contactId);
  const stage = await getContactStage(contactId);
  
  // If lead already moved to CLOSED_WON, CLOSED_LOST, or OBJECTION_HANDLING, cancel sequence
  if (stage !== 'ESTIMATE_SENT' && stage !== 'DECISION_PENDING') {
    console.log(`Lead ${contactId} already moved from ESTIMATE_SENT; cancelling follow‑up.`);
    return;
  }
  
  let message = '';
  switch(messageType) {
    case 'gentle':
      message = `Hi ${lead.name}, did you have a chance to review your ${lead.service_type} estimate? I'm available to answer any questions.`;
      break;
    case 'reminder':
      message = `Just checking in, ${lead.name}. Your estimate is still valid. Would you like to schedule a call to discuss?`;
      break;
    case 'urgency':
      message = `Hi ${lead.name}, our installation schedule is filling up. If you'd like to lock in your date, let me know within 48 hours.`;
      break;
    case 'final':
      message = `Last chance, ${lead.name}. Your estimate expires in 3 days. Reply YES to proceed or let me know if you have questions.`;
      break;
  }
  
  await sendSMS(lead.phone, message);
  await sendEmail(lead.email, `Follow‑up on your ${lead.service_type} estimate`, message);
  
  // Log sent message
  await logFollowUp(contactId, intervalHours, messageType);
  
  // If this was the final message (72h) and no action, move to DECISION_PENDING
  if (messageType === 'final') {
    await changeStage(contactId, 'DECISION_PENDING');
  }
}

async function onEstimateAction(contactId, action) {
  if (action === 'accept' || action === 'reject') {
    // Cancel all pending follow‑ups
    await cancelAllScheduledMessages(contactId);
    await updateCustomField(contactId, 'decision_timer_cancelled_at', new Date().toISOString());
    await logEvent(contactId, 'decision_sequence_cancelled', { reason: action });
  } else if (action === 'objection') {
    // Pause sequence without cancelling
    await pauseScheduledMessages(contactId);
    await updateCustomField(contactId, 'decision_timer_paused', true);
    await logEvent(contactId, 'decision_sequence_paused', { reason: 'objection_detected' });
  }
}

async function resumeDecisionSequence(contactId) {
  const paused = await getCustomField(contactId, 'decision_timer_paused');
  if (!paused) return;
  
  // Calculate remaining time based on original timer start
  const timerStart = await getCustomField(contactId, 'decision_timer_start');
  const elapsed = (Date.now() - new Date(timerStart)) / (1000 * 60 * 60);
  const remainingSteps = [1, 24, 48, 72].filter(h => h > elapsed);
  
  for (const delayHours of remainingSteps) {
    const triggerTime = new Date(Date.now() + (delayHours - elapsed) * 60 * 60 * 1000);
    await scheduleMessage(triggerTime, contactId, `follow_up_${delayHours}h`);
  }
  
  await updateCustomField(contactId, 'decision_timer_paused', false);
}

async function escalateToManager(contactId) {
  const stage = await getContactStage(contactId);
  if (stage !== 'DECISION_PENDING') return;
  
  // Create task for sales manager
  await createTask(contactId, 'Stalled decision – no response for 5 days', 'sales_manager@company.com', 24);
  
  // Send final SMS
  await sendSMS(lead.phone, `We haven't heard from you. Your estimate is still valid. Reply YES or call us at XXX.`);
  
  // Start 7‑day archive timer
  await startTimer(contactId, 'archive_stalled', 7 * 24 * 60 * 60);
}

async function archiveStalledLead(contactId) {
  const stage = await getContactStage(contactId);
  if (stage !== 'DECISION_PENDING') return;
  
  await changeStage(contactId, 'REACTIVATION');
  await addTag(contactId, 'stalled_no_response');
  await updateCustomField(contactId, 'loss_reason', 'no_response');
  
  // Schedule reactivation in 60 days
  const reactivationDate = new Date();
  reactivationDate.setDate(reactivationDate.getDate() + 60);
  await updateCustomField(contactId, 'reactivation_date', reactivationDate.toISOString());
  
  await logEvent(contactId, 'stalled_lead_archived');
}

async function logFollowUp(contactId, intervalHours, messageType) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/follow_up_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        interval_hours: intervalHours,
        message_type: messageType,
        sent_at: new Date().toISOString()
      }
    })
  });
}

async function classifyObjection(messageText, estimateAmount, serviceType) {
  const prompt = `
    You are an objection classifier for a home improvement company.
    Classify the customer message into one of:
    - price: concerns about cost, budget, financing
    - trust: concerns about reliability, license, insurance, reviews
    - timing: not ready, need to delay, seasonal
    - competitor: comparing with other companies
    - confusion: unclear about estimate, scope, or next steps
    - accept: positive acceptance (let's do it, yes, proceed)
    - reject: explicit rejection (no thanks, went with someone else)
    - other: none of the above

    Return JSON: {"intent": "...", "confidence": 0.95, "suggested_response_type": "financing"}
  `;
  
  const response = await openai.chat.completions.create({
    model: 'gpt-4o-mini',
    messages: [
      { role: 'system', content: prompt },
      { role: 'user', content: `Message: ${messageText}\nEstimate amount: ${estimateAmount}\nService: ${serviceType}` }
    ],
    temperature: 0,
    max_tokens: 150
  });
  
  return JSON.parse(response.choices[0].message.content);
}

const responseTemplates = {
  price: (name, amount) => `We understand, ${name}. Many clients use our financing – payments as low as $${Math.round(amount * 0.02)}/month. Would you like me to send a breakdown?`,
  trust: (name) => `Great question, ${name}. We're licensed Licensed ABC123 and insured. Here are 3 recent projects with reviews: link to reviews`,
  timing: (name) => `No problem, ${name}. Our lead time is currently 3–4 weeks, so starting sooner avoids delays. Want to lock in your date?`,
  competitor: (name) => `We'd love the opportunity, ${name}. Our warranty is 10 years vs. their 5, and we use premium materials. Happy to compare side‑by‑side.`,
  confusion: (name, amount, scope) => `I'll simplify: your estimate covers ${scope}. The price is $${amount}. Next step: accept here: link. Questions? I can call you.`
};

async function handleObjection(contactId, messageText, estimateAmount, serviceType) {
  const classification = await classifyObjection(messageText, estimateAmount, serviceType);
  const intent = classification.intent;
  const confidence = classification.confidence;
  const lead = await getLeadData(contactId);
  
  if (confidence < 0.7) {
    // Low confidence – escalate to human
    await createTask(contactId, `Low confidence objection classification (${intent}). Review and respond.`);
    await logEvent(contactId, 'objection_low_confidence', { intent, confidence, message: messageText });
    return;
  }
  
  // Handle accept/reject immediately
  if (intent === 'accept') {
    await changeStage(contactId, 'CLOSED_WON');
    await sendSMS(lead.phone, `Great! We'll send over the contract and next steps shortly.`);
    await logEvent(contactId, 'auto_accept', { source: 'objection_handler' });
    return;
  }
  
  if (intent === 'reject') {
    await changeStage(contactId, 'CLOSED_LOST');
    await updateCustomField(contactId, 'loss_reason', 'explicit_reject');
    await logEvent(contactId, 'auto_reject');
    return;
  }
  
  // For objection intents, send auto‑response
  let responseText = '';
  switch(intent) {
    case 'price':
      responseText = responseTemplates.price(lead.name, estimateAmount);
      // Also trigger financing workflow
      await triggerFinancingWorkflow(contactId);
      break;
    case 'trust':
      responseText = responseTemplates.trust(lead.name);
      break;
    case 'timing':
      responseText = responseTemplates.timing(lead.name);
      break;
    case 'competitor':
      responseText = responseTemplates.competitor(lead.name);
      break;
    case 'confusion':
      responseText = responseTemplates.confusion(lead.name, estimateAmount, lead.service_type);
      break;
    default:
      responseText = `Thanks for your message, ${lead.name}. I'll have a specialist reach out shortly.`;
  }
  
  await sendSMS(lead.phone, responseText);
  await sendEmail(lead.email, `Regarding your estimate`, responseText);
  
  // Increment objection attempt counter
  let attemptCount = (await getCustomField(contactId, 'objection_attempt_count')) || 0;
  attemptCount++;
  await updateCustomField(contactId, 'objection_attempt_count', attemptCount);
  await addTag(contactId, `objection:${intent}`);
  
  // If attempt count > 2, escalate to human
  if (attemptCount > 2) {
    await createTask(contactId, `Multiple objections (${attemptCount}) unresolved. Call lead.`);
    await sendSlackAlert(`Lead ${lead.name} has had ${attemptCount} objection attempts.`);
  }
  
  // Log event
  await logEvent(contactId, 'auto_objection_response', { intent, confidence, response: responseText });
}

// If AI classification fails (timeout, error), use keyword fallback
function keywordFallback(messageText) {
  const lower = messageText.toLowerCase();
  if (lower.includes('expensive') || lower.includes('price') || lower.includes('cost')) return 'price';
  if (lower.includes('trust') || lower.includes('license') || lower.includes('reviews')) return 'trust';
  if (lower.includes('later') || lower.includes('not ready') || lower.includes('delay')) return 'timing';
  if (lower.includes('competitor') || lower.includes('other company')) return 'competitor';
  if (lower.includes('confused') || lower.includes('understand') || lower.includes('explain')) return 'confusion';
  if (lower.includes('yes') || lower.includes('accept') || lower.includes('proceed')) return 'accept';
  if (lower.includes('no') || lower.includes('cancel') || lower.includes('unsubscribe')) return 'reject';
  return 'other';
}

const tags = await getContactTags(contactId);
if (tags.includes('auto:objection_response_sent') || tags.includes('manual:objection_handled')) {
  console.log('Objection already handled; skipping auto‑response.');
  return;
}

async function getApprovalChain(documentType, amount, submitterId) {
  // Example: contracts over $50k need VP Sales then Legal
  if (documentType === 'contract' && amount > 50000) {
    return [
      { role: 'VP Sales', email: 'vp.sales@company.com', order: 1 },
      { role: 'Legal', email: 'legal@company.com', order: 2 }
    ];
  }
  // Discount over 20% needs Sales Manager only
  if (documentType === 'discount' && amount > 20) {
    return [
      { role: 'Sales Manager', email: 'sales.mgr@company.com', order: 1 }
    ];
  }
  // Default: single approver
  return [
    { role: 'Manager', email: 'manager@company.com', order: 1 }
  ];
}

async function startApproval(documentId, documentType, amount, submitterId, documentLink) {
  const chain = await getApprovalChain(documentType, amount, submitterId);
  const approvalId = generateUUID();
  
  // Store approval record in Airtable
  await createApprovalRecord(approvalId, documentId, documentType, amount, chain);
  
  // Process first approver
  await processApproverStep(approvalId, chain[0], 0);
}

async function processApproverStep(approvalId, approver, stepIndex) {
  const stepId = generateUUID();
  const approval = await getApprovalRecord(approvalId);
  
  // Notify approver via Slack and email
  const message = `Please approve document: ${approval.documentLink}. Reply APPROVE or REJECT with reason.`;
  await sendSlackDM(approver.email, message);
  await sendEmail(approver.email, `Approval required for ${approval.documentType}`, message);
  
  // Create record for this step
  await createStepRecord(stepId, approvalId, stepIndex, approver.email, new Date());
  
  // Start SLA timer (e.g., 4 hours for normal, 1 hour for urgent)
  const slaHours = approval.amount > 100000 ? 1 : 4;
  await scheduleStepTimer(stepId, slaHours);
}

async function handleApproverResponse(stepId, response, reason) {
  const step = await getStepRecord(stepId);
  const approval = await getApprovalRecord(step.approvalId);
  const responseLower = response.toLowerCase().trim();
  
  // Cancel the SLA timer
  await cancelStepTimer(stepId);
  
  if (responseLower === 'approve' || responseLower === 'approved' || responseLower === 'ok') {
    await updateStepRecord(stepId, { status: 'approved', responded_at: new Date(), reason });
    
    const nextStepIndex = step.step_index + 1;
    if (nextStepIndex < approval.approval_chain.length) {
      // Move to next approver
      await processApproverStep(approval.approvalId, approval.approval_chain[nextStepIndex], nextStepIndex);
    } else {
      // All approvals complete
      await completeApproval(approval.approvalId);
    }
  } 
  else if (responseLower === 'reject' || responseLower === 'rejected' || responseLower === 'no') {
    await updateStepRecord(stepId, { status: 'rejected', responded_at: new Date(), reason });
    await rejectApproval(approval.approvalId, step.approver_email, reason);
  }
  else {
    // Invalid response – ask again
    await sendSlackDM(step.approver_email, `Please reply with APPROVE or REJECT. Current response "${response}" not recognized.`);
  }
}

async function completeApproval(approvalId) {
  await updateApprovalRecord(approvalId, { status: 'approved', completed_at: new Date() });
  // Notify submitter
  const approval = await getApprovalRecord(approvalId);
  await sendEmail(approval.submitter_email, `Document approved`, `Your ${approval.documentType} has been approved.`);
  // Trigger next stage (e.g., move to initial pay)
  await triggerNextStage(approval.documentId, 'initial_pay');
}

async function rejectApproval(approvalId, rejectedBy, reason) {
  await updateApprovalRecord(approvalId, { status: 'rejected', rejected_at: new Date(), rejected_by: rejectedBy, reject_reason: reason });
  const approval = await getApprovalRecord(approvalId);
  await sendEmail(approval.submitter_email, `Document rejected`, `${approval.documentType} was rejected by ${rejectedBy}. Reason: ${reason}`);
}

async function escalateStep(stepId) {
  const step = await getStepRecord(stepId);
  if (step.status !== 'pending') return;
  
  const approval = await getApprovalRecord(step.approvalId);
  const escalations = await getStepEscalations(stepId);
  
  if (escalations.length === 0) {
    // First escalation – notify manager of the approver
    const managerEmail = await getManagerEmail(step.approver_email);
    await sendSlackDM(managerEmail, `Urgent: ${step.approver_email} has not approved step. Please follow up.`);
    await createTask(approval.documentId, `Approval step overdue – contact ${step.approver_email}`, managerEmail, 2);
    await logEscalation(stepId, 'first_escalation', managerEmail);
    // Schedule second escalation in 2 hours
    await scheduleStepTimer(stepId, 2);
  } 
  else if (escalations.length === 1) {
    // Second escalation – escalate to department head
    const deptHead = await getDepartmentHead(step.approver_email);
    await sendSMS(deptHead.phone, `CRITICAL: Approval step for ${approval.documentId} overdue. ${step.approver_email} not responding.`);
    await createTask(approval.documentId, `Critical approval overdue – contact department head`, deptHead.email, 1);
    await logEscalation(stepId, 'second_escalation', deptHead.email);
    // No further automatic escalation – becomes manual
  }
}

async function createApprovalRecord(approvalId, documentId, documentType, amount, chain) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/approvals', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        approval_id: approvalId,
        document_id: documentId,
        document_type: documentType,
        amount: amount,
        approval_chain: JSON.stringify(chain),
        status: 'pending',
        created_at: new Date().toISOString()
      }
    })
  });
}

async function logEscalation(stepId, escalationLevel, escalatedTo) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/escalations', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        step_id: stepId,
        escalation_level: escalationLevel,
        escalated_to: escalatedTo,
        timestamp: new Date().toISOString()
      }
    })
  });
}

if (manualOverride) {
  for (let step of pendingSteps) {
    await updateStepRecord(step.id, { status: 'skipped', skipped_reason: 'manual_override' });
  }
  await completeApproval(approvalId);
}

async function createSignatureEnvelope(contactId, documentUrl, documentName, signerEmail, signerName) {
  const docusign = require('docusign-esign');
  const apiClient = new docusign.ApiClient();
  apiClient.setBasePath(process.env.DOCUSIGN_BASE_PATH);
  apiClient.addDefaultHeader('Authorization', `Bearer ${getAccessToken()}`);
  
  const envelopesApi = new docusign.EnvelopesApi(apiClient);
  
  const envelopeDefinition = {
    status: 'sent',
    emailSubject: `Please sign your ${documentName}`,
    documents: [{
      documentId: '1',
      name: documentName,
      documentBase64: await getBase64FromUrl(documentUrl)
    }],
    recipients: {
      signers: [{
        email: signerEmail,
        name: signerName,
        recipientId: '1',
        routingOrder: '1',
        tabs: {
          signHereTabs: [{ documentId: '1', pageNumber: '1', xPosition: '100', yPosition: '100' }]
        }
      }]
    }
  };
  
  const results = await envelopesApi.createEnvelope(accountId, { envelopeDefinition });
  const envelopeId = results.envelopeId;
  
  // Store envelopeId in CRM
  await updateCustomField(contactId, 'docusign_envelope_id', envelopeId);
  await updateCustomField(contactId, 'contract_sent_at', new Date().toISOString());
  
  // Log to Airtable
  await logEvent(contactId, 'signature_request_sent', { envelopeId, documentName });
  
  return envelopeId;
}

// Express webhook endpoint for DocuSign events
app.post('/docusign-webhook', async (req, res) => {
  const event = req.body;
  const envelopeId = event.envelopeId;
  const status = event.status; // 'sent', 'delivered', 'completed', 'declined', 'voided'
  
  const contactId = await getContactIdByEnvelopeId(envelopeId);
  
  if (status === 'completed') {
    await handleSignatureCompleted(contactId, envelopeId);
  } else if (status === 'declined') {
    await handleSignatureDeclined(contactId, envelopeId, event.declineReason);
  } else if (status === 'delivered') {
    await logEvent(contactId, 'signature_opened', { envelopeId });
  }
  
  res.send('OK');
});

async function handleSignatureCompleted(contactId, envelopeId) {
  // Download signed PDF
  const docusign = require('docusign-esign');
  const apiClient = new docusign.ApiClient();
  const envelopesApi = new docusign.EnvelopesApi(apiClient);
  const documents = await envelopesApi.listDocuments(accountId, envelopeId);
  const signedDoc = documents.envelopeDocuments.find(doc => doc.type === 'signature');
  const pdfBytes = await envelopesApi.getDocument(accountId, envelopeId, signedDoc.documentId);
  
  // Upload to cloud storage
  const fileName = `contract_${contactId}_${Date.now()}.pdf`;
  const signedUrl = await uploadToS3(pdfBytes, fileName);
  
  // Update CRM
  await updateCustomField(contactId, 'contract_signed_pdf_url', signedUrl);
  await updateCustomField(contactId, 'contract_signed_at', new Date().toISOString());
  await changeStage(contactId, 'CONTRACT_SIGNED');
  
  // Log to Airtable
  await logEvent(contactId, 'signature_completed', { envelopeId, signedUrl });
  
  // Trigger next action (e.g., initial payment)
  await triggerNextStage(contactId, 'initial_pay');
}

async function handleSignatureDeclined(contactId, envelopeId, reason) {
  await updateCustomField(contactId, 'contract_declined_reason', reason);
  await changeStage(contactId, 'CONTRACT_DECLINED');
  await createTask(contactId, `Customer declined to sign contract. Reason: ${reason}. Follow up.`);
  await logEvent(contactId, 'signature_declined', { envelopeId, reason });
}

async function scheduleSignatureReminders(contactId, envelopeId) {
  // 24h reminder
  await scheduleMessage(new Date(Date.now() + 24*60*60*1000), contactId, async () => {
    const status = await getEnvelopeStatus(envelopeId);
    if (status !== 'completed') {
      await sendSMS(lead.phone, `Reminder: Please sign your contract. Link: ${getSigningLink(envelopeId)}`);
      await sendEmail(lead.email, `Reminder to sign contract`, `Please complete signing here: ${getSigningLink(envelopeId)}`);
      await logEvent(contactId, 'signature_reminder_24h', { envelopeId });
    }
  });
  
  // 48h reminder + escalation to rep
  await scheduleMessage(new Date(Date.now() + 48*60*60*1000), contactId, async () => {
    const status = await getEnvelopeStatus(envelopeId);
    if (status !== 'completed') {
      await createTask(contactId, `Customer has not signed contract after 48h. Follow up.`, lead.assigned_rep, 4);
      await sendSlackAlert(`Contract unsigned for 48h – Lead ${lead.name}`);
      await logEvent(contactId, 'signature_reminder_48h_escalated', { envelopeId });
    }
  });
}

async function logEvent(contactId, eventType, metadata) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/esign_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        event_type: eventType,
        timestamp: new Date().toISOString(),
        metadata: JSON.stringify(metadata)
      }
    })
  });
}

const manualOverride = await getCustomField(contactId, 'manual_contract_uploaded');
if (manualOverride) {
  console.log('Contract manually uploaded; ignoring e‑sign webhook.');
  return;
}

const express = require('express');
const app = express();
const redis = require('redis');
const client = redis.createClient();

// Stripe webhook with idempotency header
app.post('/stripe-webhook', express.raw({type: 'application/json'}), async (req, res) => {
  const idempotencyKey = req.headers['idempotency-key'] || req.body.idempotency_key;
  if (!idempotencyKey) {
    return res.status(400).send('Missing idempotency key');
  }
  
  // Check if already processed
  const processed = await client.get(idempotencyKey);
  if (processed) {
    console.log(`Duplicate webhook for key ${idempotencyKey}, skipping`);
    return res.status(200).send('OK duplicate');
  }
  
  const sig = req.headers['stripe-signature'];
  let event;
  try {
    event = stripe.webhooks.constructEvent(req.body, sig, process.env.STRIPE_WEBHOOK_SECRET);
  } catch (err) {
    console.error(`Webhook signature verification failed: ${err.message}`);
    return res.status(400).send(`Webhook Error: ${err.message}`);
  }
  
  // Mark idempotency key as processed (TTL 24 hours)
  await client.setex(idempotencyKey, 86400, 'processed');
  
  // Handle event
  await handlePaymentEvent(event);
  
  res.status(200).json({received: true});
});

async function handlePaymentEvent(event) {
  const eventType = event.type;
  
  switch(eventType) {
    case 'payment_intent.succeeded':
      await handlePaymentSuccess(event.data.object);
      break;
    case 'payment_intent.payment_failed':
      await handlePaymentFailure(event.data.object);
      break;
    case 'charge.refunded':
      await handleRefund(event.data.object);
      break;
    default:
      console.log(`Unhandled event type ${eventType}`);
  }
}

async function handlePaymentSuccess(paymentIntent) {
  const contactId = paymentIntent.metadata.contact_id;
  const estimateId = paymentIntent.metadata.estimate_id;
  const amount = paymentIntent.amount / 100; // cents to dollars
  const transactionId = paymentIntent.id;
  
  // Update CRM
  await updateCRM(contactId, {
    payment_status: 'paid',
    payment_amount: amount,
    payment_transaction_id: transactionId,
    payment_received_at: new Date().toISOString()
  });
  
  // Determine payment stage initial or progress or final
  const paymentType = paymentIntent.metadata.payment_type; // deposit, progress_1, final
  await handlePaymentType(contactId, paymentType, amount);
  
  // Send receipt
  await sendReceipt(contactId, amount, transactionId, paymentType);
  
  // Log to Airtable
  await logPaymentEvent(contactId, 'payment_succeeded', { amount, transactionId, paymentType });
}

async function handlePaymentFailure(paymentIntent) {
  const contactId = paymentIntent.metadata.contact_id;
  const failureReason = paymentIntent.last_payment_error?.message || 'Unknown';
  
  let retryCount = await getCustomField(contactId, 'payment_retry_count');
  retryCount = (retryCount || 0) + 1;
  await updateCustomField(contactId, 'payment_retry_count', retryCount);
  
  if (retryCount < 3) {
    // Schedule retry after delay
    const delays = [1, 3, 7]; // days
    const delayDays = delays[retryCount - 1];
    await schedulePaymentRetry(contactId, delayDays);
    await sendSMS(lead.phone, `Your payment failed. We will retry in ${delayDays} day. Update payment method here: link`);
  } else {
    // Max retries exceeded
    await changeStage(contactId, 'PAYMENT_FAILED');
    await createTask(contactId, `Payment failed after ${retryCount} retries. Contact customer.`, 'collections@company.com');
  }
  
  await logPaymentEvent(contactId, 'payment_failed', { failureReason, retryCount });
}

async function sendReceipt(contactId, amount, transactionId, paymentType) {
  const lead = await getLeadData(contactId);
  const receiptMessage = `Receipt: Thank you for your ${paymentType} payment of $${amount}. Transaction ID: ${transactionId}`;
  await sendSMS(lead.phone, receiptMessage);
  await sendEmail(lead.email, `Receipt for your ${paymentType} payment`, receiptMessage);
}

async function schedulePaymentRetry(contactId, delayDays) {
  const triggerTime = new Date(Date.now() + delayDays * 24 * 60 * 60 * 1000);
  await scheduleJob(triggerTime, 'retry_payment', { contactId });
}

async function retryPayment(contactId) {
  // Call Stripe API to retry the payment using saved payment method
  const paymentIntentId = await getCustomField(contactId, 'payment_intent_id');
  try {
    const paymentIntent = await stripe.paymentIntents.retrieve(paymentIntentId);
    await stripe.paymentIntents.update(paymentIntentId, { payment_method: paymentIntent.payment_method });
    // Retry will trigger new webhook
  } catch (err) {
    console.error(`Retry failed: ${err.message}`);
  }
}

async function handleRefund(charge) {
  const contactId = charge.metadata.contact_id;
  const refundAmount = charge.amount_refunded / 100;
  await updateCRM(contactId, {
    payment_status: 'refunded',
    refund_amount: refundAmount,
    refunded_at: new Date().toISOString()
  });
  await sendSMS(lead.phone, `A refund of $${refundAmount} has been processed.`);
  await logPaymentEvent(contactId, 'payment_refunded', { refundAmount });
}

async function logPaymentEvent(contactId, eventType, metadata) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/payment_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        event_type: eventType,
        timestamp: new Date().toISOString(),
        metadata: JSON.stringify(metadata)
      }
    })
  });
}

const manualRecorded = await getTag(contactId, 'manual:payment_recorded');
if (manualRecorded) {
  console.log(`Payment manually recorded for contact ${contactId}; ignoring webhook.`);
  return;
}

app.post('/stripe-webhook', express.raw({type: 'application/json'}), async (req, res) => {
  const sig = req.headers['stripe-signature'];
  let event;
  try {
    event = stripe.webhooks.constructEvent(req.body, sig, process.env.STRIPE_WEBHOOK_SECRET);
  } catch (err) {
    return res.status(400).send(`Webhook Error: ${err.message}`);
  }

  switch (event.type) {
    case 'invoice.payment_failed':
      await handlePaymentFailure(event.data.object);
      break;
    case 'invoice.payment_succeeded':
      await handlePaymentSuccess(event.data.object);
      break;
    case 'customer.subscription.deleted':
      await handleSubscriptionCancelled(event.data.object);
      break;
  }

  res.status(200).json({received: true});
});

async function handlePaymentFailure(invoice) {
  const customerId = invoice.customer;
  const subscriptionId = invoice.subscription;
  const contactId = await getContactIdByStripeCustomerId(customerId);
  const attemptCount = invoice.attempt_count;

  // Log failure
  await logDunningEvent(contactId, 'payment_failed', { attemptCount, invoiceId: invoice.id });

  // Notify customer
  await sendSMS(lead.phone, `Your recurring payment of $${invoice.amount_due/100} failed. Please update payment method: ${getPaymentUpdateLink(customerId)}`);
  await sendEmail(lead.email, `Payment failed for your subscription`, `Please update your payment method here: ${getPaymentUpdateLink(customerId)}`);

  // Retrievable flag indicates payment method might still work after retry
  const canRetry = invoice.attempt_count < 3 && invoice.next_payment_attempt;
  if (canRetry) {
    // Stripe automatically schedules retries with backoff
    await logDunningEvent(contactId, 'retry_scheduled', { nextAttempt: invoice.next_payment_attempt });
  } else {
    // Max retries exceeded or no further attempts
    await escalateToCollections(contactId, customerId, subscriptionId, invoice);
  }
}

async function handlePaymentSuccess(invoice) {
  const customerId = invoice.customer;
  const contactId = await getContactIdByStripeCustomerId(customerId);
  
  // Update CRM: subscription active, last payment date
  await updateCRM(contactId, {
    subscription_status: 'active',
    last_payment_date: new Date().toISOString(),
    payment_failure_count: 0
  });
  
  // Remove any dunning flags
  await removeTag(contactId, 'dunning:payment_failed');
  await removeTag(contactId, 'dunning:escalated');
  
  // Send receipt
  await sendSMS(lead.phone, `Your payment of $${invoice.amount_paid/100} was successfully processed. Thank you.`);
  
  await logDunningEvent(contactId, 'payment_recovered', { invoiceId: invoice.id });
  
  // If there was a collections task, mark it resolved
  await resolveOpenTasks(contactId, 'Collections follow-up');
}

async function escalateToCollections(contactId, stripeCustomerId, subscriptionId, invoice) {
  // Mark subscription as dunning in CRM
  await updateCRM(contactId, {
    subscription_status: 'dunning',
    dunning_started_at: new Date().toISOString(),
    payment_failure_count: invoice.attempt_count
  });
  await addTag(contactId, 'dunning:escalated');
  
  // Create high-priority task for collections team
  await createTask(contactId, `Recurring payment failed after ${invoice.attempt_count} attempts. Contact customer immediately.`, 'collections@company.com', 4);
  
  // Send final notice to customer
  const graceEnd = new Date();
  graceEnd.setDate(graceEnd.getDate() + 7);
  await sendSMS(lead.phone, `Final notice: Your account will be suspended on ${graceEnd.toDateString()} if payment not received. Update payment method: ${getPaymentUpdateLink(stripeCustomerId)}`);
  await sendEmail(lead.email, `Action required: Payment failed`, `Your subscription will be suspended in 7 days. Please update your payment method immediately.`);
  
  // Schedule final suspension if no payment received
  await scheduleJob(graceEnd, 'suspend_subscription', { contactId, stripeCustomerId, subscriptionId });
  
  await logDunningEvent(contactId, 'escalated_to_collections', { graceEnd: graceEnd.toISOString() });
}

async function suspendSubscription(contactId, stripeCustomerId, subscriptionId) {
  // Check if payment was recovered in the meantime
  const subscription = await stripe.subscriptions.retrieve(subscriptionId);
  if (subscription.status === 'active') return;
  
  // Cancel subscription in Stripe
  await stripe.subscriptions.update(subscriptionId, { cancel_at_period_end: true });
  
  // Update CRM
  await updateCRM(contactId, {
    subscription_status: 'cancelled',
    cancelled_at: new Date().toISOString(),
    cancellation_reason: 'payment_failure_no_recovery'
  });
  await changeStage(contactId, 'REACTIVATION');
  
  // Send cancellation notice
  await sendSMS(lead.phone, `Your subscription has been cancelled due to non-payment. To reactivate, click here: reactivation link`);
  
  await logDunningEvent(contactId, 'subscription_cancelled', { reason: 'no_payment_after_grace' });
}

// When customer clicks payment update link, Stripe hosts a page.
// After update, Stripe sends a `customer.updated` webhook or you can poll.
app.post('/stripe-webhook', async (req, res) => {
  // ... existing code ...
  case 'customer.updated':
    await handleCustomerUpdated(event.data.object);
    break;
});

async function handleCustomerUpdated(customer) {
  const contactId = await getContactIdByStripeCustomerId(customer.id);
  const hasValidPaymentMethod = customer.invoice_settings.default_payment_method || customer.default_source;
  if (hasValidPaymentMethod) {
    // Retry the latest invoice
    const invoices = await stripe.invoices.list({ customer: customer.id, limit: 1, status: 'open' });
    if (invoices.data.length > 0) {
      await stripe.invoices.pay(invoices.data[0].id);
      await logDunningEvent(contactId, 'payment_method_updated_retry_triggered', { invoiceId: invoices.data[0].id });
    }
  }
}

async function logDunningEvent(contactId, eventType, metadata) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/dunning_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        event_type: eventType,
        timestamp: new Date().toISOString(),
        metadata: JSON.stringify(metadata)
      }
    })
  });
}

async function sendFinancingOffer(contactId, estimateAmount, serviceType) {
  const lead = await getLeadData(contactId);
  const applicationLink = generateFinancingLink(contactId, estimateAmount, lead.name, lead.email, lead.phone);
  
  const sms = `Good news! Your $${estimateAmount} ${serviceType} project can be financed starting at $${Math.round(estimateAmount * 0.02)}/month. Apply here: ${applicationLink}`;
  const emailSubject = `Financing options for your ${serviceType}`;
  const emailBody = `Click here to apply for financing: ${applicationLink}. Approval takes 2 minutes.`;
  
  await sendSMS(lead.phone, sms);
  await sendEmail(lead.email, emailSubject, emailBody);
  
  await changeStage(contactId, 'FINANCING_REVIEW');
  await addTag(contactId, 'financing:offered');
  await logEvent(contactId, 'financing_offer_sent', { estimateAmount });
}

function generateFinancingLink(contactId, amount, name, email, phone) {
  // Use lender's API to create a pre-filled application
  const payload = {
    amount: amount,
    customer_name: name,
    customer_email: email,
    customer_phone: phone,
    metadata: { contact_id: contactId }
  };
  // Store in your database mapping application_id to contact_id
  const applicationId = generateUUID();
  await storeMapping(applicationId, contactId);
  return `https://lender.com/apply?id=${applicationId}&prefill=true`;
}

app.post('/lender-webhook', express.json(), async (req, res) => {
  const { application_id, status, approved_amount, terms, monthly_payment, denial_reason } = req.body;
  
  // Look up contact_id from your mapping table
  const contactId = await getContactIdByApplicationId(application_id);
  if (!contactId) {
    return res.status(404).send('Contact not found');
  }
  
  // Idempotency: check if already processed
  const processed = await getFinancingProcessed(application_id);
  if (processed) {
    return res.status(200).send('Already processed');
  }
  
  if (status === 'approved') {
    await handleFinancingApproved(contactId, approved_amount, terms, monthly_payment);
  } else if (status === 'denied') {
    await handleFinancingDenied(contactId, denial_reason);
  }
  
  // Mark as processed
  await setFinancingProcessed(application_id);
  res.status(200).send('OK');
});

async function handleFinancingApproved(contactId, approvedAmount, terms, monthlyPayment) {
  // Update CRM
  await updateCustomField(contactId, 'financing_status', 'approved');
  await updateCustomField(contactId, 'financing_approved_amount', approvedAmount);
  await updateCustomField(contactId, 'financing_terms', terms);
  await updateCustomField(contactId, 'financing_monthly_payment', monthlyPayment);
  await addTag(contactId, 'financing:approved');
  
  // Send approval notification to customer
  const lead = await getLeadData(contactId);
  const acceptLink = generateAcceptEstimateLink(contactId);
  await sendSMS(lead.phone, `Great news! Your financing is approved. Accept your estimate here: ${acceptLink}`);
  await sendEmail(lead.email, `Financing approved for your ${lead.service_type} project`, `Click here to accept your estimate and proceed: ${acceptLink}`);
  
  // Notify sales rep
  await sendSlackAlert(`🎉 Financing approved for ${lead.name} ($${approvedAmount}). Ready to close.`);
  
  // Move stage to DECISION_PENDING (or directly to CLOSED_WON if auto-accept enabled)
  await changeStage(contactId, 'DECISION_PENDING');
  
  // Reset decision timer (give customer 48h to accept)
  await resetDecisionTimer(contactId, 48);
  
  await logEvent(contactId, 'financing_approved', { approvedAmount, terms });
}

async function handleFinancingDenied(contactId, denialReason) {
  await updateCustomField(contactId, 'financing_status', 'denied');
  await updateCustomField(contactId, 'financing_denial_reason', denialReason);
  await addTag(contactId, 'financing:denied');
  
  const lead = await getLeadData(contactId);
  
  // Send denial SMS with in‑house plan offer
  const inHouseOffer = `We understand. We offer an in‑house payment plan: 50% deposit, 50% on completion. No credit check. Reply YES to learn more.`;
  await sendSMS(lead.phone, inHouseOffer);
  await sendEmail(lead.email, `Alternative payment plan`, `We have an in‑house plan available. Please reply to this email or call us to discuss.`);
  
  // Create task for rep to follow up
  await createTask(contactId, `Financing denied (${denialReason}). Offer in‑house plan.`, lead.assigned_rep, 4);
  
  // Move back to OBJECTION_HANDLING (price objection unresolved)
  await changeStage(contactId, 'OBJECTION_HANDLING');
  await addTag(contactId, 'objection:price');
  
  await logEvent(contactId, 'financing_denied', { denialReason });
}

async function handleInHousePlanAcceptance(contactId) {
  // Customer replies "YES" to the in‑house offer SMS
  const lead = await getLeadData(contactId);
  
  // Send payment link for 50% deposit
  const depositLink = generatePaymentLink(contactId, lead.estimate_amount * 0.5, 'deposit');
  await sendSMS(lead.phone, `Great! Pay your 50% deposit here: ${depositLink}. The remaining 50% is due upon completion.`);
  
  // Update CRM
  await updateCustomField(contactId, 'financing_status', 'in_house');
  await changeStage(contactId, 'CLOSED_WON'); // or move to INITIAL_PAY stage
  
  await logEvent(contactId, 'in_house_plan_accepted');
}

async function logEvent(contactId, eventType, metadata) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/financing_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        event_type: eventType,
        timestamp: new Date().toISOString(),
        metadata: JSON.stringify(metadata)
      }
    })
  });
}

async function getMaterialsList(estimateId) {
  // Assume estimate stored in CRM with line items
  const estimate = await getEstimate(estimateId);
  return estimate.line_items.map(item => ({
    sku: item.sku,
    description: item.description,
    quantity: item.quantity,
    unit_price: item.unit_price,
    preferred_vendor: item.preferred_vendor || getDefaultVendor(item.category)
  }));
}

const PDFDocument = require('pdfkit');
const fs = require('fs');

async function generatePurchaseOrder(poData) {
  const doc = new PDFDocument();
  const filename = `po_${poData.po_number}_${Date.now()}.pdf`;
  const writeStream = fs.createWriteStream(filename);
  doc.pipe(writeStream);
  
  doc.fontSize(20).text('PURCHASE ORDER', { align: 'center' });
  doc.moveDown();
  doc.fontSize(12).text(`PO Number: ${poData.po_number}`);
  doc.text(`Date: ${poData.date}`);
  doc.text(`Vendor: ${poData.vendor_name}`);
  doc.text(`Job: ${poData.job_name}`);
  doc.moveDown();
  
  // Table header
  doc.text('SKU', 50, doc.y);
  doc.text('Description', 150, doc.y);
  doc.text('Qty', 350, doc.y);
  doc.text('Unit Price', 450, doc.y);
  doc.text('Total', 550, doc.y);
  doc.moveDown();
  
  // Line items
  poData.line_items.forEach(item => {
    doc.text(item.sku, 50, doc.y);
    doc.text(item.description.substring(0, 30), 150, doc.y);
    doc.text(item.quantity, 350, doc.y);
    doc.text(`$${item.unit_price}`, 450, doc.y);
    doc.text(`$${item.quantity * item.unit_price}`, 550, doc.y);
    doc.moveDown();
  });
  
  doc.end();
  return filename;
}

async function sendPOToVendor(poData, vendorEmail, poPdfPath) {
  // Upload PDF to cloud storage
  const s3 = new AWS.S3();
  const s3Key = `pos/${poData.po_number}.pdf`;
  await s3.upload({ Bucket: 'your-bucket', Key: s3Key, Body: fs.createReadStream(poPdfPath) }).promise();
  const poLink = `https://your-bucket.s3.amazonaws.com/${s3Key}`;
  
  // Store link in CRM
  await updateCustomField(poData.contact_id, 'purchase_order_link', poLink);
  
  // Send email to vendor
  const emailBody = `Dear ${poData.vendor_name},\n\nPlease find attached Purchase Order ${poData.po_number}.\n\nClick to view: ${poLink}\n\nPlease acknowledge receipt by replying to this email.\n\nThank you.`;
  await sendEmail(vendorEmail, `Purchase Order ${poData.po_number}`, emailBody);
  
  // Log event
  await logPOEvent(poData.contact_id, 'po_sent', { po_number: poData.po_number, vendor: vendorEmail });
  
  // Start acknowledgment timer
  await scheduleAcknowledgmentTimer(poData.po_number, 24);
}

// Email parsing: when vendor replies to PO email, extract acknowledgment
async function handleVendorReply(email) {
  const poNumber = extractPONumber(email.subject);
  if (!poNumber) return;
  
  const isAcknowledged = email.body.toLowerCase().includes('acknowledge') || email.body.toLowerCase().includes('received');
  if (isAcknowledged) {
    await updatePOStatus(poNumber, 'acknowledged');
    await cancelTimer(poNumber, 'ack_timer');
    await logPOEvent(null, 'po_acknowledged', { po_number: poNumber });
  }
}

async function escalatePO(poNumber) {
  const po = await getPOData(poNumber);
  if (po.status === 'acknowledged') return;
  
  // Second reminder after 24h
  await sendEmail(po.vendor_email, `Reminder: Please acknowledge PO ${poNumber}`, `We have not received acknowledgment. Please respond within 24h.`);
  await scheduleJob(new Date(Date.now() + 24*60*60*1000), 'po_second_escalation', { poNumber });
  await logPOEvent(null, 'po_reminder_sent', { po_number: poNumber });
}

async function secondEscalation(poNumber) {
  const po = await getPOData(poNumber);
  if (po.status === 'acknowledged') return;
  
  // Create task for purchasing manager
  await createTask(po.contact_id, `Vendor ${po.vendor_name} has not acknowledged PO ${poNumber}. Follow up.`, 'purchasing@company.com', 4);
  await sendSlackAlert(`🚨 PO ${poNumber} not acknowledged after 48h. Vendor: ${po.vendor_name}`);
  await logPOEvent(null, 'po_escalated', { po_number: poNumber });
}

async function logPOEvent(contactId, eventType, metadata) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/po_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        event_type: eventType,
        timestamp: new Date().toISOString(),
        metadata: JSON.stringify(metadata)
      }
    })
  });
}

async function startTracking(contactId, trackingNumber, carrier, purchaseOrderId) {
  // Store in CRM
  await updateCustomField(contactId, 'tracking_number', trackingNumber);
  await updateCustomField(contactId, 'carrier', carrier);
  await updateCustomField(contactId, 'tracking_started_at', new Date().toISOString());
  
  // Fetch initial estimated delivery date from carrier API
  const trackingInfo = await fetchTrackingInfo(trackingNumber, carrier);
  const estimatedDelivery = trackingInfo.estimated_delivery_date;
  await updateCustomField(contactId, 'estimated_delivery_date', estimatedDelivery);
  
  // Schedule daily tracking check (cron job at 8 AM)
  await scheduleDailyTrackingJob(contactId, trackingNumber, carrier);
  
  await logTrackingEvent(contactId, 'tracking_started', { trackingNumber, carrier, estimatedDelivery });
}

async function fetchTrackingInfo(trackingNumber, carrier) {
  const response = await fetch('https://api.aftership.com/v4/trackings', {
    method: 'POST',
    headers: {
      'aftership-api-key': process.env.AFTERSHIP_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      tracking: {
        tracking_number: trackingNumber,
        slug: carrier, // fedex, ups, usps
        title: `Order for job ${trackingNumber}`
      }
    })
  });
  const data = await response.json();
  return {
    estimated_delivery_date: data.data.tracking.estimated_delivery,
    current_status: data.data.tracking.tag, // 'Pending', 'InfoReceived', 'InTransit', 'Delivered', 'Exception'
    last_event: data.data.tracking.checkpoints[0]?.message
  };
}

async function checkTrackingStatus(contactId, trackingNumber, carrier) {
  const info = await fetchTrackingInfo(trackingNumber, carrier);
  const previousStatus = await getCustomField(contactId, 'tracking_status');
  const previousEstimate = await getCustomField(contactId, 'estimated_delivery_date');
  
  // Update CRM with latest status
  await updateCustomField(contactId, 'tracking_status', info.current_status);
  await updateCustomField(contactId, 'last_tracking_check', new Date().toISOString());
  await updateCustomField(contactId, 'last_tracking_event', info.last_event);
  
  // Handle delivered
  if (info.current_status === 'Delivered') {
    await handleDeliveryCompleted(contactId);
    return;
  }
  
  // Handle delay: compare estimated delivery date
  if (info.estimated_delivery_date && info.estimated_delivery_date !== previousEstimate) {
    const oldDate = new Date(previousEstimate);
    const newDate = new Date(info.estimated_delivery_date);
    const delayDays = Math.ceil((newDate - oldDate) / (1000 * 60 * 60 * 24));
    
    if (delayDays > 0) {
      await handleDelay(contactId, oldDate, newDate, delayDays);
    }
  }
  
  // Handle exception (lost, damaged, etc.)
  if (info.current_status === 'Exception') {
    await handleTrackingException(contactId, info.last_event);
  }
  
  await logTrackingEvent(contactId, 'tracking_check', { status: info.current_status, estimatedDelivery: info.estimated_delivery_date });
}

async function handleDeliveryCompleted(contactId) {
  await updateCustomField(contactId, 'delivery_completed_at', new Date().toISOString());
  await changeStage(contactId, 'DELIVERY_COMPLETE');
  await addTag(contactId, 'delivery:completed');
  
  // Stop daily tracking jobs (cancel scheduled checks)
  await cancelTrackingJobs(contactId);
  
  // Notify ops that materials are ready
  await sendSlackAlert(`📦 Delivery completed for job ${contactId}. Ready to schedule installation.`);
  
  // Trigger schedule work workflow (Pattern 19)
  await triggerScheduleWorkflow(contactId);
  
  await logTrackingEvent(contactId, 'delivery_completed', {});
}

async function handleDelay(contactId, oldDate, newDate, delayDays) {
  const lead = await getLeadData(contactId);
  
  // Store delay information
  await updateCustomField(contactId, 'delivery_delay_days', delayDays);
  await addTag(contactId, 'delivery:delayed');
  
  // Only notify customer if delay > 2 days (avoid spam for small delays)
  if (delayDays >= 2) {
    await sendSMS(lead.phone, `Update: Your materials delivery has been delayed by ${delayDays} days. New estimated arrival: ${newDate.toDateString()}. We will reschedule your installation accordingly.`);
    await sendEmail(lead.email, `Delivery delay for your project`, `The estimated delivery date for your materials has changed to ${newDate.toDateString()}. We will notify you when installation is rescheduled.`);
  }
  
  // Create task for ops to reschedule installation
  await createTask(contactId, `Delivery delayed by ${delayDays} days. Reschedule installation.`, 'ops@company.com', 24);
  
  // Notify ops via Slack
  await sendSlackAlert(`⚠️ Delivery delay for job ${contactId}: ${delayDays} days. New ETA: ${newDate.toDateString()}`);
  
  await logTrackingEvent(contactId, 'delivery_delay_detected', { oldDate, newDate, delayDays });
}

async function handleTrackingException(contactId, exceptionMessage) {
  const lead = await getLeadData(contactId);
  
  await updateCustomField(contactId, 'tracking_exception', exceptionMessage);
  await addTag(contactId, 'delivery:exception');
  
  // Immediately notify customer
  await sendSMS(lead.phone, `Urgent: There's an issue with your materials delivery: ${exceptionMessage.substring(0, 100)}. We are investigating and will update you.`);
  
  // Create high-priority task for purchasing manager
  await createTask(contactId, `Tracking exception: ${exceptionMessage}. Contact carrier immediately.`, 'purchasing@company.com', 2);
  
  // Send Slack alert to ops channel
  await sendSlackAlert(`🚨 Tracking exception for job ${contactId}: ${exceptionMessage}`);
  
  await logTrackingEvent(contactId, 'tracking_exception', { exceptionMessage });
}

async function logTrackingEvent(contactId, eventType, metadata) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/tracking_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        event_type: eventType,
        timestamp: new Date().toISOString(),
        metadata: JSON.stringify(metadata)
      }
    })
  });
}

const resourceRequirements = {
  'patio_cover': { skill: 'carpentry', crew_size: 2, equipment: ['truck', 'saw', 'drill'] },
  'roofing': { skill: 'roofing', crew_size: 3, equipment: ['ladder', 'nail_gun'] },
  'electrical': { skill: 'electrician', crew_size: 1, equipment: ['van'] }
};

async function getResourceRequirements(serviceType) {
  return resourceRequirements[serviceType] || resourceRequirements.default;
}

const { google } = require('googleapis');
const calendar = google.calendar({ version: 'v3', auth: new google.auth.JWT(...) });

async function findAvailableResources(requiredSkill, startDate, endDate, durationHours) {
  // List all resources (crews) from a dedicated calendar or CRM custom field
  const resources = await getResourceList(); // [{ id, name, skill, calendarId }]
  const available = [];
  
  for (const resource of resources) {
    if (resource.skill !== requiredSkill) continue;
    
    // Check calendar for free/busy
    const freeBusy = await calendar.freebusy.query({
      requestBody: {
        timeMin: startDate.toISOString(),
        timeMax: endDate.toISOString(),
        items: [{ id: resource.calendarId }]
      }
    });
    
    const busySlots = freeBusy.data.calendars[resource.calendarId].busy;
    if (busySlots.length === 0) {
      // Resource fully available in the window
      available.push(resource);
    } else {
      // Check if there is a contiguous free block of durationHours
      // For simplicity, assume fixed slots; real implementation would compute gaps
    }
  }
  
  return available;
}

async function proposeTimeSlots(contactId, availableResources, jobDurationHours) {
  const lead = await getLeadData(contactId);
  // Generate time slots for next 7 days, 9 AM to 5 PM
  const slots = [];
  const startDate = new Date();
  for (let i = 0; i < 7; i++) {
    let slotDate = new Date(startDate);
    slotDate.setDate(startDate.getDate() + i);
    // Skip weekends if needed
    if (slotDate.getDay() === 0 || slotDate.getDay() === 6) continue;
    for (let hour = 9; hour <= 16; hour++) {
      const slotStart = new Date(slotDate);
      slotStart.setHours(hour, 0, 0);
      const slotEnd = new Date(slotStart);
      slotEnd.setHours(slotStart.getHours() + jobDurationHours);
      slots.push({
        start: slotStart,
        end: slotEnd,
        resource: availableResources[0] // simplified: pick first
      });
    }
  }
  
  // Send SMS with booking link pre‑filled with slots
  const bookingLink = generateBookingLink(contactId, slots);
  await sendSMS(lead.phone, `Your materials are ready! Choose an installation time: ${bookingLink}`);
}

async function bookResource(contactId, selectedSlot, resourceId) {
  const lead = await getLeadData(contactId);
  
  // Add event to resource calendar
  const event = {
    summary: `Installation for ${lead.name} - ${lead.service_type}`,
    description: `Address: ${lead.address}, Phone: ${lead.phone}`,
    start: { dateTime: selectedSlot.start.toISOString(), timeZone: 'America/New_York' },
    end: { dateTime: selectedSlot.end.toISOString(), timeZone: 'America/New_York' },
    attendees: [{ email: lead.email }]
  };
  await calendar.events.insert({ calendarId: resourceId, requestBody: event });
  
  // Update CRM
  await updateCustomField(contactId, 'scheduled_resource', resourceId);
  await updateCustomField(contactId, 'scheduled_start', selectedSlot.start.toISOString());
  await updateCustomField(contactId, 'scheduled_end', selectedSlot.end.toISOString());
  await changeStage(contactId, 'WORK_SCHEDULED');
  
  // Notify customer
  const startFormatted = selectedSlot.start.toLocaleString();
  await sendSMS(lead.phone, `Installation scheduled for ${startFormatted}. Your crew will be Crew ${resourceId}.`);
  await sendEmail(lead.email, `Installation scheduled`, `Date: ${startFormatted}\nCrew: Crew ${resourceId}\nAddress: ${lead.address}`);
  
  // Notify crew (via SMS/email)
  const crewLead = await getCrewLead(resourceId);
  await sendSMS(crewLead.phone, `New job scheduled for ${startFormatted}: ${lead.name}, ${lead.address}, ${lead.service_type}.`);
  await sendEmail(crewLead.email, `New installation job`, `Details: ${JSON.stringify(lead)}`);
  
  // Log
  await logSchedulingEvent(contactId, 'work_scheduled', { resourceId, start: selectedSlot.start });
}

async function autoSelectBestSlot(contactId) {
  const lead = await getLeadData(contactId);
  const bestSlot = await getBestAvailableSlot(contactId); // picks earliest
  if (bestSlot) {
    await bookResource(contactId, bestSlot.slot, bestSlot.resourceId);
    await sendSMS(lead.phone, `We've automatically scheduled your installation for ${bestSlot.start.toLocaleString()} to avoid delays. Reply RESCHEDULE if needed.`);
  }
}

async function selectBestResource(availableResources) {
  // Prefer resource with fewest upcoming jobs
  const workload = {};
  for (const resource of availableResources) {
    const events = await calendar.events.list({
      calendarId: resource.calendarId,
      timeMin: new Date().toISOString(),
      maxResults: 50
    });
    workload[resource.id] = events.data.items.length;
  }
  availableResources.sort((a,b) => workload[a.id] - workload[b.id]);
  return availableResources[0];
}

async function logSchedulingEvent(contactId, eventType, metadata) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/scheduling_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        event_type: eventType,
        timestamp: new Date().toISOString(),
        metadata: JSON.stringify(metadata)
      }
    })
  });
}

const projectTemplates = {
  'patio_cover': {
    phases: [
      { name: 'Site preparation', durationDays: 1, sequence: 1 },
      { name: 'Foundation pouring', durationDays: 2, sequence: 2 },
      { name: 'Framing', durationDays: 3, sequence: 3 },
      { name: 'Roof installation', durationDays: 2, sequence: 4 },
      { name: 'Finishing', durationDays: 2, sequence: 5 }
    ]
  },
  'roofing': {
    phases: [
      { name: 'Old roof removal', durationDays: 1, sequence: 1 },
      { name: 'Underlayment installation', durationDays: 1, sequence: 2 },
      { name: 'New shingles', durationDays: 2, sequence: 3 },
      { name: 'Cleanup and inspection', durationDays: 1, sequence: 4 }
    ]
  }
};

async function getProjectPhases(serviceType) {
  return projectTemplates[serviceType] || projectTemplates.default;
}

async function initializeMilestones(contactId, serviceType, startDate) {
  const template = await getProjectPhases(serviceType);
  const milestones = [];
  let currentDate = new Date(startDate);
  
  for (const phase of template.phases) {
    const milestone = {
      contact_id: contactId,
      phase_name: phase.name,
      sequence: phase.sequence,
      scheduled_start: currentDate.toISOString(),
      scheduled_end: new Date(currentDate.getTime() + phase.durationDays * 24*60*60*1000).toISOString(),
      status: 'pending',
      completed_at: null
    };
    milestones.push(milestone);
    await createMilestoneRecord(milestone);
    // Advance date for next phase
    currentDate = new Date(currentDate.getTime() + phase.durationDays * 24*60*60*1000);
  }
  
  // Log initialization
  await logMilestoneEvent(contactId, 'milestones_initialized', { phases: template.phases.length });
  
  // Notify customer of project timeline
  const lead = await getLeadData(contactId);
  const timelineSummary = milestones.map(m => `${m.phase_name}: ${new Date(m.scheduled_start).toLocaleDateString()} - ${new Date(m.scheduled_end).toLocaleDateString()}`).join('\n');
  await sendEmail(lead.email, `Your project timeline for ${serviceType}`, `Estimated phases:\n${timelineSummary}\nWe will notify you at each step.`);
}

async function notifyPhaseStart(contactId, phaseName, scheduledStartDate) {
  const lead = await getLeadData(contactId);
  const startFormatted = new Date(scheduledStartDate).toLocaleDateString();
  
  // Notify crew
  const crewLead = await getAssignedCrew(contactId);
  await sendSMS(crewLead.phone, `Phase "${phaseName}" for job ${contactId} should start today (${startFormatted}). Mark complete when done.`);
  
  // Notify customer (optional – some customers want updates)
  if (await getCustomField(contactId, 'send_phase_updates') !== false) {
    await sendSMS(lead.phone, `Update: Your project is entering the "${phaseName}" phase. We'll notify you when it's complete.`);
  }
  
  await logMilestoneEvent(contactId, 'phase_start_notified', { phase: phaseName, scheduledStart: scheduledStartDate });
}

async function handlePhaseComplete(contactId, phaseName, crewId) {
  // Find the milestone record
  const milestone = await getCurrentPendingMilestone(contactId, phaseName);
  if (!milestone) return;
  
  const now = new Date();
  const scheduledEnd = new Date(milestone.scheduled_end);
  const isLate = now > scheduledEnd;
  
  // Update milestone
  await updateMilestoneRecord(milestone.id, {
    status: 'completed',
    completed_at: now.toISOString(),
    completed_by: crewId,
    is_late: isLate
  });
  
  // Notify customer
  const lead = await getLeadData(contactId);
  await sendSMS(lead.phone, `Great news! The "${phaseName}" phase of your project is complete.`);
  
  // If late, escalate
  if (isLate) {
    const delayHours = Math.ceil((now - scheduledEnd) / (1000*60*60));
    await escalateDelay(contactId, phaseName, delayHours);
  }
  
  // Move to next phase
  const nextMilestone = await getNextPendingMilestone(contactId);
  if (nextMilestone) {
    // Schedule start notification for next phase
    const startDate = new Date();
    // If next phase scheduled earlier than today, adjust
    if (new Date(nextMilestone.scheduled_start) < startDate) {
      await updateMilestoneRecord(nextMilestone.id, { scheduled_start: startDate.toISOString() });
    }
    await notifyPhaseStart(contactId, nextMilestone.phase_name, nextMilestone.scheduled_start);
  } else {
    // All phases complete
    await allPhasesComplete(contactId);
  }
  
  await logMilestoneEvent(contactId, 'phase_completed', { phase: phaseName, isLate, completedAt: now });
}

async function escalateDelay(contactId, phaseName, delayHours) {
  const lead = await getLeadData(contactId);
  
  // Notify customer of delay
  await sendSMS(lead.phone, `The "${phaseName}" phase is ${delayHours} hours behind schedule. We're working to get back on track.`);
  
  // Create task for project manager
  await createTask(contactId, `Phase "${phaseName}" delayed by ${delayHours}h. Investigate and adjust schedule.`, 'pm@company.com', 4);
  
  // Send Slack alert to ops channel
  await sendSlackAlert(`⚠️ Delay on job ${contactId}: Phase "${phaseName}" ${delayHours}h behind.`);
  
  // Adjust subsequent phase dates
  await rescheduleRemainingPhases(contactId);
}

async function rescheduleRemainingPhases(contactId) {
  const pendingMilestones = await getPendingMilestones(contactId);
  if (pendingMilestones.length === 0) return;
  
  let currentDate = new Date();
  for (const milestone of pendingMilestones) {
    const durationDays = (new Date(milestone.scheduled_end) - new Date(milestone.scheduled_start)) / (1000*60*60*24);
    const newStart = currentDate;
    const newEnd = new Date(currentDate.getTime() + durationDays * 24*60*60*1000);
    await updateMilestoneRecord(milestone.id, {
      scheduled_start: newStart.toISOString(),
      scheduled_end: newEnd.toISOString()
    });
    currentDate = newEnd;
  }
  
  // Notify customer of revised timeline
  const lead = await getLeadData(contactId);
  const newTimeline = pendingMilestones.map(m => `${m.phase_name}: ${new Date(m.scheduled_start).toLocaleDateString()} - ${new Date(m.scheduled_end).toLocaleDateString()}`).join('\n');
  await sendEmail(lead.email, `Revised project timeline`, `Due to a delay, your updated schedule is:\n${newTimeline}`);
  
  await logMilestoneEvent(contactId, 'schedule_rescheduled', { pendingPhases: pendingMilestones.length });
}

async function allPhasesComplete(contactId) {
  await updateCustomField(contactId, 'all_phases_completed_at', new Date().toISOString());
  await changeStage(contactId, 'JOB_FINISHED');
  await addTag(contactId, 'job:completed');
  
  // Notify customer
  const lead = await getLeadData(contactId);
  await sendSMS(lead.phone, `All phases of your project are now complete! We'll schedule a final inspection shortly.`);
  
  // Trigger final inspection and sign‑off workflow (Pattern 21)
  await triggerFinalInspection(contactId);
  
  await logMilestoneEvent(contactId, 'all_phases_complete', {});
}

async function logMilestoneEvent(contactId, eventType, metadata) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/milestone_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        event_type: eventType,
        timestamp: new Date().toISOString(),
        metadata: JSON.stringify(metadata)
      }
    })
  });
}

async function generateSignOffRequest(contactId) {
  const lead = await getLeadData(contactId);
  const completionSummary = {
    job_address: lead.address,
    service_type: lead.service_type,
    completion_date: new Date().toISOString(),
    final_amount: lead.estimate_amount,
    notes: await getCustomField(contactId, 'completion_notes') || 'Job completed as specified.'
  };
  
  // Store summary in CRM
  await updateCustomField(contactId, 'completion_summary', JSON.stringify(completionSummary));
  
  // Generate unique sign‑off token (expires in 7 days)
  const token = createJWT({ contactId, exp: Date.now() + 7*24*60*60*1000 });
  const signOffLink = `https://yourdomain.com/signoff/${token}`;
  
  return { signOffLink, completionSummary };
}

async function sendSignOffRequest(contactId) {
  const { signOffLink, completionSummary } = await generateSignOffRequest(contactId);
  const lead = await getLeadData(contactId);
  
  const sms = `Your project is complete! Please review and sign off here: ${signOffLink}`;
  const emailSubject = `Final sign‑off for your ${lead.service_type} project`;
  const emailBody = `
    <p>Dear ${lead.name},</p>
    <p>Your project is complete. Please review the summary below and sign off using the link:</p>
    <p><a href="${signOffLink}">Click here to sign off</a></p>
    <p><strong>Completion summary:</strong><br>
    Address: ${completionSummary.job_address}<br>
    Service: ${completionSummary.service_type}<br>
    Final amount: $${completionSummary.final_amount}<br>
    Completion date: ${new Date(completionSummary.completion_date).toLocaleDateString()}<br>
    Notes: ${completionSummary.notes}</p>
    <p>If you have any issues, please reply to this email.</p>
  `;
  
  await sendSMS(lead.phone, sms);
  await sendEmail(lead.email, emailSubject, emailBody);
  
  // Schedule reminder if no sign‑off after 3 days
  await scheduleReminder(contactId, 'signoff_reminder', 3*24*60*60*1000);
  
  await logSignOffEvent(contactId, 'signoff_request_sent', { link: signOffLink });
}

<!-- signoff.html served by Express -->
<!DOCTYPE html>
<html>
<head>
    <title>Project Sign‑Off</title>
    <script src="https://cdn.jsdelivr.net/npm/signature_pad@4.0.0/dist/signature_pad.umd.min.js"></script>
</head>
<body>
    <h1>Project Completion Sign‑Off</h1>
    <div id="summary"></div>
    <canvas id="signature" width="400" height="200" style="border:1px solid #ccc;"></canvas>
    <button id="clear">Clear</button>
    <button id="submit">Approve & Sign</button>
    <button id="reportIssue">Report Issue</button>
    <div id="issueForm" style="display:none;">
        <textarea id="issueDescription" placeholder="Describe the issue..."></textarea>
        <button id="submitIssue">Submit Issue</button>
    </div>
    
    <script>
        const canvas = document.getElementById('signature');
        const signaturePad = new SignaturePad(canvas);
        const token = window.location.pathname.split('/').pop();
        
        // Load completion summary
        fetch(`/api/signoff/summary/${token}`).then(res => res.json()).then(data => {
            document.getElementById('summary').innerHTML = `
                <p><strong>Address:</strong> ${data.address}</p>
                <p><strong>Service:</strong> ${data.service_type}</p>
                <p><strong>Final amount:</strong> $${data.final_amount}</p>
                <p><strong>Notes:</strong> ${data.notes}</p>
            `;
        });
        
        document.getElementById('submit').onclick = async () => {
            if (signaturePad.isEmpty()) {
                alert('Please provide your signature.');
                return;
            }
            const signatureData = signaturePad.toDataURL();
            const response = await fetch(`/api/signoff/approve/${token}`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ signature: signatureData })
            });
            if (response.ok) {
                alert('Thank you! Your sign‑off has been recorded.');
                window.location.href = '/thankyou';
            } else {
                alert('Error. Please try again.');
            }
        };
        
        document.getElementById('reportIssue').onclick = () => {
            document.getElementById('issueForm').style.display = 'block';
        };
        
        document.getElementById('submitIssue').onclick = async () => {
            const issue = document.getElementById('issueDescription').value;
            if (!issue) return;
            await fetch(`/api/signoff/issue/${token}`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ issue })
            });
            alert('Thank you. We will contact you to resolve the issue.');
            window.location.href = '/thankyou';
        };
    </script>
</body>
</html>

app.post('/api/signoff/approve/:token', async (req, res) => {
  const { token } = req.params;
  const { signature } = req.body;
  const payload = verifyJWT(token);
  const contactId = payload.contactId;
  
  // Generate signed PDF (using PDFKit or similar)
  const pdfPath = await generateSignedPDF(contactId, signature);
  
  // Upload to cloud storage
  const signedUrl = await uploadToS3(pdfPath, `signoffs/${contactId}_${Date.now()}.pdf`);
  
  // Update CRM
  await updateCustomField(contactId, 'signed_off', true);
  await updateCustomField(contactId, 'signed_off_at', new Date().toISOString());
  await updateCustomField(contactId, 'signed_document_url', signedUrl);
  await changeStage(contactId, 'CUSTOMER_SIGNED_OFF');
  
  // Cancel any pending reminders
  await cancelReminders(contactId, 'signoff_reminder');
  
  // Trigger final payment invoice
  await triggerFinalPayment(contactId);
  
  // Notify ops
  await sendSlackAlert(`✅ Customer ${contactId} has signed off. Ready for final payment.`);
  
  await logSignOffEvent(contactId, 'signoff_approved', { signedUrl });
  
  res.status(200).send('OK');
});

app.post('/api/signoff/issue/:token', async (req, res) => {
  const { token } = req.params;
  const { issue } = req.body;
  const payload = verifyJWT(token);
  const contactId = payload.contactId;
  
  await updateCustomField(contactId, 'completion_issues', issue);
  await addTag(contactId, 'completion:issues_reported');
  
  // Create high‑priority task for project manager
  await createTask(contactId, `Customer reported issue: ${issue.substring(0, 100)}. Contact customer to resolve.`, 'pm@company.com', 4);
  
  // Send acknowledgment to customer
  const lead = await getLeadData(contactId);
  await sendSMS(lead.phone, `We received your issue report. A project manager will contact you within 24 hours.`);
  
  await logSignOffEvent(contactId, 'signoff_issue_reported', { issue });
  
  res.status(200).send('OK');
});

async function generateSignedPDF(contactId, signatureDataURL) {
  const lead = await getLeadData(contactId);
  const PDFDocument = require('pdfkit');
  const fs = require('fs');
  const filename = `signoff_${contactId}_${Date.now()}.pdf`;
  const doc = new PDFDocument();
  const writeStream = fs.createWriteStream(filename);
  doc.pipe(writeStream);
  
  doc.fontSize(20).text('JOB COMPLETION SIGN‑OFF', { align: 'center' });
  doc.moveDown();
  doc.fontSize(12).text(`Customer: ${lead.name}`);
  doc.text(`Address: ${lead.address}`);
  doc.text(`Service: ${lead.service_type}`);
  doc.text(`Completion Date: ${new Date().toLocaleDateString()}`);
  doc.text(`Final Amount: $${lead.estimate_amount}`);
  doc.moveDown();
  doc.text('I confirm that the job has been completed to my satisfaction and authorize final payment.', { underline: true });
  doc.moveDown();
  
  // Add signature image
  const base64Data = signatureDataURL.replace(/^data:image\/png;base64,/, '');
  const signatureBuffer = Buffer.from(base64Data, 'base64');
  doc.image(signatureBuffer, { width: 200, height: 80 });
  doc.text(`Signed: ${lead.name}`);
  doc.text(`Date: ${new Date().toLocaleString()}`);
  doc.text(`IP: ${lead.signoff_ip || 'collected at signing'}`);
  
  doc.end();
  return filename;
}

async function logSignOffEvent(contactId, eventType, metadata) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/signoff_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        event_type: eventType,
        timestamp: new Date().toISOString(),
        metadata: JSON.stringify(metadata)
      }
    })
  });
}

async function getWarrantyInfo(contactId) {
  const lead = await getLeadData(contactId);
  const materials = await getMaterialsList(lead.estimate_id); // from Pattern 17
  
  // Identify products that require warranty registration
  const registrations = [];
  for (const material of materials) {
    if (material.warranty_required) {
      registrations.push({
        product_name: material.description,
        model: material.model,
        serial_number: material.serial_number, // captured during installation
        manufacturer: material.manufacturer,
        warranty_years: material.warranty_years,
        registration_deadline: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000) // 30 days from completion
      });
    }
  }
  return registrations;
}

async function registerWarranty(contactId, product) {
  const lead = await getLeadData(contactId);
  
  // Example: Trane warranty API (hypothetical)
  const response = await fetch('https://api.trane.com/warranty/register', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer TRANE_API_KEY', 'Content-Type': 'application/json' },
    body: JSON.stringify({
      customer_name: lead.name,
      customer_email: lead.email,
      customer_phone: lead.phone,
      installation_address: lead.address,
      installation_date: lead.completion_date,
      product_model: product.model,
      serial_number: product.serial_number,
      dealer_id: process.env.TRANE_DEALER_ID
    })
  });
  
  const result = await response.json();
  if (result.status === 'registered') {
    await updateCustomField(contactId, `warranty_${product.model}_reg_number`, result.registration_number);
    await updateCustomField(contactId, `warranty_${product.model}_expiry`, result.expiry_date);
    return { success: true, registration_number: result.registration_number, expiry: result.expiry_date };
  } else {
    await createTask(contactId, `Warranty registration failed for ${product.model}. Manual registration required.`, 'ops@company.com', 24);
    return { success: false };
  }
}

async function generateWarrantyPDF(contactId, warrantyInfo, registrations) {
  const lead = await getLeadData(contactId);
  const PDFDocument = require('pdfkit');
  const fs = require('fs');
  const filename = `warranty_${contactId}_${Date.now()}.pdf`;
  const doc = new PDFDocument();
  const writeStream = fs.createWriteStream(filename);
  doc.pipe(writeStream);
  
  doc.fontSize(20).text('WARRANTY CERTIFICATE', { align: 'center' });
  doc.moveDown();
  doc.fontSize(12).text(`Customer: ${lead.name}`);
  doc.text(`Address: ${lead.address}`);
  doc.text(`Service: ${lead.service_type}`);
  doc.text(`Completion Date: ${new Date(lead.completion_date).toLocaleDateString()}`);
  doc.moveDown();
  doc.text(`This warranty covers the following products:`, { underline: true });
  doc.moveDown();
  
  for (const reg of registrations) {
    doc.text(`Product: ${reg.product_name}`);
    doc.text(`Model: ${reg.model}`);
    doc.text(`Serial Number: ${reg.serial_number}`);
    doc.text(`Warranty Period: ${reg.warranty_years} years`);
    doc.text(`Registration Number: ${reg.registration_number || 'N/A'}`);
    doc.text(`Expiry Date: ${new Date(reg.expiry).toLocaleDateString()}`);
    doc.moveDown();
  }
  
  doc.text(`Warranty Terms:`, { underline: true });
  doc.text(`This warranty covers defects in materials and workmanship for the period stated above.`);
  doc.text(`To make a claim, contact our service department at 555-123-4567 or warranty@company.com.`);
  doc.text(`Retain this certificate for your records.`);
  
  doc.end();
  return filename;
}

async function deliverWarranty(contactId, pdfPath) {
  // Upload to cloud storage
  const s3 = new AWS.S3();
  const s3Key = `warranties/${contactId}_${Date.now()}.pdf`;
  await s3.upload({ Bucket: 'your-bucket', Key: s3Key, Body: fs.createReadStream(pdfPath) }).promise();
  const warrantyLink = `https://your-bucket.s3.amazonaws.com/${s3Key}`;
  
  // Store link in CRM
  await updateCustomField(contactId, 'warranty_document_link', warrantyLink);
  await updateCustomField(contactId, 'warranty_delivered_at', new Date().toISOString());
  
  // Send to customer
  const lead = await getLeadData(contactId);
  const sms = `Your warranty certificate is ready: ${warrantyLink}. Please save it for your records.`;
  const emailSubject = `Warranty certificate for your ${lead.service_type}`;
  const emailBody = `Thank you for choosing us. Your warranty certificate is available at: <a href="${warrantyLink}">${warrantyLink}</a>. Please keep this for future reference.`;
  
  await sendSMS(lead.phone, sms);
  await sendEmail(lead.email, emailSubject, emailBody);
  
  await logWarrantyEvent(contactId, 'warranty_delivered', { link: warrantyLink });
}

async function scheduleWarrantyReminders(contactId, expiryDate) {
  const expiry = new Date(expiryDate);
  const now = new Date();
  
  const reminders = [
    { daysBefore: 30, message: `Your warranty expires in 30 days. Renew to extend coverage.` },
    { daysBefore: 14, message: `Your warranty expires in 14 days. Renew now: ${getRenewalLink(contactId)}` },
    { daysBefore: 7, message: `FINAL REMINDER: Your warranty expires in 7 days. Renew today.` }
  ];
  
  for (const reminder of reminders) {
    const reminderDate = new Date(expiry.getTime() - reminder.daysBefore * 24 * 60 * 60 * 1000);
    if (reminderDate > now) {
      await scheduleMessage(reminderDate, contactId, async () => {
        const lead = await getLeadData(contactId);
        await sendSMS(lead.phone, reminder.message);
        await sendEmail(lead.email, `Warranty renewal reminder`, reminder.message);
        await logWarrantyEvent(contactId, 'warranty_reminder_sent', { daysBefore: reminder.daysBefore });
      });
    }
  }
}

async function handleWarrantyClaim(contactId, issueDescription) {
  const lead = await getLeadData(contactId);
  const warrantyLink = await getCustomField(contactId, 'warranty_document_link');
  
  // Create high‑priority task for service department
  await createTask(contactId, `Warranty claim: ${issueDescription.substring(0, 100)}. Customer: ${lead.name}`, 'service@company.com', 4);
  
  // Send acknowledgment
  await sendSMS(lead.phone, `We received your warranty claim. A service technician will contact you within 2 business days.`);
  
  await logWarrantyEvent(contactId, 'warranty_claim_filed', { issue: issueDescription });
}

async function logWarrantyEvent(contactId, eventType, metadata) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/warranty_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        event_type: eventType,
        timestamp: new Date().toISOString(),
        metadata: JSON.stringify(metadata)
      }
    })
  });
}

async function sendReviewRequest(contactId) {
  const lead = await getLeadData(contactId);
  const completionDate = new Date(lead.completion_date);
  const now = new Date();
  const daysSinceCompletion = (now - completionDate) / (1000*60*60*24);
  
  if (daysSinceCompletion < 5) return; // wait 5 days
  
  // Generate review links
  const googleReviewLink = `https://search.google.com/local/writereview?placeid=${process.env.GOOGLE_PLACE_ID}`;
  const fbReviewLink = `https://www.facebook.com/${process.env.FB_PAGE_ID}/reviews/`;
  
  const sms = `Hi ${lead.name}, we hope you love your new ${lead.service_type}! Please share your experience on Google: ${googleReviewLink} or Facebook: ${fbReviewLink}. Thank you!`;
  const emailSubject = `How did we do? Please review your ${lead.service_type}`;
  const emailBody = `Dear ${lead.name},<br><br>Thank you for choosing us. We'd love your feedback!<br><br><a href="${googleReviewLink}">Leave a Google Review</a><br><a href="${fbReviewLink}">Leave a Facebook Review</a><br><br>Your feedback helps other homeowners make informed decisions.<br><br>Thank you!`;
  
  await sendSMS(lead.phone, sms);
  await sendEmail(lead.email, emailSubject, emailBody);
  
  await addTag(contactId, 'review:requested');
  await updateCustomField(contactId, 'review_requested_at', new Date().toISOString());
  
  // Schedule reminder after 7 days
  await scheduleReviewReminder(contactId, 7);
  
  await logReviewEvent(contactId, 'review_request_sent', { googleLink, fbLink });
}

app.post('/webhook/google-review', express.json(), async (req, res) => {
  // Google sends review data when a new review is posted
  const { name, reviewUrl, rating, comment, reviewerName } = req.body;
  // Match customer by name, phone, or email (fuzzy)
  const contactId = await findContactByReviewerInfo(reviewerName, comment);
  if (!contactId) {
    // Could not match – store in unclaimed queue
    await storeUnclaimedReview({ reviewerName, rating, comment });
    return res.status(200).send('OK');
  }
  
  await handleReviewSubmitted(contactId, rating, comment, 'google');
  res.status(200).send('OK');
});

async function handleReviewSubmitted(contactId, rating, comment, platform) {
  const lead = await getLeadData(contactId);
  
  // Store in CRM
  await updateCustomField(contactId, 'review_given', true);
  await updateCustomField(contactId, 'review_rating', rating);
  await updateCustomField(contactId, 'review_comment', comment);
  await updateCustomField(contactId, 'review_platform', platform);
  await updateCustomField(contactId, 'review_submitted_at', new Date().toISOString());
  await addTag(contactId, `review:${rating >= 4 ? 'positive' : 'negative'}`);
  
  if (rating >= 4) {
    // Positive review: send thank you and trigger referral offer
    await sendSMS(lead.phone, `Thank you for your ${rating}-star review! As a token of appreciation, here's a $200 referral link to share with friends: ${getReferralLink(contactId)}`);
    await triggerReferralOffer(contactId); // Pattern 24
  } else {
    // Negative review: create ops task immediately
    await createTask(contactId, `Customer left a ${rating}-star review: "${comment.substring(0, 100)}". Respond and resolve.`, 'ops_manager@company.com', 4);
    await sendSMS(lead.phone, `We're sorry to hear about your experience. A manager will contact you within 24 hours to make things right.`);
    
    // Also send Slack alert
    await sendSlackAlert(`⚠️ Negative review (${rating} stars) from ${lead.name}: ${comment.substring(0, 100)}`);
  }
  
  // Cancel any pending review reminders
  await cancelReviewReminders(contactId);
  
  await logReviewEvent(contactId, 'review_submitted', { rating, platform, commentPreview: comment.substring(0, 100) });
}

async function scheduleReviewReminder(contactId, daysLater) {
  const reminderDate = new Date(Date.now() + daysLater * 24 * 60 * 60 * 1000);
  await scheduleMessage(reminderDate, contactId, async () => {
    const lead = await getLeadData(contactId);
    const reviewGiven = await getCustomField(contactId, 'review_given');
    if (reviewGiven) return;
    
    // Second reminder
    const googleLink = `https://search.google.com/local/writereview?placeid=${process.env.GOOGLE_PLACE_ID}`;
    await sendSMS(lead.phone, `Hi ${lead.name}, we'd still love your feedback. It takes only 30 seconds: ${googleLink}`);
    await logReviewEvent(contactId, 'review_reminder_sent', { daysLater });
    
    // Schedule final reminder at 14 days
    if (daysLater === 7) {
      await scheduleReviewReminder(contactId, 14);
    } else if (daysLater === 14) {
      // Final reminder – no further action
      await addTag(contactId, 'review:unresponsive');
      await logReviewEvent(contactId, 'review_unresponsive', {});
    }
  });
}

async function autoRespondToReview(contactId, rating, comment, platform) {
  // Only auto-respond to positive reviews
  if (rating < 4) return;
  
  let responseText = `Thank you for your kind words! We're thrilled you had a great experience. Enjoy your ${service_type}! - The Team`;
  
  if (platform === 'google') {
    // Post reply to Google review using API
    await fetch(`https://mybusiness.googleapis.com/v4/accounts/${accountId}/locations/${locationId}/reviews/${reviewId}/reply`, {
      method: 'PUT',
      headers: { 'Authorization': `Bearer ${googleAccessToken}` },
      body: JSON.stringify({ reply: responseText })
    });
  } else if (platform === 'facebook') {
    // Post reply to Facebook comment
    await fetch(`https://graph.facebook.com/v18.0/${commentId}/comments`, {
      method: 'POST',
      params: { message: responseText, access_token: fbAccessToken }
    });
  }
  
  await logReviewEvent(contactId, 'auto_response_sent', { platform, response: responseText });
}

async function logReviewEvent(contactId, eventType, metadata) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/review_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        event_type: eventType,
        timestamp: new Date().toISOString(),
        metadata: JSON.stringify(metadata)
      }
    })
  });
}

async function generateReferralCode(contactId) {
  // Check if already exists
  let existingCode = await getCustomField(contactId, 'referral_code');
  if (existingCode) return existingCode;
  
  const code = generateShortCode(contactId); // e.g., "JOHND5F"
  const referralLink = `https://refer.company.com/${code}`;
  
  await updateCustomField(contactId, 'referral_code', code);
  await updateCustomField(contactId, 'referral_link', referralLink);
  await updateCustomField(contactId, 'referral_created_at', new Date().toISOString());
  
  return { code, link: referralLink };
}

async function sendReferralOffer(contactId) {
  const lead = await getLeadData(contactId);
  const { code, link } = await generateReferralCode(contactId);
  
  const sms = `Love your ${lead.service_type}? Refer a friend and you both get $200 off! Share your unique link: ${link}`;
  const emailSubject = `Refer a friend, get $200`;
  const emailBody = `Thank you for being a valued customer. Share your unique referral link: ${link}<br>When your friend books a project, you both receive $200 off.`;
  
  await sendSMS(lead.phone, sms);
  await sendEmail(lead.email, emailSubject, emailBody);
  
  await addTag(contactId, 'referral:offered');
  await updateCustomField(contactId, 'referral_offered_at', new Date().toISOString());
  
  // Schedule reminders at 30, 60, 90 days
  await scheduleReferralReminders(contactId);
  
  await logReferralEvent(contactId, 'referral_offer_sent', { link });
}

// Landing page route: /:code
app.get('/:code', async (req, res) => {
  const code = req.params.code;
  const referrerId = await getContactIdByReferralCode(code);
  if (!referrerId) {
    return res.status(404).send('Invalid referral code');
  }
  
  // Store referrer_id in session or hidden form field
  res.send(`
    <html>
    <body>
      <h1>You've been referred!</h1>
      <form action="/lead" method="POST">
        <input type="hidden" name="referrer_code" value="${code}">
        <input type="text" name="name" placeholder="Your name" required>
        <input type="phone" name="phone" placeholder="Phone" required>
        <input type="email" name="email" placeholder="Email">
        <button type="submit">Request a free estimate</button>
      </form>
    </body>
    </html>
  `);
});

app.post('/lead', async (req, res) => {
  const { referrer_code, name, phone, email } = req.body;
  const referrerId = await getContactIdByReferralCode(referrer_code);
  
  // Create lead in CRM
  const newContact = await createLead({
    name, phone, email,
    source: 'referral',
    referrer_id: referrerId,
    status: 'NEW_LEAD',
    tags: [`referral:from_${referrerId}`]
  });
  
  // Increment referrer's click count
  await incrementReferralClickCount(referrerId);
  await logReferralEvent(referrerId, 'referral_click', { leadId: newContact.id });
  
  res.send('Thank you! A specialist will contact you soon.');
});

// When a lead reaches CLOSED_WON, webhook triggers
async function handleReferralClosedWon(contactId) {
  const referrerId = await getCustomField(contactId, 'referrer_id');
  if (!referrerId) return;
  
  // Mark this referral as converted
  await updateCustomField(contactId, 'referral_converted', true);
  await updateCustomField(contactId, 'referral_converted_at', new Date().toISOString());
  
  // Update referrer's record
  await addTag(referrerId, 'referral:converted');
  const currentReward = await getCustomField(referrerId, 'referral_reward_earned') || 0;
  const rewardAmount = 200; // configurable
  await updateCustomField(referrerId, 'referral_reward_earned', currentReward + rewardAmount);
  await incrementReferralCount(referrerId);
  
  // Send notification to referrer
  const referrer = await getLeadData(referrerId);
  await sendSMS(referrer.phone, `Your friend ${name} booked a project! Your $${rewardAmount} reward is on its way.`);
  await sendEmail(referrer.email, `Referral reward earned`, `Congratulations! Your friend booked a project. We'll process your $${rewardAmount} reward within 7 days.`);
  
  // Trigger reward fulfillment
  await fulfillReward(referrerId, rewardAmount);
  
  await logReferralEvent(referrerId, 'referral_converted', { referredLeadId: contactId, rewardAmount });
}

async function fulfillReward(referrerId, amount) {
  const referrer = await getLeadData(referrerId);
  
  // Call Tremendous API to send gift card
  const response = await fetch('https://api.tremendous.com/v1/orders', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.TREMENDOUS_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      payment: {
        method: 'balance'
      },
      reward: {
        value: { denomination: amount, currency: 'USD' },
        delivery: { method: 'email', email: referrer.email },
        products: [{ product_id: 'gift_card_product_id' }]
      }
    })
  });
  
  const result = await response.json();
  await updateCustomField(referrerId, 'referral_last_reward_fulfilled_at', new Date().toISOString());
  await addTag(referrerId, 'referral:reward_sent');
  
  await logReferralEvent(referrerId, 'reward_fulfilled', { amount, orderId: result.order.id });
}

async function scheduleReferralReminders(contactId) {
  const intervals = [30, 60, 90]; // days
  for (const days of intervals) {
    const reminderDate = new Date(Date.now() + days * 24 * 60 * 60 * 1000);
    await scheduleMessage(reminderDate, contactId, async () => {
      const lead = await getLeadData(contactId);
      const referralLink = await getCustomField(contactId, 'referral_link');
      const alreadyConverted = await getCustomField(contactId, 'referral_converted_count') > 0;
      if (alreadyConverted) return;
      
      await sendSMS(lead.phone, `Still have friends who need ${lead.service_type}? Share your link and earn $200: ${referralLink}`);
      await logReferralEvent(contactId, 'referral_reminder_sent', { days });
    });
  }
}

async function expireReferral(contactId) {
  const hasConverted = await getCustomField(contactId, 'referral_converted_count') > 0;
  if (hasConverted) return;
  
  await addTag(contactId, 'referral:expired');
  await logReferralEvent(contactId, 'referral_expired', {});
}

async function logReferralEvent(contactId, eventType, metadata) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/referral_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        event_type: eventType,
        timestamp: new Date().toISOString(),
        metadata: JSON.stringify(metadata)
      }
    })
  });
}

// Scheduled every day at 8 AM (Make scenario or Node cron)
async function moveToReactivation() {
  // Query GHL for contacts with reactivation_date <= today AND stage != REACTIVATION
  const today = new Date().toISOString().split('T')[0];
  const contacts = await searchContacts({
    filters: [
      { field: 'reactivation_date', operator: '<=', value: today },
      { field: 'stage', operator: '!=', value: 'REACTIVATION' },
      { field: 'stage', operator: '!=', value: 'CLOSED_WON' } // exclude active customers
    ]
  });
  
  for (const contact of contacts) {
    await changeStage(contact.id, 'REACTIVATION');
    await addTag(contact.id, 'reactivation:entered');
    await logReactivationEvent(contact.id, 'moved_to_reactivation', { previous_stage: contact.stage });
    
    // Send first message immediately
    await sendFirstReactivationMessage(contact.id);
  }
}

async function sendFirstReactivationMessage(contactId) {
  const lead = await getLeadData(contactId);
  const previousEstimate = await getCustomField(contactId, 'estimate_amount');
  const lossReason = await getCustomField(contactId, 'loss_reason');
  
  let offer = '';
  if (lossReason === 'price') {
    offer = `We now offer financing – payments as low as $${Math.round(previousEstimate * 0.02)}/month.`;
  } else if (lossReason === 'timing') {
    offer = `We're scheduling for next month – lock in your project now.`;
  } else {
    offer = `We have a special offer for past leads: $${Math.round(previousEstimate * 0.1)} off your estimate.`;
  }
  
  const sms = `Hi ${lead.name}, still thinking about your ${lead.service_type}? ${offer} Reply YES to revive your estimate.`;
  const emailSubject = `We haven't forgotten about your ${lead.service_type}`;
  const emailBody = `Dear ${lead.name},<br><br>We noticed you were interested in a ${lead.service_type} project. ${offer}<br><br><a href="${getReviveLink(contactId)}">Click here to revive your estimate</a><br><br>Reply to this email or call us.`;
  
  await sendSMS(lead.phone, sms);
  await sendEmail(lead.email, emailSubject, emailBody);
  
  await updateCustomField(contactId, 'reactivation_attempts', 1);
  await updateCustomField(contactId, 'last_reactivation_at', new Date().toISOString());
  await addTag(contactId, 'reactivation:attempt1');
  
  // Schedule second attempt in 14 days
  await scheduleReactivationStep(contactId, 14, 2);
  
  await logReactivationEvent(contactId, 'first_message_sent', { offer });
}

async function handleReactivationReply(contactId, replyText) {
  const lower = replyText.toLowerCase();
  if (lower.includes('yes') || lower.includes('revive') || lower.includes('start') || lower === 'y') {
    // Preserve estimate amount and service type
    const estimateAmount = await getCustomField(contactId, 'estimate_amount');
    const serviceType = await getCustomField(contactId, 'service_type');
    
    // Move back to NEW_LEAD or QUALIFIED (depending on whether estimate still valid)
    await changeStage(contactId, 'QUALIFIED');
    await updateCustomField(contactId, 'lead_score', 70); // reset to qualified
    await removeTags(contactId, ['reactivation:attempt1', 'reactivation:attempt2', 'reactivation:attempt3']);
    await addTag(contactId, 'reactivated:from_lost');
    
    // Notify rep
    await createTask(contactId, `Reactivated lead: ${contactId}. Follow up immediately.`, lead.assigned_rep, 2);
    
    await sendSMS(lead.phone, `Great! Your estimate has been revived. A specialist will contact you shortly.`);
    
    await logReactivationEvent(contactId, 'lead_reactivated', { reply: replyText });
  } else if (lower.includes('stop') || lower.includes('unsubscribe')) {
    // Opt out permanently
    await updateCustomField(contactId, 'do_not_contact', true);
    await changeStage(contactId, 'CLOSED_LOST');
    await addTag(contactId, 'unsubscribed');
    await logReactivationEvent(contactId, 'lead_unsubscribed', { reply: replyText });
  } else {
    // Unclear intent – create task for rep to follow up
    await createTask(contactId, `Lead replied to reactivation with unclear message: "${replyText}". Review.`, lead.assigned_rep, 24);
    await logReactivationEvent(contactId, 'unclear_reply', { reply: replyText });
  }
}

async function sendReactivationStep(contactId, stepNumber) {
  const lead = await getLeadData(contactId);
  const stage = await getContactStage(contactId);
  if (stage !== 'REACTIVATION') return; // already revived
  
  await updateCustomField(contactId, 'reactivation_attempts', stepNumber);
  await addTag(contactId, `reactivation:attempt${stepNumber}`);
  
  let message = '';
  if (stepNumber === 2) {
    message = `Hi ${lead.name}, last chance to revive your ${lead.service_type} estimate with a 10% discount. Reply YES within 7 days.`;
  } else if (stepNumber === 3) {
    message = `FINAL REMINDER: Your estimate expires in 7 days. Reply YES now to lock in your price.`;
  }
  
  await sendSMS(lead.phone, message);
  await sendEmail(lead.email, `Reminder: Your estimate is about to expire`, message);
  
  await logReactivationEvent(contactId, `message_${stepNumber}_sent`, { message });
  
  // Schedule next step or archive
  if (stepNumber < 3) {
    await scheduleReactivationStep(contactId, 14, stepNumber + 1);
  } else {
    // Final step: schedule archive in 14 days if no reply
    await scheduleArchive(contactId, 14);
  }
}

async function archiveUnresponsiveLead(contactId) {
  const stage = await getContactStage(contactId);
  if (stage !== 'REACTIVATION') return;
  
  await changeStage(contactId, 'DORMANT_ARCHIVE');
  await addTag(contactId, 'reactivation:archived');
  await updateCustomField(contactId, 'archived_at', new Date().toISOString());
  
  await logReactivationEvent(contactId, 'lead_archived', {});
}

async function logReactivationEvent(contactId, eventType, metadata) {
  await fetch('https://api.airtable.com/v0/YOUR_BASE_ID/reactivation_log', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer AIRTABLE_API_KEY' },
    body: JSON.stringify({
      fields: {
        contact_id: contactId,
        event_type: eventType,
        timestamp: new Date().toISOString(),
        metadata: JSON.stringify(metadata)
      }
    })
  });
}