// Start the report
const session = await codex.startTask(`
  Generate a weekly pipeline report for the executive team.
  Include: stage progression, new opportunities, closed deals.
`);

// Steer as it works
await session.steer("Add win/loss reasons for closed deals");
await session.steer("Break down new opps by source");
await session.steer("Highlight any deals that skipped stages");

// Get final output
const report = await session.complete();

const session = await codex.startTask(`
  Rebalance sales territories based on Q1 performance data.
`);

// Adjust criteria in real-time
await session.steer("Account for the new Austin rep starting Monday");
await session.steer("Keep enterprise accounts with existing reps");
await session.steer("Show me the impact on each rep's quota");

const territories = await session.complete();

const session = await codex.startTask(`
  Generate personalized emails for 50 conference attendees.
`);

// Refine the approach
await session.steer("Make them shorter - 3 sentences max");
await session.steer("Reference specific sessions they attended");
await session.steer("Skip anyone who's already a customer");

const emails = await session.complete();

const session = await codex.startTask(`
  Analyze the Acme Corp opportunity and recommend next steps.
`);

// Add context as you think of it
await session.steer("They mentioned budget concerns in the last call");
await session.steer("Their competitor just signed with us");
await session.steer("The CFO is the real decision maker, not the VP");

const analysis = await session.complete();

async function buildTargetList(criteria) {
  const session = await codex.startTask(`
    Build a target account list matching: ${criteria.initial}
  `);
  
  // Watch progress and refine
  session.onProgress(async (progress) => {
    if (progress.accounts > 100) {
      await session.steer("Limit to top 50 by revenue");
    }
    if (progress.includesCompetitorCustomers) {
      await session.steer("Exclude known competitor customers");
    }
  });
  
  return session.complete();
}

async function analyzeDeals(pipeline) {
  const session = await codex.startTask(`
    Analyze pipeline health for Q1 forecast.
  `);
  
  // Handle edge cases as they appear
  session.onAnomaly(async (anomaly) => {
    if (anomaly.type === 'missing_data') {
      await session.steer(`Skip ${anomaly.deal} - incomplete record`);
    }
    if (anomaly.type === 'outlier') {
      await session.steer(`Flag ${anomaly.deal} for manual review`);
    }
  });
  
  return session.complete();
}

async function buildForecast() {
  const session = await codex.startTask(`
    Generate Q2 revenue forecast based on current pipeline.
  `);
  
  // Sales leader input
  await session.steer("Use 60% close rate for enterprise, not 40%");
  
  // Finance input  
  await session.steer("Apply 10% churn assumption to renewals");
  
  // CEO input
  await session.steer("Add scenario for if the big deal slips");
  
  return session.complete();
}

async function buildWithLearning(task, userId) {
  const session = await codex.startTask(task);
  const steerings = [];
  
  session.onSteer((input) => {
    steerings.push({
      trigger: session.currentState(),
      steering: input,
      userId: userId
    });
  });
  
  const result = await session.complete();
  
  // Store patterns for future prompts
  await saveSteerings(task.type, steerings);
  
  return result;
}

const { Codex } = require('@openai/codex');

const codex = new Codex({ model: 'gpt-5.3-codex' });

async function steerableTask() {
  const session = await codex.createSession();
  
  // Start task
  await session.send(`
    Analyze our CRM data and identify upsell opportunities.
    Data source: HubSpot
  `);
  
  // Wait for initial processing
  await session.waitForProgress(0.3); // 30% complete
  
  // Steer based on early results
  const preliminary = await session.getProgress();
  if (preliminary.includesSmallAccounts) {
    await session.steer("Focus on accounts with ARR > $50K only");
  }
  
  // Wait for more progress
  await session.waitForProgress(0.7); // 70% complete
  
  // Final refinement
  await session.steer("Rank by expansion likelihood, not just ARR");
  
  // Get final output
  return session.complete();
}

// api/hubspot/book.js
const HubSpot = require('@hubspot/api-client');

const hubspot = new HubSpot.Client({ accessToken: process.env.HUBSPOT_TOKEN });

async function bookMeeting(email, name, qualificationData) {
  // Create or update contact in HubSpot
  const contact = await hubspot.crm.contacts.basicApi.create({
    properties: {
      email,
      firstname: name.split(' ')[0],
      lastname: name.split(' ').slice(1).join(' '),
      lead_source: 'Inbound Chat',
      qualification_score: qualificationData.score,
      qualification_notes: qualificationData.notes,
      lifecyclestage: 'salesqualifiedlead'
    }
  });
  
  // Generate Calendly link with pre-filled info
  const calendlyLink = `https://calendly.com/your-team/demo?name=${encodeURIComponent(name)}&email=${encodeURIComponent(email)}`;
  
  // Log activity in HubSpot
  await hubspot.crm.timeline.eventsApi.create({
    eventTemplateId: 'chat_qualified',
    objectId: contact.id,
    tokens: {
      score: qualificationData.score,
      summary: qualificationData.notes
    }
  });
  
  return {
    calendlyLink,
    contactId: contact.id,
    message: `Great! Here's a link to book directly with our team: ${calendlyLink}`
  };
}

module.exports = { bookMeeting };

// api/clearbit/company.js
const Clearbit = require('clearbit')(process.env.CLEARBIT_KEY);

async function checkCompany(domain) {
  try {
    const company = await Clearbit.Company.find({ domain });
    
    return {
      name: company.name,
      size: company.metrics?.employees || 'Unknown',
      industry: company.category?.industry || 'Unknown',
      description: company.description,
      tech: company.tech || [],
      sizeCategory: categorizeSiz(company.metrics?.employees)
    };
  } catch (error) {
    return {
      name: domain,
      size: 'Unknown',
      industry: 'Unknown',
      sizeCategory: 'Unknown'
    };
  }
}

function categorizeSize(employees) {
  if (!employees) return 'Unknown';
  if (employees < 20) return 'too_small';
  if (employees < 50) return 'small';
  if (employees < 200) return 'mid_market';
  if (employees < 1000) return 'enterprise';
  return 'large_enterprise';
}

module.exports = { checkCompany };

// webhooks/crisp.js
const express = require('express');
const { OpenClaw } = require('openclaw');

const app = express();
const openclaw = new OpenClaw();

// Crisp webhook endpoint
app.post('/webhooks/crisp', async (req, res) => {
  const { event, data } = req.body;
  
  if (event === 'message:send') {
    // Visitor sent a message
    const { website_id, session_id, content } = data;
    
    // Get or create OpenClaw session for this chat
    const session = await openclaw.getSession(`crisp:${session_id}`);
    
    // Process message through qualification agent
    const response = await session.send(content, {
      agent: 'lead-qualifier',
      metadata: {
        source: 'crisp',
        website_id,
        visitor_data: data.visitor
      }
    });
    
    // Send response back to Crisp
    await sendCrispMessage(website_id, session_id, response.message);
  }
  
  res.sendStatus(200);
});

async function sendCrispMessage(websiteId, sessionId, message) {
  await fetch(`https://api.crisp.chat/v1/website/${websiteId}/conversation/${sessionId}/message`, {
    method: 'POST',
    headers: {
      'Authorization': `Basic ${Buffer.from(CRISP_ID + ':' + CRISP_KEY).toString('base64')}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      type: 'text',
      content: message,
      from: 'operator'
    })
  });
}

// config/field-map.js
module.exports = {
  contact: {
    // HubSpot field -> Salesforce field
    'email': 'Email',
    'firstname': 'FirstName',
    'lastname': 'LastName',
    'phone': 'Phone',
    'company': 'Company',
    'jobtitle': 'Title',
    'lifecyclestage': 'Status__c', // Custom field
    'hs_lead_score': 'Lead_Score__c',
    
    // Complex mappings
    'hs_analytics_source': {
      salesforce_field: 'LeadSource',
      transform: (value) => {
        const sourceMap = {
          'ORGANIC_SEARCH': 'Web',
          'PAID_SEARCH': 'Paid Search',
          'SOCIAL_MEDIA': 'Social',
          'EMAIL_MARKETING': 'Email',
          'DIRECT_TRAFFIC': 'Direct',
          'REFERRALS': 'Referral'
        };
        return sourceMap[value] || 'Other';
      }
    }
  },
  
  deal: {
    'dealname': 'Name',
    'amount': 'Amount',
    'closedate': 'CloseDate',
    'dealstage': {
      salesforce_field: 'StageName',
      transform: (stage) => {
        const stageMap = {
          'appointmentscheduled': 'Discovery',
          'qualifiedtobuy': 'Qualification',
          'presentationscheduled': 'Demo',
          'decisionmakerboughtin': 'Proposal',
          'contractsent': 'Negotiation',
          'closedwon': 'Closed Won',
          'closedlost': 'Closed Lost'
        };
        return stageMap[stage] || 'Unknown';
      }
    }
  },
  
  company: {
    'name': 'Name',
    'domain': 'Website',
    'industry': 'Industry',
    'numberofemployees': 'NumberOfEmployees',
    'annualrevenue': 'AnnualRevenue'
  }
};

// lib/sync-engine.js
const HubSpot = require('@hubspot/api-client');
const jsforce = require('jsforce');
const fieldMap = require('../config/field-map');

class SyncEngine {
  constructor() {
    this.hubspot = new HubSpot.Client({ accessToken: process.env.HUBSPOT_TOKEN });
    this.salesforce = new jsforce.Connection({
      loginUrl: process.env.SF_LOGIN_URL,
      accessToken: process.env.SF_ACCESS_TOKEN,
      instanceUrl: process.env.SF_INSTANCE_URL
    });
    this.syncState = new SyncStateDB(); // Your state store
  }

  async syncHubSpotToSalesforce(objectType, hubspotId) {
    // Get HubSpot record
    const hsRecord = await this.getHubSpotRecord(objectType, hubspotId);
    
    // Check if already synced
    const existingSfId = await this.syncState.getSalesforceId(objectType, hubspotId);
    
    if (existingSfId) {
      // Update existing record
      return this.updateSalesforceRecord(objectType, existingSfId, hsRecord);
    } else {
      // Find or create in Salesforce
      const sfRecord = await this.findSalesforceMatch(objectType, hsRecord);
      
      if (sfRecord) {
        // Link existing and update
        await this.syncState.linkRecords(objectType, hubspotId, sfRecord.Id);
        return this.updateSalesforceRecord(objectType, sfRecord.Id, hsRecord);
      } else {
        // Create new
        return this.createSalesforceRecord(objectType, hsRecord, hubspotId);
      }
    }
  }

  async findSalesforceMatch(objectType, hsRecord) {
    // Use email for contacts, domain for companies, etc.
    if (objectType === 'contact') {
      const email = hsRecord.properties.email;
      if (!email) return null;
      
      const results = await this.salesforce.sobject('Contact')
        .find({ Email: email })
        .limit(1);
      
      return results[0] || null;
    }
    
    if (objectType === 'company') {
      const domain = hsRecord.properties.domain;
      if (!domain) return null;
      
      const results = await this.salesforce.sobject('Account')
        .find({ Website: { $like: `%${domain}%` } })
        .limit(1);
      
      return results[0] || null;
    }
    
    return null;
  }

  transformHubSpotToSalesforce(objectType, hsProperties) {
    const mapping = fieldMap[objectType];
    const sfFields = {};
    
    for (const [hsField, sfConfig] of Object.entries(mapping)) {
      const value = hsProperties[hsField];
      if (value === undefined || value === null) continue;
      
      if (typeof sfConfig === 'string') {
        // Simple mapping
        sfFields[sfConfig] = value;
      } else {
        // Complex mapping with transform
        sfFields[sfConfig.salesforce_field] = sfConfig.transform(value);
      }
    }
    
    return sfFields;
  }
}

module.exports = { SyncEngine };

// lib/conflict-resolver.js
const { Codex } = require('@openai/codex');

const codex = new Codex({ apiKey: process.env.OPENAI_API_KEY });

async function resolveConflict(hubspotRecord, salesforceRecord, fieldName) {
  const prompt = `You are a CRM data quality expert. Resolve this field conflict:

FIELD: ${fieldName}

HUBSPOT VALUE:
Value: ${hubspotRecord[fieldName]}
Last Modified: ${hubspotRecord.updatedAt}
Modified By: ${hubspotRecord.updatedBy || 'Unknown'}
Source: ${hubspotRecord.source || 'Unknown'}

SALESFORCE VALUE:
Value: ${salesforceRecord[fieldName]}
Last Modified: ${salesforceRecord.LastModifiedDate}
Modified By: ${salesforceRecord.LastModifiedById || 'Unknown'}

BUSINESS RULES:
1. More recent updates generally win
2. Human edits beat automated updates
3. Sales-owned fields (title, phone) prefer Salesforce
4. Marketing-owned fields (lead source, score) prefer HubSpot
5. Email should match—if different, flag for review

OUTPUT FORMAT:
{
  "winner": "hubspot" | "salesforce" | "review_needed",
  "reason": "brief explanation",
  "confidence": 0.0-1.0
}`;

  const response = await codex.complete({
    model: 'gpt-5.3-codex',
    prompt,
    max_tokens: 200,
    response_format: { type: 'json_object' }
  });

  return JSON.parse(response.choices[0].text);
}

async function resolveRecordConflicts(hsRecord, sfRecord, mapping) {
  const resolutions = {};
  const reviewNeeded = [];

  for (const [hsField, sfConfig] of Object.entries(mapping)) {
    const sfField = typeof sfConfig === 'string' ? sfConfig : sfConfig.salesforce_field;
    
    const hsValue = hsRecord.properties[hsField];
    const sfValue = sfRecord[sfField];
    
    // Skip if same
    if (hsValue === sfValue) {
      resolutions[hsField] = { value: hsValue, source: 'same' };
      continue;
    }
    
    // Skip if one is empty
    if (!hsValue && sfValue) {
      resolutions[hsField] = { value: sfValue, source: 'salesforce' };
      continue;
    }
    if (hsValue && !sfValue) {
      resolutions[hsField] = { value: hsValue, source: 'hubspot' };
      continue;
    }
    
    // Conflict! Let Codex decide
    const resolution = await resolveConflict(
      { [hsField]: hsValue, updatedAt: hsRecord.updatedAt },
      { [sfField]: sfValue, LastModifiedDate: sfRecord.LastModifiedDate },
      hsField
    );
    
    if (resolution.winner === 'review_needed') {
      reviewNeeded.push({
        field: hsField,
        hubspotValue: hsValue,
        salesforceValue: sfValue,
        reason: resolution.reason
      });
    } else {
      resolutions[hsField] = {
        value: resolution.winner === 'hubspot' ? hsValue : sfValue,
        source: resolution.winner,
        confidence: resolution.confidence,
        reason: resolution.reason
      };
    }
  }

  return { resolutions, reviewNeeded };
}

module.exports = { resolveConflict, resolveRecordConflicts };

// webhooks/hubspot.js
const express = require('express');
const { SyncEngine } = require('../lib/sync-engine');
const { resolveRecordConflicts } = require('../lib/conflict-resolver');

const router = express.Router();
const syncEngine = new SyncEngine();

router.post('/hubspot', async (req, res) => {
  const events = req.body;
  
  for (const event of events) {
    const { subscriptionType, objectId, propertyName, propertyValue } = event;
    
    // Handle contact updates
    if (subscriptionType === 'contact.propertyChange') {
      console.log(`📥 HubSpot contact ${objectId} updated: ${propertyName}`);
      
      try {
        await syncEngine.syncHubSpotToSalesforce('contact', objectId);
        console.log(`✅ Synced to Salesforce`);
      } catch (error) {
        console.error(`❌ Sync failed: ${error.message}`);
        // Queue for retry
        await retryQueue.add({ type: 'contact', id: objectId, source: 'hubspot' });
      }
    }
    
    // Handle deal updates
    if (subscriptionType === 'deal.propertyChange') {
      console.log(`📥 HubSpot deal ${objectId} updated: ${propertyName}`);
      await syncEngine.syncHubSpotToSalesforce('deal', objectId);
    }
  }
  
  res.sendStatus(200);
});

module.exports = router;

// webhooks/salesforce.js
const express = require('express');
const { SyncEngine } = require('../lib/sync-engine');

const router = express.Router();
const syncEngine = new SyncEngine();

// Salesforce Outbound Message handler
router.post('/salesforce', async (req, res) => {
  // Parse SOAP envelope (Salesforce uses SOAP for outbound messages)
  const notification = parseOutboundMessage(req.body);
  
  const { objectType, recordId, changedFields } = notification;
  
  console.log(`📥 Salesforce ${objectType} ${recordId} updated`);
  
  try {
    await syncEngine.syncSalesforceToHubSpot(objectType, recordId);
    console.log(`✅ Synced to HubSpot`);
  } catch (error) {
    console.error(`❌ Sync failed: ${error.message}`);
  }
  
  // Return ACK
  res.type('text/xml').send(`
    <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
      <soapenv:Body>
        <notificationsResponse xmlns="http://soap.sforce.com/2005/09/outbound">
          <Ack>true</Ack>
        </notificationsResponse>
      </soapenv:Body>
    </soapenv:Envelope>
  `);
});

module.exports = router;

// api/sync-status.js
router.get('/status', async (req, res) => {
  const stats = await db.query(`
    SELECT 
      object_type,
      COUNT(*) as total_synced,
      COUNT(CASE WHEN status = 'success' THEN 1 END) as successful,
      COUNT(CASE WHEN status = 'failed' THEN 1 END) as failed,
      COUNT(CASE WHEN status = 'pending_review' THEN 1 END) as pending_review,
      MAX(synced_at) as last_sync
    FROM sync_log
    WHERE synced_at > NOW() - INTERVAL '24 hours'
    GROUP BY object_type
  `);
  
  const conflicts = await db.query(`
    SELECT *
    FROM sync_conflicts
    WHERE resolved = false
    ORDER BY created_at DESC
    LIMIT 50
  `);
  
  res.json({
    stats,
    conflicts,
    health: conflicts.length === 0 ? 'healthy' : 'needs_attention'
  });
});