Player Limit Sistemi - Kod Planı

<?php

namespace Modules\Muzibu\App\Services;

use App\Models\User;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Str;
use Jenssegers\Agent\Agent;

/**
 * PlaybackSessionService - Concurrent Playback Limit Sistemi
 *
 * Spotify modeli: Sınırsız giriş, sınırlı playback
 * Device limit yerine aktif stream limiti uygular
 */
class PlaybackSessionService
{
    protected string $table = 'active_playback_sessions';
    protected int $pingTimeout = 30; // seconds - 3 ping kaçırırsa expired

    /**
     * Servis çalışmalı mı?
     */
    public function shouldRun(): bool
    {
        return tenant() !== null;
    }

    /**
     * Yeni playback session başlat
     * Play butonuna basıldığında çağrılır
     */
    public function registerPlaybackSession(
        User $user,
        string $playbackId,
        ?int $songId = null
    ): array {
        if (!$this->shouldRun()) {
            return ['success' => true, 'playback_id' => $playbackId];
        }

        // 1. Expired session'ları temizle
        $this->cleanupExpiredSessions();

        // 2. Aktif playback sayısını kontrol et
        $activeCount = $this->getActivePlaybackCount($user);
        $limit = $this->getConcurrentStreamLimit($user);

        // 3. Bu playback_id zaten kayıtlı mı? (refresh/reconnect durumu)
        $existingSession = DB::table($this->table)
            ->where('playback_id', $playbackId)
            ->where('user_id', $user->id)
            ->first();

        if ($existingSession) {
            // Mevcut session'ı güncelle
            DB::table($this->table)
                ->where('playback_id', $playbackId)
                ->update([
                    'current_song_id' => $songId,
                    'last_ping' => now(),
                    'updated_at' => now(),
                ]);

            return [
                'success' => true,
                'playback_id' => $playbackId,
                'resumed' => true,
            ];
        }

        // 4. Limit kontrolü (yeni session için)
        if ($activeCount >= $limit) {
            return [
                'success' => false,
                'error' => 'max_streams_exceeded',
                'message' => "Bu abonelik zaten {$activeCount} yerde çalıyor. Limit: {$limit}",
                'active_count' => $activeCount,
                'limit' => $limit,
                'active_sessions' => $this->getActiveSessions($user),
            ];
        }

        // 5. Yeni playback session kaydet
        $agent = new Agent();

        DB::table($this->table)->insert([
            'user_id' => $user->id,
            'playback_id' => $playbackId,
            'session_id' => session()->getId(),
            'current_song_id' => $songId,
            'device_name' => $agent->platform() . ' - ' . $agent->browser(),
            'device_type' => $this->getDeviceType($agent),
            'ip_address' => request()->ip(),
            'user_agent' => request()->userAgent(),
            'last_ping' => now(),
            'created_at' => now(),
            'updated_at' => now(),
        ]);

        \Log::info('🎵 Playback session started', [
            'user_id' => $user->id,
            'playback_id' => $playbackId,
            'song_id' => $songId,
        ]);

        return [
            'success' => true,
            'playback_id' => $playbackId,
            'active_count' => $activeCount + 1,
            'limit' => $limit,
        ];
    }

    /**
     * Playback heartbeat (10 saniyede bir)
     */
    public function pingPlaybackSession(
        User $user,
        string $playbackId,
        ?int $songId = null
    ): array {
        if (!$this->shouldRun()) {
            return ['success' => true];
        }

        $updated = DB::table($this->table)
            ->where('playback_id', $playbackId)
            ->where('user_id', $user->id)
            ->update([
                'last_ping' => now(),
                'current_song_id' => $songId,
                'updated_at' => now(),
            ]);

        if ($updated === 0) {
            // Session bulunamadı - muhtemelen timeout oldu veya silinmiş
            return [
                'success' => false,
                'error' => 'session_not_found',
                'message' => 'Playback session bulunamadı. Başka bir yerden durdurulmuş olabilir.',
            ];
        }

        return ['success' => true];
    }

    /**
     * Playback session sonlandır (pause/stop)
     */
    public function stopPlaybackSession(User $user, string $playbackId): bool
    {
        if (!$this->shouldRun()) {
            return true;
        }

        $deleted = DB::table($this->table)
            ->where('playback_id', $playbackId)
            ->where('user_id', $user->id)
            ->delete();

        if ($deleted > 0) {
            \Log::info('🎵 Playback session stopped', [
                'user_id' => $user->id,
                'playback_id' => $playbackId,
            ]);
        }

        return $deleted > 0;
    }

    /**
     * Belirli bir session'ı zorla durdur (admin veya kullanıcı isteği)
     */
    public function forceStopSession(User $user, string $playbackId): bool
    {
        return $this->stopPlaybackSession($user, $playbackId);
    }

    /**
     * Tüm playback session'ları durdur
     */
    public function stopAllSessions(User $user): int
    {
        if (!$this->shouldRun()) {
            return 0;
        }

        return DB::table($this->table)
            ->where('user_id', $user->id)
            ->delete();
    }

    /**
     * Concurrent stream limit al
     */
    public function getConcurrentStreamLimit(User $user): int
    {
        // 1. User override (admin tarafından ayarlanabilir)
        if ($user->concurrent_streams_limit !== null && $user->concurrent_streams_limit > 0) {
            return $user->concurrent_streams_limit;
        }

        // 2. Subscription Plan
        $subscription = $user->subscriptions()
            ->whereIn('status', ['active', 'trial'])
            ->where(function($q) {
                $q->whereNull('current_period_end')
                  ->orWhere('current_period_end', '>', now());
            })
            ->with('plan')
            ->first();

        if ($subscription && $subscription->plan) {
            // Önce concurrent_streams_limit, yoksa device_limit'e fallback
            if ($subscription->plan->concurrent_streams_limit) {
                return (int) $subscription->plan->concurrent_streams_limit;
            }
            if ($subscription->plan->device_limit) {
                return (int) $subscription->plan->device_limit;
            }
        }

        // 3. Tenant setting fallback
        if (function_exists('setting') && setting('concurrent_streams_limit')) {
            return (int) setting('concurrent_streams_limit');
        }

        // 4. Default
        return 1;
    }

    /**
     * Aktif playback sayısı
     */
    public function getActivePlaybackCount(User $user): int
    {
        if (!$this->shouldRun()) {
            return 0;
        }

        return DB::table($this->table)
            ->where('user_id', $user->id)
            ->where('last_ping', '>', now()->subSeconds($this->pingTimeout))
            ->count();
    }

    /**
     * Kullanıcının aktif playback session'larını getir
     */
    public function getActiveSessions(User $user): array
    {
        if (!$this->shouldRun()) {
            return [];
        }

        return DB::table($this->table)
            ->where('user_id', $user->id)
            ->where('last_ping', '>', now()->subSeconds($this->pingTimeout))
            ->orderBy('last_ping', 'desc')
            ->get()
            ->map(function($session) {
                return [
                    'playback_id' => $session->playback_id,
                    'device_name' => $session->device_name,
                    'device_type' => $session->device_type,
                    'current_song_id' => $session->current_song_id,
                    'last_ping' => $session->last_ping,
                    'started_at' => $session->created_at,
                    'ip_address' => $session->ip_address,
                ];
            })
            ->toArray();
    }

    /**
     * Expired session'ları temizle (30 saniye ping almayan)
     */
    public function cleanupExpiredSessions(): int
    {
        return DB::table($this->table)
            ->where('last_ping', '<', now()->subSeconds($this->pingTimeout))
            ->delete();
    }

    /**
     * Device type belirle
     */
    protected function getDeviceType(Agent $agent): string
    {
        if ($agent->isMobile()) return 'mobile';
        if ($agent->isTablet()) return 'tablet';
        return 'desktop';
    }
}