🎵 MUZİBU MÜZİK PLATFORMU

protected function getPreviewStreamResponse(Song $song, string $userType): JsonResponse
{
    // HLS conversion başlat
    if ($song->needsHlsConversion()) {
        ConvertToHLSJob::dispatch($song);
    }

    // Stream URL hazırla
    if (!empty($song->hls_path)) {
        $streamUrl = route('api.muzibu.songs.dynamic-playlist', ['id' => $song->song_id]);
        $streamType = 'hls';
        $fallbackUrl = $this->signedUrlService->generateStreamUrl($song->song_id, 30, true);
    } else {
        $streamUrl = $this->signedUrlService->generateStreamUrl($song->song_id, 30);
        $streamType = 'mp3';
        $fallbackUrl = null;
    }

    $message = $userType === 'guest'
        ? 'Kayıt olun, tam dinleyin'
        : 'Premium\'a geçin, sınırsız dinleyin';

    return response()->json([
        'status' => 'preview',
        'message' => $message,
        'stream_url' => $streamUrl,
        'stream_type' => $streamType,
        'fallback_url' => $fallbackUrl,
        'preview_duration' => 30,
        'is_premium' => false,
    ]);
}

public function getDeviceLimit(User $user): int
{
    // 1. User override (VIP/Test/Ban)
    if ($user->device_limit !== null && $user->device_limit > 0) {
        return $user->device_limit;
    }

    // 2. Subscription Plan device_limit
    $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 && $subscription->plan->device_limit) {
        return (int) $subscription->plan->device_limit;
    }

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

    // 4. Ultimate fallback
    return 1;
}

// CSRF token yenileme interceptor ekle
axios.interceptors.response.use(
    response => response,
    error => {
        // CSRF token mismatch hatası
        if (error.response?.status === 419) {
            console.warn('CSRF token expired, refreshing...');

            // Yeni token al
            return axios.get('/sanctum/csrf-cookie').then(() => {
                // Token yenilendi, isteği tekrar gönder
                return axios(error.config);
            });
        }
        return Promise.reject(error);
    }
);

async login() {
    try {
        const response = await axios.post('/api/login', this.loginForm);

        // Login başarılı
        window.location.reload();

    } catch (error) {
        // CSRF token yenileme zaten interceptor'da

        // Device limit kontrolü
        if (error.response?.status === 403 &&
            error.response?.data?.error === 'device_limit_exceeded') {

            // Device selection modal aç
            this.activeDevices = error.response.data.devices;
            this.deviceLimit = error.response.data.limit;
            this.showDeviceSelectionModal = true;
            return;
        }

        // Diğer hatalar
        this.authError = error.response?.data?.message || 'Giriş başarısız';
    }
}

public function updateSessionActivity(): array
{
    $user = auth('web')->user() ?? auth('sanctum')->user();

    if (!$user) {
        return ['status' => 'unauthenticated'];
    }

    $sessionId = session()->getId();

    // MySQL: last_activity güncelle
    UserActiveSession::where('session_id', $sessionId)
        ->where('user_id', $user->id)
        ->update(['last_activity' => now()]);

    // Redis: Session TTL yenile (120 dakika)
    Redis::expire("laravel_session:{$sessionId}", 7200);

    // Mevcut cihaz limiti kontrol
    $deviceLimit = $this->getDeviceLimit($user);
    $activeDevices = $this->getActiveDevicesCount($user);

    return [
        'status' => 'active',
        'device_limit' => $deviceLimit,
        'active_devices' => $activeDevices,
        'device_limit_exceeded' => $activeDevices > $deviceLimit,
    ];
}

return [
    'session' => [
        'polling_interval' => env('MUZIBU_SESSION_POLLING', 30000), // ms
        'ttl' => env('MUZIBU_SESSION_TTL', 7200), // saniye
    ],
];

public function stream(Song $song)
{
    $user = auth('web')->user() ?? auth('sanctum')->user();

    // 1. Guest user
    if (!$user) {
        return $this->getPreviewStreamResponse($song, 'guest');
    }

    // 2. Free member
    if (!$user->isPremiumOrTrial()) {
        return $this->getPreviewStreamResponse($song, 'free');
    }

    // 3. Premium/Trial member
    return $this->getFullStreamResponse($song, $user);
}

protected function getPreviewStreamResponse(Song $song, string $userType): JsonResponse
{
    // HLS conversion
    if ($song->needsHlsConversion()) {
        ConvertToHLSJob::dispatch($song);
    }

    // Stream URL (30 saniye limit)
    if (!empty($song->hls_path)) {
        $streamUrl = route('api.muzibu.songs.dynamic-playlist', [
            'id' => $song->song_id
        ]);
        $streamType = 'hls';
        $fallbackUrl = $this->signedUrlService->generateStreamUrl(
            $song->song_id, 30, true
        );
    } else {
        $streamUrl = $this->signedUrlService->generateStreamUrl(
            $song->song_id, 30
        );
        $streamType = 'mp3';
        $fallbackUrl = null;
    }

    $message = $userType === 'guest'
        ? 'Kayıt olun, tam dinleyin'
        : 'Premium\'a geçin, sınırsız dinleyin';

    return response()->json([
        'status' => 'preview',
        'message' => $message,
        'stream_url' => $streamUrl,
        'stream_type' => $streamType,
        'fallback_url' => $fallbackUrl,
        'preview_duration' => 30,
        'is_premium' => false,
    ]);
}

protected function getFullStreamResponse(Song $song, User $user): JsonResponse
{
    // Full stream logic (sınırsız)
    // ...
}

return [
    'stream' => [
        'preview_duration' => env('MUZIBU_PREVIEW_DURATION', 30), // saniye
        'hls_timeout' => env('MUZIBU_HLS_TIMEOUT', 6), // saniye
        'preview_chunks' => env('MUZIBU_PREVIEW_CHUNKS', 3), // adet
    ],
];

namespace App\Observers;

use Modules\Subscription\app\Models\Subscription;
use Illuminate\Support\Facades\Cache;

class SubscriptionObserver
{
    public function created(Subscription $subscription)
    {
        $this->flushPremiumCache($subscription->user_id);
    }

    public function updated(Subscription $subscription)
    {
        $this->flushPremiumCache($subscription->user_id);
    }

    public function deleted(Subscription $subscription)
    {
        $this->flushPremiumCache($subscription->user_id);
    }

    protected function flushPremiumCache(int $userId)
    {
        $tenantId = tenant() ? tenant()->id : 1;
        $cacheKey = "premium_status_{$userId}_{$tenantId}";

        Cache::forget($cacheKey);

        \Log::info("Premium cache flushed", [
            'user_id' => $userId,
            'tenant_id' => $tenantId,
            'cache_key' => $cacheKey,
        ]);
    }
}

public function logout()
{
    $user = auth('web')->user() ?? auth('sanctum')->user();

    if ($user) {
        // Premium cache temizle
        $tenantId = tenant() ? tenant()->id : 1;
        $cacheKey = "premium_status_{$user->id}_{$tenantId}";
        Cache::forget($cacheKey);

        // Device session temizle
        app(DeviceService::class)->unregisterSession();

        // Auth logout
        Auth::logout();
    }

    return response()->json(['message' => 'Logged out']);
}

@auth
    @php
        $deviceService = app(\Modules\Muzibu\app\Services\DeviceService::class);
        $deviceLimit = $deviceService->getDeviceLimit(auth()->user());
    @endphp

    window.muzibuPlayerConfig = {
        deviceLimit: {{ $deviceLimit }},
        sessionPollingInterval: {{ config('muzibu.session.polling_interval') }},
        previewDuration: {{ config('muzibu.stream.preview_duration') }},
    };
@endauth

return [
    // Stream Settings
    'stream' => [
        'preview_duration' => env('MUZIBU_PREVIEW_DURATION', 30),
        'hls_timeout' => env('MUZIBU_HLS_TIMEOUT', 6),
        'preview_chunks' => env('MUZIBU_PREVIEW_CHUNKS', 3),
    ],

    // Session Settings
    'session' => [
        'polling_interval' => env('MUZIBU_SESSION_POLLING', 30000),
        'ttl' => env('MUZIBU_SESSION_TTL', 7200),
    ],

    // Cache Settings
    'cache' => [
        'premium_status_ttl' => env('MUZIBU_PREMIUM_CACHE_TTL', 300),
    ],

    // Device Settings
    'device' => [
        'default_limit' => env('MUZIBU_DEVICE_LIMIT_FALLBACK', 1),
    ],
];

// DeviceService.php (MEVCUT - DOĞRU)
if (function_exists('setting') && setting('auth_device_limit')) {
    return (int) setting('auth_device_limit');
}

// SongStreamController.php (EKLENMELİ)
$previewDuration = setting('muzibu_preview_duration')
    ?? config('muzibu.stream.preview_duration');

// Session Polling (EKLENMELİ)
$pollingInterval = setting('muzibu_session_polling')
    ?? config('muzibu.session.polling_interval');