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

package com.gacy.android.service

import android.app.Notification
import android.app.PendingIntent
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 androidx.lifecycle.LifecycleService
import androidx.lifecycle.lifecycleScope
import com.chaquo.python.Python
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.Dispatchers
import kotlinx.coroutines.Job
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 : LifecycleService() {

    private var serverThread: Thread? = null
    private var probeJob: Job? = null
    private var serverJob: Job? = null

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

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        super.onStartCommand(intent, flags, startId)
        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
        }

        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)
        }
    }

    private fun startLocalServerExecution(dispatchPort: Int) {
        serverJob = lifecycleScope.launch(Dispatchers.IO) {
            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: Exception) {
                LogBuffer.append("[Warning] Persistent validation: ${e.message}")
            }

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

            // Background TCP port readiness probe
            probeJob?.cancel()
            probeJob = lifecycleScope.launch(Dispatchers.IO) {
                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 {
                    val py = Python.getInstance()
                    val runPpsr = py.getModule("run_ppsr")
                    val logReceiver = ServerLogReceiver()
                    runPpsr.callAttr("run_server", ppsrFile.absolutePath, logReceiver)
                } catch (e: Exception) {
                    LogBuffer.append("[Python Error] ${e.localizedMessage ?: e.message}")
                } finally {
                    probeJob?.cancel()
                    _serverStatus.value = ServerStatus.STOPPED
                    LogBuffer.append("[System] Server stopped.")
                    stopForegroundCompat()
                    stopSelf()
                }
            }, "GaCy-PythonServer").apply {
                start()
            }
        }
    }

    private fun startRemoteMonitor(remoteHost: String, dispatchPort: Int) {
        serverJob = lifecycleScope.launch(Dispatchers.IO) {
            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

        serverJob?.cancel()
        serverJob = null

        lifecycleScope.launch(Dispatchers.IO) {
            try {
                if (Python.isStarted()) {
                    val py = Python.getInstance()
                    val runPpsr = py.getModule("run_ppsr")
                    runPpsr.callAttr("kill_server_process")
                }
            } catch (e: Exception) {
                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()
        lifecycleScope.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 (_: Exception) {
            false
        }
    }

    private fun createNotification(contentText: String): Notification {
        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.mipmap.ic_launcher)
            .setOngoing(true)
            .setContentIntent(pendingIntent)
            .addAction(android.R.drawable.ic_menu_close_clear_cancel, "Stop", stopPendingIntent)
            .build()
    }

    private fun startForegroundCompat(text: String) {
        val notification = createNotification(text)
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            startForeground(
                NOTIFICATION_ID,
                notification,
                ServiceInfo.FOREGROUND_SERVICE_TYPE_SPECIAL_USE
            )
        } else {
            startForeground(NOTIFICATION_ID, notification)
        }
    }

    private fun updateNotification(contentText: String) {
        val manager = getSystemService(Context.NOTIFICATION_SERVICE) as android.app.NotificationManager
        manager.notify(NOTIFICATION_ID, createNotification(contentText))
    }

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

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

    override fun onBind(intent: Intent): IBinder? {
        super.onBind(intent)
        return null
    }

    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 }
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                context.startForegroundService(intent)
            } else {
                context.startService(intent)
            }
        }

        fun stop(context: Context) {
            val intent = Intent(context, ServerService::class.java).apply { action = ACTION_STOP }
            context.startService(intent)
        }

        fun restart(context: Context) {
            val intent = Intent(context, ServerService::class.java).apply { action = ACTION_RESTART }
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                context.startForegroundService(intent)
            } else {
                context.startService(intent)
            }
        }
    }
}