function calculateDataQualityScore(source, data) {
  let score = 0;
  
  // Email validation (30 points)
  if (data.email && validateEmail(data.email)) score += 30;
  
  // Phone validation (25 points)  
  if (data.phone && validatePhone(data.phone)) score += 25;
  
  // Complete name (20 points)
  if (data.firstName && data.lastName) score += 20;
  
  // Company data (15 points)
  if (data.companyName && data.website) score += 15;
  
  // Job title (10 points)
  if (data.jobTitle) score += 10;
  
  return Math.min(score, 100);
}

const dataCleansingRules = {
  email: {
    validation: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
    normalize: email => email.toLowerCase().trim()
  },
  phone: {
    clean: phone => phone.replace(/[^\d+]/g, ''),
    format: phone => formatToE164(phone, defaultCountry)
  },
  companyName: {
    clean: name => name.replace(/\b(Inc|LLC|Ltd|Corp)\b\.?/gi, '').trim(),
    normalize: name => properCase(name)
  },
  website: {
    normalize: url => url.replace(/^https?:\/\//, '').replace(/\/$/, '')
  }
}

const dataPrecedence = {
  contactInfo: ['ZoomInfo', 'Apollo.io', 'Hunter.io'],
  companyInfo: ['ZoomInfo', 'Apollo.io', 'Hunter.io'],  
  emailVerification: ['Hunter.io', 'ZoomInfo', 'Apollo.io'],
  phoneNumbers: ['ZoomInfo', 'Apollo.io'],
  socialMedia: ['Apollo.io', 'ZoomInfo'],
  technographics: ['Apollo.io', 'ZoomInfo']
};

function generateDeduplicationKey(leadData) {
  const email = leadData.email ? leadData.email.toLowerCase() : '';
  const company = leadData.companyName ? leadData.companyName.toLowerCase().replace(/[^a-z0-9]/g, '') : '';
  const name = (leadData.firstName + leadData.lastName).toLowerCase().replace(/[^a-z]/g, '');
  
  // Primary key: email
  if (email) return `email:${email}`;
  
  // Secondary key: company + name
  if (company && name) return `company-person:${company}-${name}`;
  
  // Fallback: phone number
  if (leadData.phone) return `phone:${leadData.phone.replace(/[^\d]/g, '')}`;
  
  return null; // Skip record if no deduplication key possible
}

async function smartUpdateLead(existingTicket, newLeadData, haloApi) {
  const updatePayload = {
    id: existingTicket.id
  };
  
  const fieldsToUpdate = [];
  const fieldsPreserved = [];
  
  // NEVER update these workflow-critical fields if manually changed
  const protectedFields = [
    'status_id',           // Preserve manual status changes
    'agent_id',           // Preserve assigned agent
    'priority_id',        // Preserve manual priority changes
    'category_1',         // Preserve lead classification
    'notes',              // Preserve manual notes/updates
    'last_update_date'    // System managed
  ];
  
  // ALWAYS update these data enrichment fields (if new data available)
  const enrichmentFields = {
    // Contact data updates
    'phonenumber': newLeadData.phone,
    'linkedin_url': newLeadData.linkedinUrl,
    
    // Custom field updates (CF_106-113 - new enrichment data)
    'CF_106_technology_stack': newLeadData.technologyStack,
    'CF_107_revenue_range': newLeadData.revenueRange,
    'CF_108_employee_count_range': newLeadData.employeeCountRange,
    'CF_109_management_level': newLeadData.managementLevel,
    'CF_110_department_function': newLeadData.departmentFunction,
    'CF_111_intent_signals': newLeadData.intentSignals,
    'CF_112_company_founded_year': newLeadData.foundedYear,
    'CF_113_location_hq': newLeadData.hqAddress
  };
  
  // CONDITIONALLY update these fields (only if empty or significantly different)
  const conditionalFields = {
    'CF_102_services_offered': {
      existing: existingTicket.customfields?.find(f => f.id === 102)?.value,
      new: newLeadData.servicesOffered,
      updateIf: (existing, newVal) => !existing || (newVal && newVal.length > existing.length * 1.5)
    },
    'CF_103_growth_signals': {
      existing: existingTicket.customfields?.find(f => f.id === 103)?.value,  
      new: newLeadData.growthSignals,
      updateIf: (existing, newVal) => !existing || (newVal && !existing.includes(newVal))
    },
    'CF_104_project_pipelines': {
      existing: existingTicket.customfields?.find(f => f.id === 104)?.value,
      new: newLeadData.projectPipelines,
      updateIf: (existing, newVal) => !existing || (newVal && !existing.includes(newVal))
    }
  };
  
  // Process enrichment fields (always update if new data exists)
  const customFieldUpdates = [];
  Object.entries(enrichmentFields).forEach(([fieldKey, newValue]) => {
    if (newValue && newValue !== '') {
      const fieldId = parseInt(fieldKey.match(/CF_(\d+)/)?.[1]);
      if (fieldId) {
        customFieldUpdates.push({"id": fieldId, "value": newValue});
        fieldsToUpdate.push(fieldKey);
      }
    }
  });
  
  // Process conditional fields
  Object.entries(conditionalFields).forEach(([fieldKey, config]) => {
    if (config.updateIf(config.existing, config.new)) {
      const fieldId = parseInt(fieldKey.match(/CF_(\d+)/)?.[1]);
      if (fieldId && config.new) {
        customFieldUpdates.push({"id": fieldId, "value": config.new});
        fieldsToUpdate.push(fieldKey);
      }
    } else {
      fieldsPreserved.push(fieldKey);
    }
  });
  
  // Check if status progression should be blocked
  const hasManualUpdates = existingTicket.last_update_user !== 'B2B Integration';
  const statusChanged = existingTicket.status_id !== 1; // Not "New Lead"
  
  if (hasManualUpdates || statusChanged) {
    fieldsPreserved.push('status_id', 'workflow_position');
    console.log(`⚠️  Preserving manual changes for ticket ${existingTicket.id}`);
  }
  
  // Only proceed with update if there are fields to update
  if (customFieldUpdates.length > 0) {
    updatePayload.customfields = customFieldUpdates;
    
    // Add update tracking
    updatePayload.notes = existingTicket.notes + 
      `\n\n[${new Date().toISOString()}] Auto-updated from ${newLeadData.source}:\n` +
      `✓ Updated: ${fieldsToUpdate.join(', ')}\n` +
      `🔒 Preserved: ${fieldsPreserved.join(', ')}`;
    
    const result = await haloApi.put(`/api/Tickets/${existingTicket.id}`, updatePayload);
    
    return {
      action: 'updated',
      ticket_id: existingTicket.id,
      fields_updated: fieldsToUpdate,
      fields_preserved: fieldsPreserved,
      manual_work_detected: hasManualUpdates || statusChanged
    };
  }
  
  return {
    action: 'skipped',
    ticket_id: existingTicket.id,
    reason: 'No new data to update',
    manual_work_detected: hasManualUpdates || statusChanged
  };
}

async function processLeadImport(newLeadData, haloApi) {
  // 1. Generate deduplication key
  const dedupKey = generateDeduplicationKey(newLeadData);
  if (!dedupKey) {
    return { action: 'rejected', reason: 'Insufficient data for deduplication' };
  }
  
  // 2. Search for existing lead
  const existingTicket = await haloApi.get('/api/Tickets', {
    params: {
      search: newLeadData.email,
      tickettype_id: 1, // Lead type
      include_custom_fields: '101,102,103,104,105,106,107,108,109,110,111,112,113'
    }
  });
  
  // 3. Determine action based on existence and status
  if (existingTicket && existingTicket.length > 0) {
    const ticket = existingTicket[0];
    
    // Check if ticket has progressed beyond initial lead stage
    if (ticket.status_id > 2 || ticket.tickettype_id > 1) { // Beyond "Researching" or converted
      return {
        action: 'preserved',
        ticket_id: ticket.id,
        reason: 'Lead has progressed in workflow - preserving all data',
        current_status: ticket.status_name
      };
    }
    
    // Perform smart update for early-stage leads
    return await smartUpdateLead(ticket, newLeadData, haloApi);
  } else {
    // 4. Create new lead (original creation logic)
    return await createLeadWithListAssignment(newLeadData, haloApi);
  }
}

// Enhanced logging for update decisions
function logUpdateDecision(result, leadData) {
  const logEntry = {
    timestamp: new Date().toISOString(),
    source: leadData.source,
    email: leadData.email,
    company: leadData.companyName,
    action: result.action,
    ticket_id: result.ticket_id,
    fields_updated: result.fields_updated || [],
    fields_preserved: result.fields_preserved || [],
    manual_work_detected: result.manual_work_detected || false
  };
  
  // Log to your preferred monitoring system
  console.log('Lead Update Decision:', logEntry);
  
  // Optional: Send to webhook for tracking
  // await sendToWebhook('lead-update-audit', logEntry);
  
  return logEntry;
}

// Monitor HaloPSA for DNC flag changes and sync back to source systems
async function syncDoNotContactToSources(ticket, haloApi) {
  // Detect DNC flag changes
  const dncField = ticket.customfields?.find(f => f.id === 105); // CF_105: Do Not Contact
  const leadSource = ticket.customfields?.find(f => f.id === 101)?.value; // CF_101: Lead Source
  
  if (!dncField?.value || !leadSource) return null;
  
  const contactData = {
    email: ticket.reportedby,
    firstName: ticket.user?.firstname,
    lastName: ticket.user?.surname,
    companyName: ticket.client?.name,
    reason: 'Opted out via HaloPSA workflow',
    timestamp: new Date().toISOString(),
    halo_ticket_id: ticket.id
  };
  
  const suppressionResults = [];
  
  try {
    // Push to appropriate B2B platform based on source
    switch (leadSource.toLowerCase()) {
      case 'apollo.io':
        const apolloResult = await addToApolloSuppression(contactData);
        suppressionResults.push({source: 'Apollo.io', status: apolloResult.status});
        break;
        
      case 'zoominfo':
        const zoomResult = await addToZoomInfoSuppression(contactData);
        suppressionResults.push({source: 'ZoomInfo', status: zoomResult.status});
        break;
        
      case 'hunter.io':
        const hunterResult = await addToHunterSuppression(contactData);
        suppressionResults.push({source: 'Hunter.io', status: hunterResult.status});
        break;
        
      default:
        // For unknown sources, log but don't fail
        console.log(`Unknown lead source for DNC sync: ${leadSource}`);
    }
    
    // Update ticket with suppression status
    await haloApi.put(`/api/Tickets/${ticket.id}`, {
      notes: ticket.notes + 
        `\n\n[${new Date().toISOString()}] DNC Suppression Sync:\n` +
        suppressionResults.map(r => `✓ ${r.source}: ${r.status}`).join('\n')
    });
    
    return {
      success: true,
      suppressions_added: suppressionResults,
      contact: contactData.email
    };
    
  } catch (error) {
    console.error('DNC sync failed:', error);
    
    // Log failure but don't block HaloPSA workflow
    await haloApi.put(`/api/Tickets/${ticket.id}`, {
      notes: ticket.notes + 
        `\n\n[${new Date().toISOString()}] DNC Suppression Sync FAILED: ${error.message}`
    });
    
    return {
      success: false,
      error: error.message,
      contact: contactData.email
    };
  }
}

async function addToApolloSuppression(contactData) {
  const apolloConfig = {
    url: 'https://api.apollo.io/v1/emailer_campaigns/email_accounts/suppression_list',
    headers: {
      'Content-Type': 'application/json',
      'Cache-Control': 'no-cache',
      'X-Api-Key': process.env.APOLLO_API_KEY
    }
  };
  
  const payload = {
    email_account_id: process.env.APOLLO_EMAIL_ACCOUNT_ID,
    suppression_list_entries: [{
      email: contactData.email,
      first_name: contactData.firstName,
      last_name: contactData.lastName,
      suppression_reason: contactData.reason
    }]
  };
  
  const response = await fetch(apolloConfig.url, {
    method: 'POST',
    headers: apolloConfig.headers,
    body: JSON.stringify(payload)
  });
  
  return {
    status: response.ok ? 'Added to suppression list' : `Failed: ${response.statusText}`,
    api_response: await response.json()
  };
}

async function addToZoomInfoSuppression(contactData) {
  const zoomConfig = {
    url: 'https://api.zoominfo.com/lookup/suppression',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${process.env.ZOOMINFO_ACCESS_TOKEN}`
    }
  };
  
  const payload = {
    emails: [contactData.email],
    suppression_reason: contactData.reason,
    source: 'HaloPSA_Integration'
  };
  
  const response = await fetch(zoomConfig.url, {
    method: 'POST',
    headers: zoomConfig.headers,
    body: JSON.stringify(payload)
  });
  
  return {
    status: response.ok ? 'Added to suppression list' : `Failed: ${response.statusText}`,
    api_response: await response.json()
  };
}

async function addToHunterSuppression(contactData) {
  const hunterConfig = {
    url: 'https://api.hunter.io/v2/leads/suppression',
    headers: {
      'Content-Type': 'application/json'
    }
  };
  
  const params = new URLSearchParams({
    api_key: process.env.HUNTER_API_KEY,
    email: contactData.email,
    reason: contactData.reason
  });
  
  const response = await fetch(`${hunterConfig.url}?${params}`, {
    method: 'POST',
    headers: hunterConfig.headers
  });
  
  return {
    status: response.ok ? 'Added to suppression list' : `Failed: ${response.statusText}`,
    api_response: await response.json()
  };
}

// Webhook endpoint to handle DNC changes from HaloPSA
app.post('/webhooks/dnc-sync', async (req, res) => {
  const { ticket_id, event_type, changes } = req.body;
  
  try {
    // Fetch full ticket details
    const ticket = await haloApi.get(`/api/Tickets/${ticket_id}`, {
      params: { include_custom_fields: 'all' }
    });
    
    // Check if DNC flag was set
    const dncChanged = changes.customfields?.some(cf => 
      cf.id === 105 && cf.new_value === true
    );
    
    const statusChangedToDNC = changes.status_id?.new_value === 6; // "Do Not Contact" status
    
    if (dncChanged || statusChangedToDNC) {
      // Execute bi-directional sync
      const result = await syncDoNotContactToSources(ticket, haloApi);
      
      console.log('DNC Sync Result:', result);
      
      // Respond with success
      res.json({
        success: true,
        ticket_id: ticket_id,
        suppression_result: result
      });
    } else {
      res.json({
        success: true,
        message: 'No DNC changes detected'
      });
    }
  } catch (error) {
    console.error('Webhook DNC sync failed:', error);
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

// Sync verified contact data back to B2B sources
async function syncContactUpdates(ticket, changes, haloApi) {
  const updates = {};
  
  // Phone number verification/updates
  if (changes.user?.phonenumber) {
    updates.verified_phone = changes.user.phonenumber;
    updates.phone_verification_date = new Date().toISOString();
  }
  
  // Email verification (bounces, corrections)
  if (changes.user?.emailaddress) {
    updates.verified_email = changes.user.emailaddress;
    updates.email_status = 'verified';
  }
  
  // Job title corrections from actual conversations
  if (changes.user?.jobtitle) {
    updates.corrected_title = changes.user.jobtitle;
    updates.title_verification_source = 'direct_contact';
  }
  
  return await pushToSourceAPI(updates, ticket.leadSource);
}

// Share discovered company insights back to B2B platforms
async function syncCompanyIntelligence(ticket, discoveredData) {
  const companyUpdates = {
    // Technology stack discoveries during sales conversations
    verified_technologies: discoveredData.actualTechStack,
    tech_pain_points: discoveredData.technologyChallenges,
    
    // Accurate employee count from direct contact
    verified_employee_count: discoveredData.actualEmployeeCount,
    employee_count_source: 'sales_conversation',
    
    // Real decision maker structure
    decision_makers: discoveredData.identifiedDecisionMakers,
    procurement_process: discoveredData.buyingProcess,
    
    // Budget reality vs estimates
    actual_budget_range: discoveredData.confirmedBudget,
    budget_timeline: discoveredData.budgetCycle,
    
    // Competitive landscape insights
    current_vendors: discoveredData.existingVendors,
    vendor_satisfaction: discoveredData.vendorFeedback
  };
  
  return await enrichSourceDatabase(companyUpdates, ticket.companyId);
}

// Provide lead scoring feedback to improve source algorithms
async function syncLeadQualityFeedback(ticket, outcome) {
  const qualityMetrics = {
    // Conversion tracking
    lead_id: ticket.sourceLeadId,
    conversion_stage: ticket.currentStage, // Lead → Prospect → Opportunity → Won
    conversion_timeline: calculateTimeline(ticket.createdDate, ticket.lastUpdate),
    
    // Quality indicators
    data_accuracy_score: calculateDataAccuracy(ticket),
    contact_reachability: ticket.contactAttempts?.success_rate,
    decision_maker_accuracy: ticket.decisionMakerVerified,
    
    // Sales feedback
    sales_feedback: {
      lead_quality: ticket.salesTeamRating, // 1-10 scale
      data_completeness: ticket.missingDataPoints,
      follow_up_potential: ticket.futureOpportunityScore
    },
    
    // Outcome tracking
    final_outcome: outcome.result, // won, lost, disqualified
    outcome_reason: outcome.reason,
    deal_value: outcome.dealValue || null
  };
  
  return await sendQualityFeedback(qualityMetrics, ticket.leadSource);
}

// Track engagement activities back to source for better intent scoring
async function syncEngagementData(ticket, activities) {
  const engagementData = {
    contact_email: ticket.contactEmail,
    
    // Call tracking
    calls_made: activities.calls?.length || 0,
    calls_answered: activities.calls?.filter(c => c.connected).length || 0,
    avg_call_duration: calculateAverageCallTime(activities.calls),
    
    // Email engagement  
    emails_sent: activities.emails?.length || 0,
    emails_opened: activities.emails?.filter(e => e.opened).length || 0,
    emails_replied: activities.emails?.filter(e => e.replied).length || 0,
    
    // Meeting outcomes
    meetings_scheduled: activities.meetings?.length || 0,
    meetings_attended: activities.meetings?.filter(m => m.attended).length || 0,
    
    // Response patterns
    best_contact_time: identifyBestContactTime(activities),
    preferred_contact_method: identifyPreferredMethod(activities),
    response_time_avg: calculateAverageResponseTime(activities)
  };
  
  return await updateEngagementProfile(engagementData, ticket.leadSource);
}

// Share market insights discovered during sales process
async function syncMarketIntelligence(ticket, marketData) {
  const insights = {
    // Industry trends discovered
    industry_challenges: marketData.commonPainPoints,
    technology_adoption_trends: marketData.techTrends,
    budget_allocation_patterns: marketData.spendingPatterns,
    
    // Competitive intelligence
    competitor_strengths: marketData.competitorAdvantages,
    competitor_weaknesses: marketData.competitorGaps,
    pricing_sensitivity: marketData.pricingFeedback,
    
    // Solution effectiveness
    successful_use_cases: marketData.winningScenarios,
    implementation_challenges: marketData.commonObstacles,
    roi_expectations: marketData.expectedOutcomes
  };
  
  return await contributeMarketIntelligence(insights, ticket.industry);
}

// Correct inaccurate data found during sales process
async function syncDataCorrections(ticket, corrections) {
  const dataFixes = {
    // Contact corrections
    contact_corrections: {
      incorrect_email: corrections.emailChanges,
      incorrect_phone: corrections.phoneChanges,
      incorrect_title: corrections.titleCorrections,
      incorrect_department: corrections.departmentChanges
    },
    
    // Company corrections
    company_corrections: {
      incorrect_industry: corrections.industryChanges,
      incorrect_size: corrections.sizeCorrections,
      incorrect_revenue: corrections.revenueCorrections,
      incorrect_headquarters: corrections.locationChanges,
      outdated_website: corrections.websiteChanges
    },
    
    // Technology corrections
    technology_corrections: {
      outdated_tech_stack: corrections.techUpdates,
      missing_technologies: corrections.additionalTech,
      incorrect_platforms: corrections.platformChanges
    }
  };
  
  return await submitDataCorrections(dataFixes, ticket.leadSource);
}

// Validate and enhance intent signals based on actual conversations
async function syncIntentValidation(ticket, intentData) {
  const validatedSignals = {
    // Buying intent confirmation
    confirmed_buying_intent: intentData.actualBuyingIntent,
    buying_timeline_confirmed: intentData.actualTimeline,
    budget_intent_validated: intentData.budgetReality,
    
    // Decision process insights
    actual_decision_process: intentData.realDecisionProcess,
    key_decision_criteria: intentData.decisionFactors,
    approval_requirements: intentData.approvalProcess,
    
    // Pain point validation
    confirmed_pain_points: intentData.validatedPains,
    priority_ranking: intentData.painPriority,
    solution_urgency: intentData.urgencyLevel,
    
    // Competitive situation
    active_evaluations: intentData.competitorEvaluations,
    incumbent_solutions: intentData.currentSolutions,
    switching_likelihood: intentData.changeProbability
  };
  
  return await validateIntentSignals(validatedSignals, ticket.contactId);
}

// Unified bi-directional sync orchestrator
class BiDirectionalSyncManager {
  constructor(haloApi, b2bConfigs) {
    this.haloApi = haloApi;
    this.b2bConfigs = b2bConfigs;
    this.syncQueue = [];
  }
  
  async processTicketUpdate(ticket, changes) {
    const syncTasks = [];
    
    // Determine which sync types apply
    if (this.isDNCUpdate(changes)) {
      syncTasks.push(this.syncDoNotContact(ticket));
    }
    
    if (this.isContactUpdate(changes)) {
      syncTasks.push(this.syncContactUpdates(ticket, changes));
    }
    
    if (this.isCompanyDiscovery(changes)) {
      syncTasks.push(this.syncCompanyIntelligence(ticket, changes));
    }
    
    if (this.isOutcomeUpdate(changes)) {
      syncTasks.push(this.syncLeadQualityFeedback(ticket, changes));
    }
    
    if (this.isEngagementActivity(changes)) {
      syncTasks.push(this.syncEngagementData(ticket, changes));
    }
    
    // Execute all applicable sync tasks
    return await Promise.allSettled(syncTasks);
  }
  
  isDNCUpdate(changes) {
    return changes.customfields?.some(cf => cf.id === 105) || 
           changes.status_id === 6;
  }
  
  isContactUpdate(changes) {
    return changes.user?.emailaddress || 
           changes.user?.phonenumber || 
           changes.user?.jobtitle;
  }
  
  isCompanyDiscovery(changes) {
    return changes.customfields?.some(cf => 
      [106, 107, 108, 109, 110].includes(cf.id)
    );
  }
  
  isOutcomeUpdate(changes) {
    return changes.status_id > 10 || // Advanced status
           changes.tickettype_id > 1;   // Converted to Prospect/Opportunity
  }
  
  isEngagementActivity(changes) {
    return changes.actions?.length > 0 || // New activities
           changes.last_contact_date;     // Engagement tracking
  }
}

async function assignLeadToLists(leadData, haloApi) {
  const assignments = [];
  
  // Source-based assignment
  const sourceList = await getListBySource(leadData.leadSource);
  if (sourceList) assignments.push(sourceList.id);
  
  // Qualification-based assignment  
  const fitScore = leadData.customFields.find(f => f.id === 206)?.value || 0;
  if (fitScore > 80) assignments.push(await getListId('hot_leads'));
  else if (fitScore >= 60) assignments.push(await getListId('warm_leads'));
  else assignments.push(await getListId('cold_leads'));
  
  // Industry-based assignment
  const industry = leadData.customFields.find(f => f.id === 102)?.value;
  const industryList = await getListByIndustry(industry);
  if (industryList) assignments.push(industryList.id);
  
  // Size-based assignment
  const employeeCount = leadData.customFields.find(f => f.id === 108)?.value;
  const sizeList = await getListByCompanySize(employeeCount);
  if (sizeList) assignments.push(sizeList.id);
  
  // Do Not Contact check
  const dncFlag = leadData.customFields.find(f => f.id === 105)?.value;
  if (dncFlag) assignments.push(await getListId('dnc_list'));
  
  return assignments;
}

// After creating the lead ticket, assign to appropriate lists
async function createLeadWithListAssignment(leadData, haloApi) {
  // 1. Create the lead ticket
  const ticket = await haloApi.post('/api/Tickets', {
    tickettype_id: 1,
    summary: `${leadData.firstName} ${leadData.lastName} - ${leadData.companyName}`,
    details: `Lead imported from ${leadData.source} on ${new Date().toISOString()}`,
    status_id: 1,
    priority_id: 3,
    category_1: "Lead",
    category_2: leadData.source,
    customfields: [
      {"id": 101, "value": leadData.source},
      {"id": 102, "value": leadData.servicesOffered},
      {"id": 103, "value": leadData.growthSignals},
      {"id": 104, "value": leadData.projectPipelines},
      {"id": 105, "value": leadData.doNotContact},
      {"id": 106, "value": leadData.technologyStack},
      {"id": 107, "value": leadData.revenueRange},
      {"id": 108, "value": leadData.employeeCountRange},
      {"id": 109, "value": leadData.managementLevel},
      {"id": 110, "value": leadData.departmentFunction},
      {"id": 111, "value": leadData.intentSignals},
      {"id": 112, "value": leadData.foundedYear},
      {"id": 113, "value": leadData.hqAddress}
    ]
  });

  // 2. Determine appropriate lists
  const listAssignments = await assignLeadToLists(leadData, haloApi);
  
  // 3. Add ticket to each relevant list
  for (const listId of listAssignments) {
    await haloApi.post(`/api/Lists/${listId}/items`, {
      ticket_id: ticket.id,
      added_by: "B2B Integration",
      notes: `Auto-assigned based on: ${leadData.source} source`
    });
  }
  
  return {
    ticket_id: ticket.id,
    assigned_lists: listAssignments,
    summary: `Lead created and assigned to ${listAssignments.length} lists`
  };
}

// 1. Create Client (Organization)
const client = await fetch('/api/Client', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${accessToken}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(organizationData)
});

// 2. Create Site (Primary location)  
const site = await fetch('/api/Site', {
  method: 'POST', 
  headers: {
    'Authorization': `Bearer ${accessToken}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({...siteData, client_id: client.id})
});

// 3. Create User (Contact)
const user = await fetch('/api/Users', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${accessToken}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({...userData, site_id: site.id})
});

// 4. Create Ticket (Lead) 
const ticket = await fetch('/api/Tickets', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${accessToken}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    ...ticketData, 
    client_id: client.id,
    user_id: user.id
  })
});