GaCyGO-Android/app/src/main/java/com/gacy/android/service/ServerService.kt

package com.gacy.android.service

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.content.pm.ServiceInfo
import android.os.Build
import android.os.IBinder
import androidx.core.app.NotificationCompat
import com.chaquo.python.Python
import com.chaquo.python.android.AndroidPlatform
import com.gacy.android.GaCyApplication
import com.gacy.android.MainActivity
import com.gacy.android.R
import com.gacy.android.data.PersistentRepository
import com.gacy.android.data.PreferencesRepository
import com.gacy.android.data.UpdateRepository
import com.gacy.android.model.ServerExecutionMode
import com.gacy.android.model.ServerStatus
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.isActive
import kotlinx.coroutines.launch
import java.io.File
import java.net.InetSocketAddress
import java.net.Socket

class ServerLogReceiver {
    fun onServerLog(msg: String) {
        LogBuffer.append(msg)
    }
}

class ServerService : Service() {

    private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
    private var serverThread: Thread? = null
    private var probeJob: Job? = null
    private var executionJob: Job? = null

    override fun onBind(intent: Intent?): IBinder? = null

    override fun onCreate() {
        super.onCreate()
        createNotificationChannel()
        _serverStatus.value = ServerStatus.STOPPED
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        val action = intent?.action ?: ACTION_START

        when (action) {
            ACTION_START -> startServer()
            ACTION_STOP -> stopServer()
            ACTION_RESTART -> restartServer()
        }

        return START_NOT_STICKY
    }

    private fun startServer() {
        if (_serverStatus.value == ServerStatus.RUNNING || _serverStatus.value == ServerStatus.STARTING) {
            return
        }

        try {
            val prefs = PreferencesRepository(this)
            val config = prefs.getServerConfig()

            _serverStatus.value = ServerStatus.STARTING
            startForegroundCompat("GaCy Server is starting...")
            LogBuffer.append("--- GaCy Server Starting ---")
            LogBuffer.append("Mode: ${config.executionMode.displayNameEn}")
            LogBuffer.append("Dispatch Port: ${config.dispatchPort} | Gameserver Port: ${config.gameserverPort}")

            if (config.executionMode == ServerExecutionMode.LOCAL_EMBEDDED) {
                startLocalServerExecution(config.dispatchPort)
            } else {
                startRemoteMonitor(config.remoteHost, config.dispatchPort)
            }
        } catch (t: Throwable) {
            LogBuffer.append("[Start Error] ${t.localizedMessage ?: t.message}")
            t.printStackTrace()
            _serverStatus.value = ServerStatus.ERROR
            stopForegroundCompat()
            stopSelf()
        }
    }

    private fun startLocalServerExecution(dispatchPort: Int) {
        executionJob?.cancel()
        executionJob = serviceScope.launch {
            try {
                val updateRepo = UpdateRepository(this@ServerService)
                if (!updateRepo.isServerInstalled()) {
                    LogBuffer.append("[Setup] Installing GaCy embedded server binaries from assets...")
                    val success = updateRepo.ensureServerInstalled()
                    if (!success) {
                        LogBuffer.append("[Error] Failed to install server binaries from assets.")
                        _serverStatus.value = ServerStatus.ERROR
                        stopForegroundCompat()
                        stopSelf()
                        return@launch
                    }
                    LogBuffer.append("[Setup] Server binaries installed successfully.")
                }

                val ppsrFile = File(filesDir, "server/build/build/ppsr.pyc")
                if (!ppsrFile.exists()) {
                    LogBuffer.append("[Error] Server bytecode missing at: ${ppsrFile.absolutePath}")
                    _serverStatus.value = ServerStatus.ERROR
                    stopForegroundCompat()
                    stopSelf()
                    return@launch
                }

                try {
                    val persistentRepo = PersistentRepository(this@ServerService)
                    persistentRepo.ensureValidPersistentJsonSync()
                } catch (e: Throwable) {
                    LogBuffer.append("[Warning] Persistent validation: ${e.message}")
                }

                LogBuffer.append("[System] Launching embedded GaCy Python server...")

                // Background TCP port readiness probe
                probeJob?.cancel()
                probeJob = serviceScope.launch {
                    var attempts = 0
                    while (isActive && _serverStatus.value == ServerStatus.STARTING && attempts < 35) {
                        delay(1000)
                        attempts++
                        if (isPortOpen("127.0.0.1", dispatchPort)) {
                            _serverStatus.value = ServerStatus.RUNNING
                            updateNotification("GaCy Server is RUNNING on :$dispatchPort")
                            LogBuffer.append("[System] GaCy Dispatch server is ready on 127.0.0.1:$dispatchPort")
                            break
                        }
                    }
                }

                serverThread = Thread({
                    try {
                        if (!Python.isStarted()) {
                            Python.start(AndroidPlatform(applicationContext))
                        }
                        val py = Python.getInstance()
                        val runPpsr = py.getModule("run_ppsr")
                        val logReceiver = ServerLogReceiver()
                        runPpsr.callAttr("run_server", ppsrFile.absolutePath, logReceiver)
                    } catch (t: Throwable) {
                        LogBuffer.append("[Python Error] ${t.localizedMessage ?: t.message}")
                        t.printStackTrace()
                    } finally {
                        probeJob?.cancel()
                        _serverStatus.value = ServerStatus.STOPPED
                        LogBuffer.append("[System] Server stopped.")
                        stopForegroundCompat()
                        stopSelf()
                    }
                }, "GaCy-PythonServer").apply {
                    start()
                }
            } catch (t: Throwable) {
                LogBuffer.append("[Execution Error] ${t.localizedMessage ?: t.message}")
                t.printStackTrace()
                _serverStatus.value = ServerStatus.ERROR
                stopForegroundCompat()
                stopSelf()
            }
        }
    }

    private fun startRemoteMonitor(remoteHost: String, dispatchPort: Int) {
        executionJob?.cancel()
        executionJob = serviceScope.launch {
            LogBuffer.append("[Remote] Connecting to remote GaCy host at $remoteHost:$dispatchPort...")
            delay(600)
            _serverStatus.value = ServerStatus.RUNNING
            updateNotification("Monitoring Remote GaCy Host at $remoteHost")
            LogBuffer.append("[Remote] Connected to remote GaCy server monitor.")
        }
    }

    private fun stopServer() {
        LogBuffer.append("--- GaCy Server Stopping ---")
        _serverStatus.value = ServerStatus.STOPPING
        updateNotification("Stopping GaCy Server...")

        probeJob?.cancel()
        probeJob = null

        executionJob?.cancel()
        executionJob = null

        serviceScope.launch {
            try {
                if (Python.isStarted()) {
                    val py = Python.getInstance()
                    val runPpsr = py.getModule("run_ppsr")
                    runPpsr.callAttr("kill_server_process")
                }
            } catch (e: Throwable) {
                LogBuffer.append("[Stop Error] ${e.localizedMessage ?: e.message}")
            }

            delay(1200)
            serverThread?.interrupt()
            serverThread = null
            _serverStatus.value = ServerStatus.STOPPED
            stopForegroundCompat()
            stopSelf()
        }
    }

    private fun restartServer() {
        LogBuffer.append("Restarting GaCy Server...")
        stopServer()
        serviceScope.launch {
            delay(1500)
            startServer()
        }
    }

    private fun isPortOpen(host: String, port: Int): Boolean {
        return try {
            Socket().use { socket ->
                socket.connect(InetSocketAddress(host, port), 400)
                true
            }
        } catch (_: Throwable) {
            false
        }
    }

    private fun createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val channel = NotificationChannel(
                GaCyApplication.CHANNEL_ID,
                GaCyApplication.CHANNEL_NAME,
                NotificationManager.IMPORTANCE_LOW
            ).apply {
                description = "Background service for GaCy Game Server & Proxy"
                setShowBadge(false)
            }
            val manager = getSystemService(NotificationManager::class.java)
            manager?.createNotificationChannel(channel)
        }
    }

    private fun createNotification(contentText: String): Notification {
        createNotificationChannel()

        val launchIntent = Intent(this, MainActivity::class.java).apply {
            flags = Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP
        }
        val pendingIntent = PendingIntent.getActivity(
            this,
            0,
            launchIntent,
            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
        )

        val stopIntent = Intent(this, ServerService::class.java).apply {
            action = ACTION_STOP
        }
        val stopPendingIntent = PendingIntent.getService(
            this,
            1,
            stopIntent,
            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
        )

        return NotificationCompat.Builder(this, GaCyApplication.CHANNEL_ID)
            .setContentTitle("GaCy Android")
            .setContentText(contentText)
            .setSmallIcon(R.drawable.app_icon)
            .setOngoing(true)
            .setContentIntent(pendingIntent)
            .addAction(android.R.drawable.ic_menu_close_clear_cancel, "Stop", stopPendingIntent)
            .build()
    }

    private fun startForegroundCompat(text: String) {
        try {
            createNotificationChannel()
            val notification = createNotification(text)
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) { // API 34+
                startForeground(
                    NOTIFICATION_ID,
                    notification,
                    ServiceInfo.FOREGROUND_SERVICE_TYPE_SPECIAL_USE
                )
            } else {
                // API 26..33
                startForeground(NOTIFICATION_ID, notification)
            }
        } catch (e: Throwable) {
            try {
                val notification = createNotification(text)
                startForeground(NOTIFICATION_ID, notification)
            } catch (e2: Throwable) {
                LogBuffer.append("[Foreground Warning] ${e2.message}")
            }
        }
    }

    private fun updateNotification(contentText: String) {
        try {
            val manager = getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager
            manager?.notify(NOTIFICATION_ID, createNotification(contentText))
        } catch (_: Throwable) {}
    }

    private fun stopForegroundCompat() {
        try {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                stopForeground(STOP_FOREGROUND_REMOVE)
            } else {
                @Suppress("DEPRECATION")
                stopForeground(true)
            }
        } catch (_: Throwable) {}
    }

    override fun onDestroy() {
        probeJob?.cancel()
        serverThread?.interrupt()
        executionJob?.cancel()
        super.onDestroy()
        _serverStatus.value = ServerStatus.STOPPED
    }

    companion object {
        const val ACTION_START = "com.gacy.android.ACTION_START"
        const val ACTION_STOP = "com.gacy.android.ACTION_STOP"
        const val ACTION_RESTART = "com.gacy.android.ACTION_RESTART"
        private const val NOTIFICATION_ID = 20261

        private val _serverStatus = MutableStateFlow(ServerStatus.STOPPED)
        val serverStatus: StateFlow<ServerStatus> = _serverStatus.asStateFlow()

        fun start(context: Context) {
            val intent = Intent(context, ServerService::class.java).apply { action = ACTION_START }
            try {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                    context.startForegroundService(intent)
                } else {
                    context.startService(intent)
                }
            } catch (t: Throwable) {
                try {
                    context.startService(intent)
                } catch (t2: Throwable) {
                    LogBuffer.append("[Service Start Error] ${t2.message}")
                }
            }
        }

        fun stop(context: Context) {
            val intent = Intent(context, ServerService::class.java).apply { action = ACTION_STOP }
            try {
                context.startService(intent)
            } catch (t: Throwable) {
                LogBuffer.append("[Service Stop Error] ${t.message}")
            }
        }

        fun restart(context: Context) {
            val intent = Intent(context, ServerService::class.java).apply { action = ACTION_RESTART }
            try {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                    context.startForegroundService(intent)
                } else {
                    context.startService(intent)
                }
            } catch (t: Throwable) {
                try {
                    context.startService(intent)
                } catch (t2: Throwable) {
                    LogBuffer.append("[Service Restart Error] ${t2.message}")
                }
            }
        }
    }
}