// Convert lead to deal
$lead = Lead::find(25);

$deal = Deal::create([
    'name' => $lead->company . ' - ' . $lead->position,
    'amount' => 25000,
    'currency_code' => 'USD',
    'probability' => 50,
    'expected_due_date' => now()->addDays(45),
    'lead_id' => $lead->lead_id,
    'status' => 'active',
    'business_id' => $lead->business_id,
    'created_by' => auth()->user()->id
]);

// Update lead status
$lead->update(['status_id' => 4]); // Converted status

// Log conversion activity
$deal->logActivity('converted_from_lead', [
    'lead_id' => $lead->lead_id,
    'converted_by' => auth()->user()->id
]);

// Update deal stage and probability
$deal = Deal::find(10);

$oldStage = $deal->current_stage;
$newStage = 3; // Proposal stage

$deal->update([
    'probability' => 75, // Increase probability
    'amount' => 45000 // Update deal value
]);

// Move to next stage
$deal->moveToStage($newStage);

// Log stage change
$deal->logActivity('stage_updated', [
    'old_stage' => $oldStage,
    'new_stage' => $newStage,
    'updated_by' => auth()->user()->id
]);

// Trigger stage update event
event(new DealUpdated($deal));

// Create new sales pipeline
$pipeline = Pipeline::create([
    'name' => 'SaaS Sales Process',
    'model' => 'Deal',
    'description' => 'Pipeline for SaaS product sales',
    'business_id' => auth()->user()->business_id,
    'created_by' => auth()->user()->id
]);

// Create pipeline stages
$stages = [
    ['name' => 'Demo Scheduled', 'sort' => 1],
    ['name' => 'Needs Analysis', 'sort' => 2],
    ['name' => 'Proposal Sent', 'sort' => 3],
    ['name' => 'Contract Review', 'sort' => 4],
    ['name' => 'Closed Won', 'sort' => 5]
];

foreach ($stages as $stageData) {
    $pipeline->stages()->create($stageData);
}

// Set up complex targeting criteria
$targetingCriteria = [
    'model_type' => 'Lead',
    'conditions' => [
        'status_id' => ['operator' => 'in', 'values' => [1, 2, 3]], // New, Qualified, Contacted
        'source_id' => ['operator' => 'not_in', 'values' => [5]], // Exclude cold calls
        'created_at' => [
            'operator' => 'between',
            'start' => '2025-01-01',
            'end' => '2025-07-31'
        ],
        'custom_fields' => [
            'industry' => ['operator' => 'in', 'values' => ['Technology', 'Healthcare']],
            'budget_range' => ['operator' => '>=', 'value' => 25000],
            'decision_timeline' => ['operator' => 'in', 'values' => ['Immediate', 'Within 3 months']]
        ]
    ],
    'exclude_conditions' => [
        'email_campaigns' => [
            'operator' => 'sent_within_days',
            'value' => 7 // Don't send if emailed in last 7 days
        ]
    ]
];

// Preview audience before campaign creation
$campaignService = new CampaignService();
$audiencePreview = $campaignService->previewAudience($targetingCriteria);

echo "Target Audience: {$audiencePreview['count']} leads";
echo "Segments: " . implode(', ', $audiencePreview['segments']);

// Send campaign with full tracking setup
$campaign = Campaign::find(1);

// Generate recipient list
$recipients = $campaignService->generateRecipientList($campaign);

// Send campaign
$sendResult = $campaignService->sendCampaign($campaign, [
    'send_immediately' => false,
    'scheduled_at' => $campaign->scheduled_at,
    'test_mode' => false,
    'tracking_enabled' => true,
    'personalization' => [
        'first_name' => true,
        'company' => true,
        'custom_fields' => ['industry', 'position']
    ]
]);

// Process each recipient
foreach ($recipients as $recipient) {
    // Create campaign message record
    $message = CampaignMessage::create([
        'campaign_id' => $campaign->id,
        'recipient_type' => $campaign->campaign_type,
        'recipient_id' => $recipient->id,
        'recipient_model_type' => $campaign->target_model_type,
        'recipient_email' => $recipient->email,
        'recipient_phone' => $recipient->phone,
        'subject' => $campaign->subject,
        'content' => $campaignService->personalizeContent($campaign, $recipient),
        'status' => 'pending',
        'business_id' => $campaign->business_id
    ]);
    
    // Add tracking parameters
    $trackingData = [
        'campaign_id' => $campaign->id,
        'message_id' => $message->id,
        'recipient_email' => $recipient->email,
        'tracking_pixel' => route('read-campaign-email-picture', [
            'email' => $recipient->email,
            'nid' => $message->id
        ])
    ];
    
    $message->update(['tracking_data' => $trackingData]);
}

// Update campaign status
$campaign->update([
    'status_id' => 2, // Sending
    'sent_at' => now(),
    'total_recipients' => $recipients->count()
]);

// Get comprehensive campaign analytics
$campaign = Campaign::with(['messages'])->find(1);

// Calculate performance metrics
$analytics = [
    'total_sent' => $campaign->messages()->where('status', 'sent')->count(),
    'delivery_rate' => $campaign->sent_count > 0 ? 
        ($campaign->sent_count - $campaign->failed_count) / $campaign->sent_count * 100 : 0,
    'open_rate' => $campaign->sent_count > 0 ? 
        $campaign->opened_count / $campaign->sent_count * 100 : 0,
    'click_rate' => $campaign->opened_count > 0 ? 
        $campaign->clicked_count / $campaign->opened_count * 100 : 0,
    'bounce_rate' => $campaign->sent_count > 0 ? 
        $campaign->failed_count / $campaign->sent_count * 100 : 0
];

// Get detailed message tracking
$messageTracking = CampaignMessage::where('campaign_id', $campaign->id)
    ->select('status', DB::raw('count(*) as count'))
    ->groupBy('status')
    ->pluck('count', 'status')
    ->toArray();

// Performance by time periods
$hourlyPerformance = CampaignMessage::where('campaign_id', $campaign->id)
    ->where('opened_at', '>=', $campaign->sent_at)
    ->select(
        DB::raw('HOUR(opened_at) as hour'),
        DB::raw('count(*) as opens')
    )
    ->groupBy('hour')
    ->orderBy('hour')
    ->get();

// Top performing links (if email campaign)
$linkPerformance = CampaignMessage::where('campaign_id', $campaign->id)
    ->whereNotNull('clicked_at')
    ->select('tracking_data->clicked_link as link', DB::raw('count(*) as clicks'))
    ->groupBy('link')
    ->orderByDesc('clicks')
    ->limit(10)
    ->get();

// Generate performance report
$report = [
    'campaign' => $campaign->name,
    'metrics' => $analytics,
    'message_breakdown' => $messageTracking,
    'hourly_opens' => $hourlyPerformance,
    'top_links' => $linkPerformance,
    'roi' => $campaignService->calculateROI($campaign)
];

return response()->json($report);

// Create AI agent for lead qualification
$agent = Agent::create([
    'name' => 'Lead Qualification Agent',
    'description' => 'AI agent for scoring and qualifying leads',
    'type' => 'lead_qualifier',
    'config' => [
        'model' => 'gpt-4',
        'prompt_template' => 'Analyze lead data and provide score 1-100',
        'parameters' => [
            'temperature' => 0.3,
            'max_tokens' => 150,
            'criteria' => [
                'company_size' => 20,
                'budget_range' => 25,
                'timeline' => 15,
                'decision_maker' => 25,
                'fit_score' => 15
            ]
        ],
        'output_format' => 'json',
        'validation_rules' => [
            'score' => 'required|numeric|min:0|max:100',
            'reasoning' => 'required|string|max:500'
        ]
    ],
    'status' => 'active',
    'user_id' => auth()->id(),
    'business_id' => auth()->user()->business_id,
    'is_public' => false
]);

// Test agent configuration
$result = $agent->test([
    'company' => 'Tech Startup',
    'budget' => 50000,
    'timeline' => 'Q4 2025',
    'contact_level' => 'CTO'
]);

// Execute workflow with lead data
$workflowService = new WorkflowService();

$executionResult = $workflowService->execute($workflow->id, [
    'trigger_data' => [
        'lead_id' => 123,
        'source' => 'website',
        'urgency' => 'high'
    ],
    'context' => [
        'user_id' => auth()->id(),
        'timestamp' => now(),
        'session_id' => session()->getId()
    ]
]);

// Check execution status
if ($executionResult->isSuccessful()) {
    $leadScore = $executionResult->getOutput('lead_score');
    $assignment = $executionResult->getOutput('assignment');
    
    // Log successful execution
    Log::info('Workflow executed successfully', [
        'workflow_id' => $workflow->id,
        'lead_id' => 123,
        'score' => $leadScore,
        'execution_id' => $executionResult->getId()
    ]);
} else {
    // Handle execution errors
    Log::error('Workflow execution failed', [
        'workflow_id' => $workflow->id,
        'error' => $executionResult->getError()
    ]);
}

// Get workflow execution history
$executions = WorkflowExecution::where('workflow_id', $workflow->id)
    ->with(['workflow', 'nodes'])
    ->orderBy('created_at', 'desc')
    ->paginate(20);

// Calculate performance metrics
$metrics = [
    'total_executions' => $executions->total(),
    'success_rate' => $executions->where('status', 'completed')->count() / $executions->total() * 100,
    'average_duration' => $executions->avg('execution_time'),
    'error_rate' => $executions->where('status', 'failed')->count() / $executions->total() * 100
];

// Get real-time execution status
$activeExecutions = WorkflowExecution::where('status', 'running')
    ->where('workflow_id', $workflow->id)
    ->with('currentNode')
    ->get();

// Monitor agent performance
$agentMetrics = Agent::withCount(['executions', 'successful_executions'])
    ->where('business_id', auth()->user()->business_id)
    ->get()
    ->map(function ($agent) {
        return [
            'agent_id' => $agent->id,
            'name' => $agent->name,
            'success_rate' => $agent->successful_executions_count / max($agent->executions_count, 1) * 100,
            'usage_count' => $agent->executions_count
        ];
    });

// Compose and send email
$emailData = [
    'account_id' => $emailAccount->id,
    'email' => 'recipient@example.com',
    'cc' => 'cc@example.com',
    'subject' => 'Welcome to Our Service',
    'message_text' => 'Your custom message content here',
    'signature_id' => $defaultSignature->id,
    'template_id' => $emailTemplate->id
];

// Handle file attachments
$attachments = [];
if (request()->hasFile('attachments')) {
    $attachments[] = request()->file('attachments');
}

// Send email through service
$messageService = new EmailMessageService();
$result = $messageService->sendMail($emailData, $emailAccount, $attachments);

// Track email in CRM folder
$emailMessage = EmailMessage::create([
    'account_id' => $emailAccount->id,
    'folder_name' => 'CRM',
    'subject' => $emailData['subject'],
    'sender_email' => $emailAccount->email,
    'email' => $emailData['email'],
    'message_html' => $emailData['message_text'],
    'business_id' => auth()->user()->business_id
]);

// Fetch emails from IMAP server
$emailService = new EmailAccountService($emailAccount);
$messageService = new EmailMessageService();

// Connect to email account
$emailService->connect($emailAccount);

// Get account settings
$days = $emailAccount->field('since_days')->first()->value ?? 7;
$limit = $emailAccount->field('fetch_limit')->first()->value ?? 20;

// Fetch messages from INBOX
$savedMessages = $emailService->fetchMessages('INBOX', $emailAccount, $days, $limit);

// Process each fetched message
foreach ($savedMessages as $message) {
    // Save attachments if any exist
    if ($message->hasAttachments()) {
        $attachments = $messageService->saveMessageAttachments($message, $message);
    }
    
    // Send push notification for new emails
    if ($emailAccount->user->pushSubscription()) {
        $emailAccount->user->notify(new EmailNotification($emailAccount, [$message]));
    }
}

// Create professional email signature
$signature = EmailSignature::create([
    'business_id' => auth()->user()->business_id,
    'user_id' => auth()->id(),
    'name' => 'Professional Signature',
    'content' => '
        

            
Best regards,

            ' . auth()->user()->name . '

            ' . (auth()->user()->job_title ?? '') . '

            ' . (auth()->user()->company_name ?? '') . '
            

             ' . (auth()->user()->phone ?? '') . '

             ' . auth()->user()->email . '

             ' . config('app.url') . '
            
        
    ',
    'is_default' => true,
    'is_active' => true
]);

// Use signature service to manage signatures
$signatureService = new EmailSignatureService();

// Get user's default signature
$defaultSignature = $signatureService->getUserDefaultSignature();

// Append signature to email content
$messageWithSignature = $signatureService->appendSignatureToMessage(
    $emailContent, 
    $signature->id
);