package com.example.godeye.services

import android.app.Notification
import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.app.Service
import android.content.Context
import android.content.Intent
import android.os.Build
import android.os.IBinder
import android.util.Log
import androidx.core.app.NotificationCompat
import com.example.godeye.MainActivity
import com.example.godeye.R
import com.example.godeye.managers.SignalingManager
import com.example.godeye.models.SessionState
import com.example.godeye.models.SignalingState
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.collect

/**
 * Фоновый сервис для поддержания подключения к сигналлинг серверу
 */
class SignalingService : Service() {

    companion object {
        private const val TAG = "SignalingService"
        private const val NOTIFICATION_ID = 1001
        private const val CHANNEL_ID = "signaling_channel"
        private const val CHANNEL_NAME = "Сигналлинг GodEye"

        fun start(context: Context) {
            val intent = Intent(context, SignalingService::class.java)
            context.startForegroundService(intent)
        }

        fun stop(context: Context) {
            val intent = Intent(context, SignalingService::class.java)
            context.stopService(intent)
        }
    }

    private lateinit var signalingManager: SignalingManager
    private val serviceScope = CoroutineScope(Dispatchers.Main + SupervisorJob())

    override fun onCreate() {
        super.onCreate()
        Log.d(TAG, "SignalingService created")

        signalingManager = SignalingManager(this)
        createNotificationChannel()

        // Отслеживаем состояние подключения
        serviceScope.launch {
            signalingManager.signalingState.collect { state ->
                updateNotification(state)
            }
        }

        // Отслеживаем состояние сессии
        serviceScope.launch {
            signalingManager.sessionState.collect { sessionState ->
                handleSessionStateChange(sessionState)
            }
        }
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        Log.d(TAG, "SignalingService started")

        // Запускаем в foreground режиме
        startForeground(NOTIFICATION_ID, createNotification(SignalingState.CONNECTING))

        // Подключаемся к сигналлинг серверу
        signalingManager.start()

        return START_STICKY // Перезапускать сервис при убийстве системой
    }

    override fun onDestroy() {
        Log.d(TAG, "SignalingService destroyed")

        signalingManager.stop()
        serviceScope.cancel()

        super.onDestroy()
    }

    override fun onBind(intent: Intent?): IBinder? {
        return null // Не поддерживаем binding
    }

    /**
     * Создание канала уведомлений
     */
    private fun createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val channel = NotificationChannel(
                CHANNEL_ID,
                CHANNEL_NAME,
                NotificationManager.IMPORTANCE_LOW
            ).apply {
                description = "Уведомления о состоянии подключения к серверу"
                setShowBadge(false)
            }

            val notificationManager = getSystemService(NotificationManager::class.java)
            notificationManager.createNotificationChannel(channel)
        }
    }

    /**
     * Создание уведомления
     */
    private fun createNotification(state: SignalingState): Notification {
        val intent = Intent(this, MainActivity::class.java).apply {
            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
        }

        val pendingIntent = PendingIntent.getActivity(
            this, 0, intent,
            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
        )

        val (title, content, icon) = when (state) {
            SignalingState.CONNECTED -> Triple(
                "GodEye подключен",
                "Готов к приему звонков от операторов",
                android.R.drawable.ic_dialog_info
            )
            SignalingState.CONNECTING -> Triple(
                "GodEye подключается",
                "Подключение к серверу...",
                android.R.drawable.ic_dialog_info
            )
            SignalingState.RECONNECTING -> Triple(
                "GodEye переподключается",
                "Восстановление соединения...",
                android.R.drawable.ic_dialog_alert
            )
            SignalingState.ERROR -> Triple(
                "GodEye - ошибка",
                "Проблема с подключением к серверу",
                android.R.drawable.ic_dialog_alert
            )
            SignalingState.DISCONNECTED -> Triple(
                "GodEye отключен",
                "Нет подключения к серверу",
                android.R.drawable.ic_dialog_alert
            )
        }

        return NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle(title)
            .setContentText(content)
            .setSmallIcon(icon)
            .setContentIntent(pendingIntent)
            .setOngoing(true)
            .setCategory(NotificationCompat.CATEGORY_SERVICE)
            .setPriority(NotificationCompat.PRIORITY_LOW)
            .build()
    }

    /**
     * Обновление уведомления
     */
    private fun updateNotification(state: SignalingState) {
        val notificationManager = getSystemService(NotificationManager::class.java)
        notificationManager.notify(NOTIFICATION_ID, createNotification(state))
    }

    /**
     * Обработка изменения состояния сессии
     */
    private fun handleSessionStateChange(sessionState: SessionState) {
        when (sessionState) {
            SessionState.INCOMING -> {
                // Показываем уведомление о входящем звонке
                showIncomingCallNotification()
            }
            SessionState.ACTIVE -> {
                // Обновляем уведомление об активной сессии
                showActiveCallNotification()
            }
            SessionState.ENDED -> {
                // Возвращаемся к обычному уведомлению
                updateNotification(signalingManager.signalingState.value)
            }
            else -> {
                // Обычное состояние
            }
        }
    }

    /**
     * Показ уведомления о входящем звонке
     */
    private fun showIncomingCallNotification() {
        val currentCall = signalingManager.currentCall.value ?: return

        val intent = Intent(this, MainActivity::class.java).apply {
            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
            putExtra("incoming_call", true)
        }

        val pendingIntent = PendingIntent.getActivity(
            this, 0, intent,
            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
        )

        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle("Входящий звонок")
            .setContentText("От оператора: ${currentCall.operatorName}")
            .setSmallIcon(android.R.drawable.ic_menu_call)
            .setContentIntent(pendingIntent)
            .setCategory(NotificationCompat.CATEGORY_CALL)
            .setPriority(NotificationCompat.PRIORITY_HIGH)
            .setAutoCancel(true)
            .setFullScreenIntent(pendingIntent, true)
            .build()

        val notificationManager = getSystemService(NotificationManager::class.java)
        notificationManager.notify(NOTIFICATION_ID + 1, notification)
    }

    /**
     * Показ уведомления об активной сессии
     */
    private fun showActiveCallNotification() {
        val currentCall = signalingManager.currentCall.value ?: return

        val intent = Intent(this, MainActivity::class.java).apply {
            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
        }

        val pendingIntent = PendingIntent.getActivity(
            this, 0, intent,
            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
        )

        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle("Активная сессия")
            .setContentText("С оператором: ${currentCall.operatorName}")
            .setSmallIcon(android.R.drawable.ic_menu_camera)
            .setContentIntent(pendingIntent)
            .setOngoing(true)
            .setCategory(NotificationCompat.CATEGORY_SERVICE)
            .setPriority(NotificationCompat.PRIORITY_LOW)
            .build()

        val notificationManager = getSystemService(NotificationManager::class.java)
        notificationManager.notify(NOTIFICATION_ID, notification)
    }
}
