<?php
 
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
 
return new class extends Migration
{
    public function up(): void
    {
        Schema::create('conversations', function (Blueprint $table) {
            $table->id();
            $table->string('session_id')->unique();
            $table->foreignId('user_id')->nullable()->constrained()->onDelete('set null');
            $table->string('platform')->default('web'); // web, slack, discord, whatsapp
            $table->json('platform_data')->nullable(); // Platform-specific user data
            $table->enum('status', ['active', 'paused', 'closed', 'escalated'])->default('active');
            $table->json('context')->nullable(); // Conversation context
            $table->json('user_profile')->nullable(); // User preferences and history
            $table->string('language', 10)->default('en');
            $table->timestamp('last_activity_at')->nullable();
            $table->json('metadata')->nullable(); // Additional conversation data
            $table->timestamps();
            
            $table->index(['session_id']);
            $table->index(['user_id']);
            $table->index(['platform']);
            $table->index(['status']);
            $table->index(['last_activity_at']);
        });
    }
 
    public function down(): void
    {
        Schema::dropIfExists('conversations');
    }
};

<?php
 
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
 
return new class extends Migration
{
    public function up(): void
    {
        Schema::create('messages', function (Blueprint $table) {
            $table->id();
            $table->foreignId('conversation_id')->constrained()->onDelete('cascade');
            $table->enum('role', ['user', 'assistant', 'system', 'tool']);
            $table->longText('content');
            $table->json('metadata')->nullable(); // Message metadata, token counts, etc.
            $table->json('tool_calls')->nullable(); // Function/tool calls made
            $table->json('tool_results')->nullable(); // Results from tool calls
            $table->decimal('confidence_score', 3, 2)->nullable(); // AI confidence in response
            $table->json('analytics')->nullable(); // Engagement metrics
            $table->timestamp('processed_at')->nullable();
            $table->timestamps();
            
            $table->index(['conversation_id', 'created_at']);
            $table->index(['role']);
            $table->fullText(['content']);
        });
    }
 
    public function down(): void
    {
        Schema::dropIfExists('messages');
    }
};

<?php
 
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
 
return new class extends Migration
{
    public function up(): void
    {
        // Categories
        Schema::create('kb_categories', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('slug')->unique();
            $table->text('description')->nullable();
            $table->foreignId('parent_id')->nullable()->constrained('kb_categories')->onDelete('cascade');
            $table->integer('sort_order')->default(0);
            $table->boolean('is_active')->default(true);
            $table->timestamps();
            
            $table->index(['slug']);
            $table->index(['parent_id']);
        });
 
        // Articles
        Schema::create('kb_articles', function (Blueprint $table) {
            $table->id();
            $table->foreignId('category_id')->constrained()->onDelete('cascade');
            $table->string('title');
            $table->string('slug')->unique();
            $table->longText('content');
            $table->text('excerpt')->nullable();
            $table->json('keywords')->nullable(); // Search keywords
            $table->json('embeddings')->nullable(); // Vector embeddings
            $table->string('language', 10)->default('en');
            $table->enum('status', ['draft', 'published', 'archived'])->default('draft');
            $table->integer('view_count')->default(0);
            $table->decimal('helpfulness_score', 3, 2)->nullable(); // User feedback
            $table->integer('helpfulness_votes')->default(0);
            $table->timestamps();
            
            $table->index(['slug']);
            $table->index(['category_id']);
            $table->index(['status']);
            $table->index(['language']);
            $table->fullText(['title', 'content']);
        });
 
        // FAQs
        Schema::create('kb_faqs', function (Blueprint $table) {
            $table->id();
            $table->string('question');
            $table->longText('answer');
            $table->json('keywords')->nullable();
            $table->json('embeddings')->nullable();
            $table->string('language', 10)->default('en');
            $table->integer('priority')->default(0);
            $table->boolean('is_active')->default(true);
            $table->integer('hit_count')->default(0);
            $table->timestamps();
            
            $table->fullText(['question', 'answer']);
        });
    }
 
    public function down(): void
    {
        Schema::dropIfExists('kb_faqs');
        Schema::dropIfExists('kb_articles');
        Schema::dropIfExists('kb_categories');
    }
};

<?php
 
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
 
return new class extends Migration
{
    public function up(): void
    {
        // Conversation Analytics
        Schema::create('conversation_analytics', function (Blueprint $table) {
            $table->id();
            $table->foreignId('conversation_id')->constrained()->onDelete('cascade');
            $table->integer('message_count')->default(0);
            $table->integer('user_message_count')->default(0);
            $table->integer('assistant_message_count')->default(0);
            $table->decimal('avg_response_time', 8, 2)->nullable(); // in seconds
            $table->decimal('satisfaction_score', 3, 2)->nullable(); // User rating
            $table->string('resolved_by')->nullable(); // AI, Human, or Escalated
            $table->json('topics_discussed')->nullable(); // Extracted topics
            $table->json('sentiment_analysis')->nullable(); // Conversation sentiment
            $table->timestamp('first_response_at')->nullable();
            $table->timestamp('last_message_at')->nullable();
            $table->timestamp('resolved_at')->nullable();
            $table->timestamps();
        });
 
        // Platform Usage Stats
        Schema::create('platform_stats', function (Blueprint $table) {
            $table->id();
            $table->string('platform');
            $table->date('date');
            $table->integer('conversations_started')->default(0);
            $table->integer('conversations_completed')->default(0);
            $table->integer('messages_exchanged')->default(0);
            $table->integer('unique_users')->default(0);
            $table->decimal('avg_session_duration', 8, 2)->nullable();
            $table->decimal('satisfaction_score', 3, 2)->nullable();
            $table->timestamps();
            
            $table->unique(['platform', 'date']);
        });
 
        // AI Performance Metrics
        Schema::create('ai_performance_metrics', function (Blueprint $table) {
            $table->id();
            $table->date('date');
            $table->string('model_used');
            $table->integer('total_requests')->default(0);
            $table->integer('successful_responses')->default(0);
            $table->integer('failed_responses')->default(0);
            $table->decimal('avg_response_time', 8, 2)->nullable();
            $table->integer('total_tokens_used')->default(0);
            $table->decimal('total_cost', 10, 6)->default(0);
            $table->json('error_types')->nullable();
            $table->timestamps();
            
            $table->unique(['date', 'model_used']);
        });
    }
 
    public function down(): void
    {
        Schema::dropIfExists('ai_performance_metrics');
        Schema::dropIfExists('platform_stats');
        Schema::dropIfExists('conversation_analytics');
    }
};

<?php
 
namespace App\Models;
 
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Support\Str;
 
class Conversation extends Model
{
    use HasFactory;
 
    protected $fillable = [
        'session_id',
        'user_id',
        'platform',
        'platform_data',
        'status',
        'context',
        'user_profile',
        'language',
        'last_activity_at',
        'metadata',
    ];
 
    protected $casts = [
        'platform_data' => 'array',
        'context' => 'array',
        'user_profile' => 'array',
        'metadata' => 'array',
        'last_activity_at' => 'datetime',
    ];
 
    protected $dates = [
        'last_activity_at',
    ];
 
    public function user(): BelongsTo
    {
        return $this->belongsTo(User::class);
    }
 
    public function messages(): HasMany
    {
        return $this->hasMany(Message::class)->orderBy('created_at');
    }
 
    public function analytics(): HasMany
    {
        return $this->hasMany(ConversationAnalytic::class);
    }
 
    public function latestAnalytics(): BelongsTo
    {
        return $this->belongsTo(ConversationAnalytic::class, 'id', 'conversation_id')
                    ->latest('created_at');
    }
 
    public function scopeActive($query)
    {
        return $query->where('status', 'active');
    }
 
    public function scopeByPlatform($query, string $platform)
    {
        return $query->where('platform', $platform);
    }
 
    public function getMessagesSummary(): array
    {
        $totalMessages = $this->messages()->count();
        $userMessages = $this->messages()->where('role', 'user')->count();
        $assistantMessages = $this->messages()->where('role', 'assistant')->count();
 
        return [
            'total' => $totalMessages,
            'user' => $userMessages,
            'assistant' => $assistantMessages,
            'system' => $totalMessages - $userMessages - $assistantMessages,
        ];
    }
 
    public function updateLastActivity(): void
    {
        $this->update(['last_activity_at' => now()]);
    }
 
    public function getContext(string $key, mixed $default = null): mixed
    {
        return data_get($this->context, $key, $default);
    }
 
    public function setContext(string $key, mixed $value): void
    {
        $context = $this->context ?? [];
        data_set($context, $key, $value);
        $this->update(['context' => $context]);
    }
 
    public function getUserProfile(string $key, mixed $default = null): mixed
    {
        return data_get($this->user_profile, $key, $default);
    }
 
    public function setUserProfile(string $key, mixed $value): void
    {
        $profile = $this->user_profile ?? [];
        data_set($profile, $key, $value);
        $this->update(['user_profile' => $profile]);
    }
 
    public function escalate(string $reason = ''): void
    {
        $this->update([
            'status' => 'escalated',
            'metadata' => array_merge($this->metadata ?? [], [
                'escalated_at' => now()->toISOString(),
                'escalation_reason' => $reason,
            ]),
        ]);
 
        // Notify human agents
        event(new ConversationEscalated($this, $reason));
    }
 
    public function close(): void
    {
        $this->update(['status' => 'closed']);
        
        // Generate analytics
        $this->generateAnalytics();
    }
 
    protected function generateAnalytics(): void
    {
        $messages = $this->messages;
        $firstMessage = $messages->first();
        $lastMessage = $messages->last();
 
        ConversationAnalytic::create([
            'conversation_id' => $this->id,
            'message_count' => $messages->count(),
            'user_message_count' => $messages->where('role', 'user')->count(),
            'assistant_message_count' => $messages->where('role', 'assistant')->count(),
            'avg_response_time' => $this->calculateAvgResponseTime($messages),
            'first_response_at' => $firstMessage?->created_at,
            'last_message_at' => $lastMessage?->created_at,
            'resolved_at' => now(),
        ]);
    }
 
    protected function calculateAvgResponseTime($messages): float
    {
        $responseTimes = [];
        
        for ($i = 0; $i < $messages->count() - 1; $i++) {
            $current = $messages[$i];
            $next = $messages[$i + 1];
            
            if ($current->role === 'user' && $next->role === 'assistant') {
                $responseTimes[] = $current->created_at->diffInSeconds($next->created_at);
            }
        }
        
        return count($responseTimes) > 0 ? array_sum($responseTimes) / count($responseTimes) : 0;
    }
}

<?php
 
namespace App\Models;
 
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Factories\HasFactory;
 
class Message extends Model
{
    use HasFactory;
 
    protected $fillable = [
        'conversation_id',
        'role',
        'content',
        'metadata',
        'tool_calls',
        'tool_results',
        'confidence_score',
        'analytics',
        'processed_at',
    ];
 
    protected $casts = [
        'metadata' => 'array',
        'tool_calls' => 'array',
        'tool_results' => 'array',
        'analytics' => 'array',
        'processed_at' => 'datetime',
        'confidence_score' => 'decimal:2',
    ];
 
    protected $dates = [
        'processed_at',
    ];
 
    public function conversation(): BelongsTo
    {
        return $this->belongsTo(Conversation::class);
    }
 
    public function isUserMessage(): bool
    {
        return $this->role === 'user';
    }
 
    public function isAssistantMessage(): bool
    {
        return $this->role === 'assistant';
    }
 
    public function isSystemMessage(): bool
    {
        return $this->role === 'system';
    }
 
    public function isToolMessage(): bool
    {
        return $this->role === 'tool';
    }
 
    public function getTokenCount(): int
    {
        return $this->metadata['token_count'] ?? 0;
    }
 
    public function getProcessingTime(): float
    {
        return $this->metadata['processing_time'] ?? 0;
    }
 
    public function markAsProcessed(): void
    {
        $this->update(['processed_at' => now()]);
    }
 
    public function addAnalytics(string $key, mixed $value): void
    {
        $analytics = $this->analytics ?? [];
        data_set($analytics, $key, $value);
        $this->update(['analytics' => $analytics]);
    }
 
    public static function boot()
    {
        parent::boot();
 
        static::created(function ($message) {
            // Update conversation's last activity
            $message->conversation->updateLastActivity();
            
            // Trigger message processing if it's a user message
            if ($message->isUserMessage()) {
                ProcessMessageJob::dispatch($message);
            }
        });
    }
}

<?php
 
namespace App\Services\AI;
 
use App\Models\Conversation;
use App\Models\Message;
use App\Models\KbArticle;
use App\Models\KbFaq;
use App\Jobs\ProcessMessageJob;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Str;
 
class ChatbotService
{
    private string $apiKey;
    private string $model;
    private array $defaultOptions;
 
    public function __construct()
    {
        $this->apiKey = config('services.openai.api_key');
        $this->model = config('chatbot.default_model', 'gpt-4');
        $this->defaultOptions = [
            'model' => $this->model,
            'temperature' => 0.7,
            'max_tokens' => 1000,
            'top_p' => 1,
            'frequency_penalty' => 0,
            'presence_penalty' => 0,
        ];
    }
 
    public function processMessage(Message $message): string
    {
        $conversation = $message->conversation;
        
        // Build conversation context
        $context = $this->buildContext($conversation);
        
        // Retrieve relevant knowledge base content
        $knowledgeContext = $this->retrieveKnowledgeBase($message->content, $conversation->language);
        
        // Generate system message
        $systemMessage = $this->buildSystemMessage($conversation, $knowledgeContext);
        
        // Prepare messages for API
        $apiMessages = [
            ['role' => 'system', 'content' => $systemMessage],
            ...$context,
            ['role' => 'user', 'content' => $message->content],
        ];
 
        // Make API call
        $response = $this->callOpenAI($apiMessages);
        
        // Store response metrics
        $this->storeMessageMetrics($message, $response);
        
        return $response['content'];
    }
 
    protected function buildContext(Conversation $conversation): array
    {
        $messages = $conversation->messages()
            ->where('role', '!=', 'system')
            ->orderBy('created_at')
            ->take(20) // Keep last 20 messages for context
            ->get();
 
        return $messages->map(function ($message) {
            return [
                'role' => $message->role,
                'content' => $message->content,
            ];
        })->toArray();
    }
 
    protected function retrieveKnowledgeBase(string $query, string $language = 'en'): array
    {
        // Generate query embedding
        $queryEmbedding = $this->generateEmbedding($query);
        
        if (!$queryEmbedding) {
            return [];
        }
 
        // Search for relevant articles
        $relevantArticles = $this->searchKnowledgeBase($queryEmbedding, $language, 3);
        
        // Search for relevant FAQs
        $relevantFaqs = $this->searchFaqs($queryEmbedding, $language, 2);
 
        return [
            'articles' => $relevantArticles,
            'faqs' => $relevantFaqs,
        ];
    }
 
    protected function searchKnowledgeBase(array $embedding, string $language, int $limit): array
    {
        $articles = KbArticle::where('language', $language)
            ->where('status', 'published')
            ->whereNotNull('embeddings')
            ->get();
 
        $similarities = $articles->map(function ($article) use ($embedding) {
            $similarity = $this->cosineSimilarity($embedding, $article->embeddings);
            return [
                'article' => $article,
                'similarity' => $similarity,
            ];
        })->sortByDesc('similarity')->take($limit);
 
        return $similarities->filter(function ($item) {
            return $item['similarity'] > 0.7; // Similarity threshold
        })->map(function ($item) {
            return [
                'title' => $item['article']->title,
                'content' => Str::limit($item['article']->content, 500),
                'url' => route('kb.article', $item['article']->slug),
                'similarity' => $item['similarity'],
            ];
        })->toArray();
    }
 
    protected function searchFaqs(array $embedding, string $language, int $limit): array
    {
        $faqs = KbFaq::where('language', $language)
            ->where('is_active', true)
            ->whereNotNull('embeddings')
            ->get();
 
        $similarities = $faqs->map(function ($faq) use ($embedding) {
            $similarity = $this->cosineSimilarity($embedding, $faq->embeddings);
            return [
                'faq' => $faq,
                'similarity' => $similarity,
            ];
        })->sortByDesc('similarity')->take($limit);
 
        return $similarities->filter(function ($item) {
            return $item['similarity'] > 0.8; // Higher threshold for FAQs
        })->map(function ($item) {
            return [
                'question' => $item['faq']->question,
                'answer' => $item['faq']->answer,
                'similarity' => $item['similarity'],
            ];
        })->toArray();
    }
 
    protected function buildSystemMessage(Conversation $conversation, array $knowledgeContext): string
    {
        $basePrompt = $this->getBasePrompt($conversation->language);
        
        $contextInfo = $this->formatKnowledgeContext($knowledgeContext);
        
        $userProfile = $conversation->user_profile ?? [];
        $personalization = $this->buildPersonalization($userProfile);
        
        return "{$basePrompt}\n\n{$personalization}\n\n{$contextInfo}";
    }
 
    protected function getBasePrompt(string $language): string
    {
        $prompts = [
            'en' => "You are an intelligent and helpful AI assistant. Provide accurate, concise, and friendly responses. Use the provided knowledge base information when relevant. If you don't know something, admit it honestly. Always maintain a professional and supportive tone.",
            
            'es' => "Eres un asistente de IA inteligente y servicial. Proporciona respuestas precisas, concisas y amigables. Utiliza la información de la base de conocimientos cuando sea relevante. Si no sabes algo, admítelo honestamente. Mantén siempre un tono profesional y de apoyo.",
            
            'fr' => "Vous êtes un assistant IA intelligent et utile. Fournissez des réponses précises, concises et amicales. Utilisez les informations de la base de connaissances lorsque cela est pertinent. Si vous ne savez pas quelque chose, admettez-le honnêtement. Maintenez toujours un ton professionnel et de soutien.",
        ];
 
        return $prompts[$language] ?? $prompts['en'];
    }
 
    protected function formatKnowledgeContext(array $knowledgeContext): string
    {
        $context = "Relevant Information:\n\n";
        
        if (!empty($knowledgeContext['articles'])) {
            $context .= "Articles:\n";
            foreach ($knowledgeContext['articles'] as $article) {
                $context .= "- {$article['title']}: {$article['content']}\n";
            }
            $context .= "\n";
        }
        
        if (!empty($knowledgeContext['faqs'])) {
            $context .= "FAQs:\n";
            foreach ($knowledgeContext['faqs'] as $faq) {
                $context .= "Q: {$faq['question']}\nA: {$faq['answer']}\n\n";
            }
        }
        
        return $context;
    }
 
    protected function buildPersonalization(array $userProfile): string
    {
        $personalization = '';
        
        if (isset($userProfile['name'])) {
            $personalization .= "The user's name is {$userProfile['name']}. ";
        }
        
        if (isset($userProfile['preferences'])) {
            $prefs = $userProfile['preferences'];
            if (isset($prefs['communication_style'])) {
                $personalization .= "The user prefers a {$prefs['communication_style']} communication style. ";
            }
            if (isset($prefs['technical_level'])) {
                $personalization .= "The user's technical level is: {$prefs['technical_level']}. ";
            }
        }
        
        if (isset($userProfile['previous_topics'])) {
            $topics = implode(', ', array_slice($userProfile['previous_topics'], -5));
            $personalization .= "Previously discussed topics: {$topics}. ";
        }
        
        return $personalization;
    }
 
    protected function callOpenAI(array $messages): array
    {
        $startTime = microtime(true);
        
        try {
            $response = Http::withHeaders([
                'Authorization' => 'Bearer ' . $this->apiKey,
                'Content-Type' => 'application/json',
            ])->post('https://api.openai.com/v1/chat/completions', [
                'model' => $this->defaultOptions['model'],
                'messages' => $messages,
                'temperature' => $this->defaultOptions['temperature'],
                'max_tokens' => $this->defaultOptions['max_tokens'],
                'top_p' => $this->defaultOptions['top_p'],
                'frequency_penalty' => $this->defaultOptions['frequency_penalty'],
                'presence_penalty' => $this->defaultOptions['presence_penalty'],
            ]);
 
            if (!$response->successful()) {
                throw new \Exception("OpenAI API Error: {$response->body()}");
            }
 
            $data = $response->json();
            $processingTime = microtime(true) - $startTime;
 
            return [
                'content' => $data['choices'][0]['message']['content'],
                'usage' => $data['usage'],
                'processing_time' => $processingTime,
                'model' => $data['model'],
            ];
 
        } catch (\Exception $e) {
            Log::error('OpenAI API call failed', [
                'error' => $e->getMessage(),
                'messages' => $messages,
            ]);
            
            throw $e;
        }
    }
 
    protected function generateEmbedding(string $text): ?array
    {
        try {
            $response = Http::withHeaders([
                'Authorization' => 'Bearer ' . $this->apiKey,
                'Content-Type' => 'application/json',
            ])->post('https://api.openai.com/v1/embeddings', [
                'model' => 'text-embedding-ada-002',
                'input' => $text,
            ]);
 
            if (!$response->successful()) {
                throw new \Exception("Embedding generation failed: {$response->body()}");
            }
 
            $data = $response->json();
            return $data['data'][0]['embedding'];
 
        } catch (\Exception $e) {
            Log::error('Embedding generation failed', [
                'error' => $e->getMessage(),
                'text' => Str::limit($text, 100),
            ]);
            
            return null;
        }
    }
 
    protected function cosineSimilarity(array $vectorA, array $vectorB): float
    {
        $dotProduct = 0;
        $magnitudeA = 0;
        $magnitudeB = 0;
 
        for ($i = 0; $i < count($vectorA); $i++) {
            $dotProduct += $vectorA[$i] * $vectorB[$i];
            $magnitudeA += $vectorA[$i] ** 2;
            $magnitudeB += $vectorB[$i] ** 2;
        }
 
        $magnitudeA = sqrt($magnitudeA);
        $magnitudeB = sqrt($magnitudeB);
 
        if ($magnitudeA == 0 || $magnitudeB == 0) {
            return 0;
        }
 
        return $dotProduct / ($magnitudeA * $magnitudeB);
    }
 
    protected function storeMessageMetrics(Message $message, array $response): void
    {
        $metadata = [
            'token_count' => $response['usage']['total_tokens'] ?? 0,
            'prompt_tokens' => $response['usage']['prompt_tokens'] ?? 0,
            'completion_tokens' => $response['usage']['completion_tokens'] ?? 0,
            'processing_time' => $response['processing_time'],
            'model' => $response['model'],
        ];
 
        $message->update(['metadata' => $metadata]);
 
        // Store performance metrics
        $this->storePerformanceMetrics($response);
    }
 
    protected function storePerformanceMetrics(array $response): void
    {
        $today = now()->toDateString();
        $model = $response['model'];
 
        Cache::lock("ai_metrics_{$today}_{$model}", 10)->block(5, function () use ($today, $model, $response) {
            $metrics = \App\Models\AiPerformanceMetric::firstOrCreate(
                ['date' => $today, 'model_used' => $model],
                [
                    'total_requests' => 0,
                    'successful_responses' => 0,
                    'failed_responses' => 0,
                    'total_tokens_used' => 0,
                    'total_cost' => 0,
                ]
            );
 
            $metrics->increment('total_requests');
            $metrics->increment('successful_responses');
            $metrics->increment('total_tokens_used', $response['usage']['total_tokens'] ?? 0);
            
            // Calculate cost (approximate)
            $cost = $this->calculateCost($response['usage'], $model);
            $metrics->increment('total_cost', $cost);
            
            // Update average response time
            $newAvgTime = (($metrics->avg_response_time * ($metrics->total_requests - 1)) + $response['processing_time']) / $metrics->total_requests;
            $metrics->avg_response_time = $newAvgTime;
            
            $metrics->save();
        });
    }
 
    protected function calculateCost(array $usage, string $model): float
    {
        // Approximate pricing (adjust based on actual OpenAI pricing)
        $pricing = [
            'gpt-4' => ['prompt' => 0.03, 'completion' => 0.06],
            'gpt-4-32k' => ['prompt' => 0.06, 'completion' => 0.12],
            'gpt-3.5-turbo' => ['prompt' => 0.0015, 'completion' => 0.002],
        ];
 
        $modelPricing = $pricing[$model] ?? $pricing['gpt-3.5-turbo'];
        
        $promptCost = ($usage['prompt_tokens'] / 1000) * $modelPricing['prompt'];
        $completionCost = ($usage['completion_tokens'] / 1000) * $modelPricing['completion'];
        
        return $promptCost + $completionCost;
    }
 
    public function detectIntent(string $message): array
    {
        $prompt = "Analyze the following user message and detect the primary intent. Respond with a JSON object containing:
{
  \"intent\": \"main_intent\",
  \"confidence\": 0.95,
  \"entities\": [
    {\"type\": \"entity_type\", \"value\": \"entity_value\"}
  ],
  \"sentiment\": \"positive|negative|neutral\"
}
 
Common intents: greeting, question, complaint, request_help, feedback, small_talk, technical_support, billing_inquiry
 
Message: {$message}";
 
        try {
            $response = Http::withHeaders([
                'Authorization' => 'Bearer ' . $this->apiKey,
                'Content-Type' => 'application/json',
            ])->post('https://api.openai.com/v1/chat/completions', [
                'model' => 'gpt-3.5-turbo',
                'messages' => [
                    ['role' => 'system', 'content' => 'You are an intent detection expert. Always respond with valid JSON.'],
                    ['role' => 'user', 'content' => $prompt],
                ],
                'temperature' => 0.1,
                'max_tokens' => 200,
            ]);
 
            if ($response->successful()) {
                $content = $response->json()['choices'][0]['message']['content'];
                return json_decode($content, true) ?? [];
            }
        } catch (\Exception $e) {
            Log::error('Intent detection failed', ['error' => $e->getMessage()]);
        }
 
        return [
            'intent' => 'unknown',
            'confidence' => 0.5,
            'entities' => [],
            'sentiment' => 'neutral',
        ];
    }
}

<?php
 
namespace App\Services\Platform;
 
use App\Models\Conversation;
use App\Models\Message;
use App\Services\Platform\Platforms\WebPlatform;
use App\Services\Platform\Platforms\SlackPlatform;
use App\Services\Platform\Platforms\DiscordPlatform;
use App\Services\Platform\Platforms\WhatsAppPlatform;
 
class PlatformManager
{
    protected array $platforms = [];
 
    public function __construct()
    {
        $this->platforms = [
            'web' => new WebPlatform(),
            'slack' => new SlackPlatform(),
            'discord' => new DiscordPlatform(),
            'whatsapp' => new WhatsAppPlatform(),
        ];
    }
 
    public function getPlatform(string $platform): ?PlatformInterface
    {
        return $this->platforms[$platform] ?? null;
    }
 
    public function sendMessage(Conversation $conversation, string $content, array $options = []): bool
    {
        $platform = $this->getPlatform($conversation->platform);
        
        if (!$platform) {
            Log::error("Unknown platform: {$conversation->platform}");
            return false;
        }
 
        try {
            // Create message in database
            $message = Message::create([
                'conversation_id' => $conversation->id,
                'role' => 'assistant',
                'content' => $content,
                'metadata' => $options,
            ]);
 
            // Send message through platform
            $success = $platform->sendMessage($conversation, $content, $options);
 
            if ($success) {
                $message->markAsProcessed();
            }
 
            return $success;
 
        } catch (\Exception $e) {
            Log::error("Failed to send message via {$conversation->platform}", [
                'error' => $e->getMessage(),
                'conversation_id' => $conversation->id,
            ]);
            
            return false;
        }
    }
 
    public function handleIncomingMessage(string $platform, array $data): ?Conversation
    {
        $platformService = $this->getPlatform($platform);
        
        if (!$platformService) {
            Log::error("Unknown platform: {$platform}");
            return null;
        }
 
        try {
            // Validate and process incoming message
            $messageData = $platformService->validateIncomingMessage($data);
            
            // Find or create conversation
            $conversation = $this->findOrCreateConversation($platform, $messageData);
            
            // Create message
            Message::create([
                'conversation_id' => $conversation->id,
                'role' => 'user',
                'content' => $messageData['content'],
                'metadata' => $messageData['metadata'] ?? [],
            ]);
 
            return $conversation;
 
        } catch (\Exception $e) {
            Log::error("Failed to handle incoming message from {$platform}", [
                'error' => $e->getMessage(),
                'data' => $data,
            ]);
            
            return null;
        }
    }
 
    protected function findOrCreateConversation(string $platform, array $messageData): Conversation
    {
        // Try to find existing conversation
        $conversation = Conversation::where('platform', $platform)
            ->where('session_id', $messageData['session_id'])
            ->active()
            ->first();
 
        if ($conversation) {
            $conversation->updateLastActivity();
            return $conversation;
        }
 
        // Create new conversation
        return Conversation::create([
            'session_id' => $messageData['session_id'],
            'user_id' => $messageData['user_id'] ?? null,
            'platform' => $platform,
            'platform_data' => $messageData['platform_data'] ?? [],
            'language' => $messageData['language'] ?? 'en',
            'status' => 'active',
        ]);
    }
 
    public function getPlatformUser(string $platform, string $userId): ?array
    {
        $platformService = $this->getPlatform($platform);
        
        if (!$platformService) {
            return null;
        }
 
        return $platformService->getUserInfo($userId);
    }
 
    public function isTyping(Conversation $conversation, bool $isTyping): void
    {
        $platform = $this->getPlatform($conversation->platform);
        
        if ($platform && method_exists($platform, 'sendTypingIndicator')) {
            $platform->sendTypingIndicator($conversation, $isTyping);
        }
    }
}

<?php
 
namespace App\Services\Platform\Platforms;
 
use App\Models\Conversation;
use App\Services\Platform\PlatformInterface;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Log;
 
class SlackPlatform implements PlatformInterface
{
    private string $botToken;
    private string $signingSecret;
 
    public function __construct()
    {
        $this->botToken = config('services.slack.bot_token');
        $this->signingSecret = config('services.slack.signing_secret');
    }
 
    public function sendMessage(Conversation $conversation, string $content, array $options = []): bool
    {
        $channel = $conversation->getContext('slack_channel');
        
        if (!$channel) {
            Log::error('No Slack channel found for conversation', [
                'conversation_id' => $conversation->id,
            ]);
            return false;
        }
 
        try {
            $response = Http::withHeaders([
                'Authorization' => 'Bearer ' . $this->botToken,
                'Content-Type' => 'application/json',
            ])->post('https://slack.com/api/chat.postMessage', [
                'channel' => $channel,
                'text' => $content,
                'blocks' => $options['blocks'] ?? null,
                'thread_ts' => $conversation->getContext('slack_thread_ts'),
            ]);
 
            return $response->json()['ok'] ?? false;
 
        } catch (\Exception $e) {
            Log::error('Failed to send Slack message', [
                'error' => $e->getMessage(),
                'conversation_id' => $conversation->id,
            ]);
            
            return false;
        }
    }
 
    public function validateIncomingMessage(array $data): array
    {
        // Verify Slack signature
        if (!$this->verifySignature($data)) {
            throw new \Exception('Invalid Slack signature');
        }
 
        // Handle different event types
        if ($data['type'] === 'url_verification') {
            return [
                'type' => 'verification',
                'challenge' => $data['challenge'],
            ];
        }
 
        if ($data['type'] === 'event_callback') {
            $event = $data['event'];
            
            if ($event['type'] === 'message' && !isset($event['bot_id'])) {
                return [
                    'type' => 'message',
                    'session_id' => $event['channel'],
                    'content' => $event['text'],
                    'user_id' => $event['user'],
                    'platform_data' => [
                        'channel' => $event['channel'],
                        'thread_ts' => $event['thread_ts'] ?? null,
                        'user' => $event['user'],
                    ],
                    'metadata' => [
                        'slack_event_type' => $event['type'],
                        'timestamp' => $event['ts'],
                    ],
                ];
            }
        }
 
        throw new \Exception('Unsupported event type');
    }
 
    public function getUserInfo(string $userId): ?array
    {
        try {
            $response = Http::withHeaders([
                'Authorization' => 'Bearer ' . $this->botToken,
            ])->get("https://slack.com/api/users.info", [
                'user' => $userId,
            ]);
 
            if ($response->json()['ok']) {
                $user = $response->json()['user'];
                
                return [
                    'id' => $user['id'],
                    'name' => $user['name'],
                    'display_name' => $user['profile']['display_name'],
                    'email' => $user['profile']['email'] ?? null,
                    'avatar' => $user['profile']['image_72'],
                ];
            }
        } catch (\Exception $e) {
            Log::error('Failed to fetch Slack user info', [
                'error' => $e->getMessage(),
                'user_id' => $userId,
            ]);
        }
 
        return null;
    }
 
    public function sendTypingIndicator(Conversation $conversation, bool $isTyping): void
    {
        // Slack doesn't have a specific typing indicator API
        // We can send a temporary message instead
        if ($isTyping) {
            $this->sendMessage($conversation, '_Typing..._', [
                'blocks' => [
                    [
                        'type' => 'context',
                        'elements' => [
                            [
                                'type' => 'image',
                                'image_url' => 'https://slack.com/img/typing-indicator.gif',
                                'alt_text' => 'Bot is typing...',
                            ],
                        ],
                    ],
                ],
            ]);
        }
    }
 
    protected function verifySignature(array $data): bool
    {
        if (!isset($data['headers']['X-Slack-Signature']) || 
            !isset($data['headers']['X-Slack-Request-Timestamp'])) {
            return false;
        }
 
        $signature = $data['headers']['X-Slack-Signature'];
        $timestamp = $data['headers']['X-Slack-Request-Timestamp'];
        
        // Check if timestamp is recent (within 5 minutes)
        if (abs(time() - $timestamp) > 300) {
            return false;
        }
 
        $baseString = "v0:{$timestamp}:" . json_encode($data['body']);
        $expectedSignature = 'v0=' . hash_hmac('sha256', $baseString, $this->signingSecret);
 
        return hash_equals($expectedSignature, $signature);
    }
}

<?php
 
namespace App\Services\Analytics;
 
use App\Models\Conversation;
use App\Models\Message;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Log;
 
class SentimentAnalysisService
{
    private string $apiKey;
 
    public function __construct()
    {
        $this->apiKey = config('services.openai.api_key');
    }
 
    public function analyzeMessage(Message $message): array
    {
        try {
            $response = Http::withHeaders([
                'Authorization' => 'Bearer ' . $this->apiKey,
                'Content-Type' => 'application/json',
            ])->post('https://api.openai.com/v1/chat/completions', [
                'model' => 'gpt-3.5-turbo',
                'messages' => [
                    [
                        'role' => 'system',
                        'content' => 'Analyze the sentiment of the following message. Respond with a JSON object containing:
{
  "sentiment": "positive|negative|neutral",
  "confidence": 0.95,
  "emotions": ["joy", "anger", "sadness", "fear", "surprise"],
  "urgency": "low|medium|high"
}',
                    ],
                    [
                        'role' => 'user',
                        'content' => $message->content,
                    ],
                ],
                'temperature' => 0.1,
                'max_tokens' => 100,
            ]);
 
            if ($response->successful()) {
                $content = $response->json()['choices'][0]['message']['content'];
                $analysis = json_decode($content, true);
                
                if ($analysis) {
                    $message->addAnalytics('sentiment', $analysis);
                    return $analysis;
                }
            }
        } catch (\Exception $e) {
            Log::error('Sentiment analysis failed', [
                'error' => $e->getMessage(),
                'message_id' => $message->id,
            ]);
        }
 
        return [
            'sentiment' => 'neutral',
            'confidence' => 0.5,
            'emotions' => [],
            'urgency' => 'low',
        ];
    }
 
    public function analyzeConversation(Conversation $conversation): array
    {
        $messages = $conversation->messages()->where('role', 'user')->get();
        
        if ($messages->isEmpty()) {
            return [
                'overall_sentiment' => 'neutral',
                'sentiment_trend' => [],
                'emotional_summary' => [],
                'urgency_level' => 'low',
            ];
        }
 
        $sentiments = [];
        $emotions = [];
        $urgencies = [];
 
        foreach ($messages as $message) {
            $analysis = $this->analyzeMessage($message);
            $sentiments[] = $analysis['sentiment'];
            $emotions = array_merge($emotions, $analysis['emotions'] ?? []);
            $urgencies[] = $analysis['urgency'] ?? 'low';
        }
 
        // Calculate overall sentiment
        $sentimentCounts = array_count_values($sentiments);
        $overallSentiment = array_keys($sentimentCounts, max($sentimentCounts))[0];
 
        // Calculate emotion frequency
        $emotionCounts = array_count_values($emotions);
        arsort($emotionCounts);
        $emotionalSummary = array_slice($emotionCounts, 0, 5, true);
 
        // Determine urgency level
        $urgencyCounts = array_count_values($urgencies);
        $urgencyLevel = array_keys($urgencyCounts, max($urgencyCounts))[0];
 
        return [
            'overall_sentiment' => $overallSentiment,
            'sentiment_trend' => $sentiments,
            'emotional_summary' => $emotionalSummary,
            'urgency_level' => $urgencyLevel,
        ];
    }
 
    public function detectEscalationTriggers(Conversation $conversation): array
    {
        $recentMessages = $conversation->messages()
            ->where('role', 'user')
            ->where('created_at', '>', now()->subMinutes(30))
            ->get();
 
        $triggers = [];
        $angerCount = 0;
        $urgencyCount = 0;
        $complaintKeywords = ['frustrated', 'angry', 'terrible', 'worst', 'unacceptable', 'disappointed'];
 
        foreach ($recentMessages as $message) {
            $analysis = $this->analyzeMessage($message);
            
            if ($analysis['sentiment'] === 'negative') {
                $angerCount++;
            }
            
            if ($analysis['urgency'] === 'high') {
                $urgencyCount++;
            }
 
            // Check for complaint keywords
            $content = strtolower($message->content);
            foreach ($complaintKeywords as $keyword) {
                if (strpos($content, $keyword) !== false) {
                    $triggers[] = "Complaint keyword detected: {$keyword}";
                }
            }
        }
 
        if ($angerCount >= 2) {
            $triggers[] = 'Multiple negative messages detected';
        }
 
        if ($urgencyCount >= 2) {
            $triggers[] = 'High urgency in recent messages';
        }
 
        return $triggers;
    }
}