package dev.stave.cast

import android.content.Context
import android.util.Log
import dagger.hilt.android.qualifiers.ApplicationContext
import okhttp3.OkHttpClient
import okhttp3.Request
import java.io.BufferedReader
import java.io.InputStreamReader
import java.io.OutputStream
import java.net.Inet4Address
import java.net.NetworkInterface
import java.net.ServerSocket
import java.net.Socket
import java.net.URLDecoder
import java.net.URLEncoder
import java.util.concurrent.TimeUnit
import javax.inject.Inject
import javax.inject.Singleton

/**
 * Lightweight HTTP proxy between UPnP media servers (MinimServer, etc.)
 * and Chromecast speaker groups. Cast group leaders make HTTP Range
 * requests to synchronize playback across members. When fetching the
 * raw UPnP URL directly, the server's responses can cause broken audio
 * on group members. The proxy normalizes HTTP behavior — proper
 * Content-Length, Accept-Ranges, Content-Range headers on every
 * response — so the group leader can seek and sync reliably.
 *
 * Single speakers don't need this; they handle server quirks
 * internally. The proxy is only used when [CastIntegration] detects
 * the target is a speaker group.
 *
 * Same architecture as BubbleUPnP's internal cast-proxy.
 */
@Singleton
class CastStreamProxy @Inject constructor(
    @ApplicationContext private val context: Context,
) {
    private val tag = "EarhornProxy"

    private val client = OkHttpClient.Builder()
        .connectTimeout(10, TimeUnit.SECONDS)
        .readTimeout(120, TimeUnit.SECONDS)
        .build()

    private var server: ServerSocket? = null
    private var port: Int = 0
    @Volatile private var running = false

    /** design decision 2026-09-02 (I.32 / review N.4): the proxy used to
     *  relay ANY url= a LAN client named and serve ANY content:// URI the
     *  app could open, from the first cast until the process died. Now every
     *  link the app hands the receiver carries a random token; requests
     *  without a known token get 403; and [stop] is called on cast end. */
    private val streamTokens = java.util.concurrent.ConcurrentHashMap<String, String>()          // token -> upstream URL
    private val localTokens = java.util.concurrent.ConcurrentHashMap<String, Pair<String, String>>() // token -> (content uri, mime)

    /** The upstream URL or content URI a proxied link stands for, or null if
     *  the link is not one this proxy issued. Lets the resume check compare
     *  the receiver's contentId against the phone's queue when group casts
     *  go through tokened links (review C.3, 2026-09-02). */
    fun originalFor(proxiedUrl: String): String? {
        val token = proxiedUrl.substringAfter("t=", "").substringBefore('&')
        if (token.isEmpty()) return null
        return streamTokens[token] ?: localTokens[token]?.first
    }
    private val rng = java.security.SecureRandom()

    private fun newToken(): String {
        val b = ByteArray(16); rng.nextBytes(b)
        return b.joinToString("") { "%02x".format(it) }
    }

    /** Start the proxy on a random port, bound to the LAN interface only
     *  when it can be determined. Idempotent. */
    fun start() {
        if (running) return
        val bindAddr = runCatching { getLocalIp()?.let { java.net.InetAddress.getByName(it) } }.getOrNull()
        val ss = if (bindAddr != null) ServerSocket(0, 50, bindAddr) else ServerSocket(0)
        port = ss.localPort
        server = ss
        running = true
        Log.i(tag, "Started on port $port (bound to ${bindAddr?.hostAddress ?: "all interfaces"})")
        Thread(null, {
            while (running && !ss.isClosed) {
                try {
                    val socket = ss.accept()
                    Thread(null, { handleConnection(socket) }, "cast-proxy-req").start()
                } catch (e: Exception) {
                    if (running) Log.w(tag, "Accept error", e)
                }
            }
        }, "cast-proxy-accept").start()
    }

    fun stop() {
        running = false
        runCatching { server?.close() }
        server = null
        streamTokens.clear()
        localTokens.clear()
        Log.i(tag, "Stopped")
    }

    /** Wrap a UPnP resource URL so the Cast device fetches from this
     *  proxy instead. Starts the proxy if not already running. */
    fun proxyUrl(originalUrl: String): String {
        start()
        val ip = getLocalIp() ?: "127.0.0.1"
        val token = newToken()
        streamTokens[token] = originalUrl
        return "http://$ip:$port/stream?t=$token"
    }

    /** Create a proxy URL for a local content:// URI so the Chromecast
     *  can stream local files over HTTP. [contentUri] is the MediaStore
     *  content:// URI; [mimeType] is passed through as Content-Type
     *  so the Cast receiver knows how to decode. */
    fun localProxyUrl(contentUri: String, mimeType: String?): String {
        start()
        val ip = getLocalIp() ?: "127.0.0.1"
        val token = newToken()
        localTokens[token] = contentUri to (mimeType ?: "audio/mpeg")
        return "http://$ip:$port/local?t=$token"
    }

    private fun handleConnection(socket: Socket) {
        try {
            socket.soTimeout = 30_000
            socket.sendBufferSize = 262144  // 256KB — matches the read buffer
            socket.tcpNoDelay = true        // disable Nagle — send chunks immediately
            val input = BufferedReader(InputStreamReader(socket.getInputStream()))
            val output = socket.getOutputStream()

            val requestLine = input.readLine() ?: return
            val parts = requestLine.split(' ')
            val method = parts.getOrNull(0) ?: "GET"
            val path = parts.getOrNull(1) ?: ""

            // Read headers
            val headers = mutableMapOf<String, String>()
            var line = input.readLine()
            while (line != null && line.isNotBlank()) {
                val colon = line.indexOf(':')
                if (colon > 0) {
                    headers[line.substring(0, colon).trim().lowercase()] =
                        line.substring(colon + 1).trim()
                }
                line = input.readLine()
            }

            // Extract Range header — needed by both local and UPnP paths
            val rangeHeader = headers["range"]

            // Only links the app itself issued are served: /local?t=… and
            // /stream?t=…. Anything else is refused.
            val token = path.substringAfter("t=", "").substringBefore('&').substringBefore(' ')

            // ── Local file path: /local?t=<token> ──
            if (path.startsWith("/local")) {
                val entry = localTokens[token]
                if (entry == null) {
                    sendError(output, 403, "Forbidden")
                    return
                }
                val contentUri = android.net.Uri.parse(entry.first)
                val contentType = entry.second
                Log.i(tag, "$method LOCAL $contentUri mime=$contentType range=$rangeHeader")

                handleLocalFile(socket, output, method, contentUri, contentType, rangeHeader)
                return
            }

            // ── UPnP proxy path: /stream?t=<token> ──
            val originalUrl = streamTokens[token]
            if (originalUrl == null) {
                sendError(output, 403, "Forbidden")
                return
            }

            Log.i(tag, "$method $originalUrl range=$rangeHeader")

            // First: HEAD request to get Content-Length if we don't have Range
            // For Range requests, pass through directly
            val reqBuilder = Request.Builder().url(originalUrl)
            if (rangeHeader != null) {
                reqBuilder.header("Range", rangeHeader)
            }
            if (method == "HEAD") {
                reqBuilder.head()
            }

            val response = client.newCall(reqBuilder.build()).execute()
            val body = response.body
            val contentType = response.header("Content-Type") ?: "application/octet-stream"
            val contentLength = response.header("Content-Length")
            val contentRange = response.header("Content-Range")
            val acceptRanges = response.header("Accept-Ranges") ?: "bytes"

            val statusCode = response.code
            // Relay the real reason phrase (I.33: everything used to be "OK").
            val statusText = response.message.ifBlank {
                when (statusCode) { 200 -> "OK"; 206 -> "Partial Content"; 404 -> "Not Found"; else -> "Error" }
            }

            // Build response
            val sb = StringBuilder()
            sb.append("HTTP/1.1 $statusCode $statusText\r\n")
            sb.append("Content-Type: $contentType\r\n")
            sb.append("Accept-Ranges: bytes\r\n")
            sb.append("Access-Control-Allow-Origin: *\r\n")
            if (contentLength != null) {
                sb.append("Content-Length: $contentLength\r\n")
            }
            if (contentRange != null) {
                sb.append("Content-Range: $contentRange\r\n")
            }
            sb.append("Connection: close\r\n")
            sb.append("\r\n")

            output.write(sb.toString().toByteArray())
            output.flush()

            // Stream body for GET (not HEAD)
            if (method != "HEAD" && body != null) {
                val buf = ByteArray(32768)
                val bodyStream = body.byteStream()
                try {
                    var read: Int
                    while (bodyStream.read(buf).also { read = it } != -1) {
                        output.write(buf, 0, read)
                    }
                    output.flush()
                } catch (e: Exception) {
                    // Client disconnected — normal during seek
                    Log.d(tag, "Stream interrupted: ${e.message}")
                } finally {
                    bodyStream.close()
                }
            }
            body?.close()
            response.close()
        } catch (e: Exception) {
            Log.w(tag, "Connection error", e)
        } finally {
            runCatching { socket.close() }
        }
    }

    /** Serve a local content:// file to the Chromecast via HTTP.
     *  Supports Range requests so Cast can seek within the track. */
    private fun handleLocalFile(
        socket: Socket,
        output: OutputStream,
        method: String,
        contentUri: android.net.Uri,
        contentType: String,
        rangeHeader: String?,
    ) {
        try {
            val afd = context.contentResolver.openAssetFileDescriptor(contentUri, "r")
            if (afd == null) {
                sendError(output, 404, "File not found")
                return
            }

            val totalSize = afd.length // -1 if unknown

            val rangeStart: Long
            val rangeEnd: Long
            val statusCode: Int
            val statusText: String

            if (rangeHeader != null && totalSize > 0) {
                val rangeParts = rangeHeader.removePrefix("bytes=").split('-')
                rangeStart = rangeParts.getOrNull(0)?.toLongOrNull() ?: 0L
                rangeEnd = rangeParts.getOrNull(1)?.toLongOrNull()
                    ?.coerceAtMost(totalSize - 1) ?: (totalSize - 1)
                statusCode = 206
                statusText = "Partial Content"
            } else {
                rangeStart = 0L
                rangeEnd = if (totalSize > 0) totalSize - 1 else -1L
                statusCode = 200
                statusText = "OK"
            }

            val contentLength = if (rangeEnd >= 0) rangeEnd - rangeStart + 1 else totalSize
            val sb = StringBuilder()
            sb.append("HTTP/1.1 $statusCode $statusText\r\n")
            sb.append("Content-Type: $contentType\r\n")
            sb.append("Accept-Ranges: bytes\r\n")
            sb.append("Access-Control-Allow-Origin: *\r\n")
            if (contentLength > 0) sb.append("Content-Length: $contentLength\r\n")
            if (statusCode == 206 && totalSize > 0) {
                sb.append("Content-Range: bytes $rangeStart-$rangeEnd/$totalSize\r\n")
            }
            sb.append("Connection: close\r\n\r\n")

            // Wrap in BufferedOutputStream — raw socket writes of small
            // chunks thrash the TCP stack and cause Cast buffer underruns
            // on high-bitrate formats like FLAC.
            val buffered = java.io.BufferedOutputStream(output, 262144)
            buffered.write(sb.toString().toByteArray())
            buffered.flush()

            if (method == "HEAD") {
                afd.close()
                return
            }

            // Stream from the file descriptor directly (no double-open).
            // FileInputStream from the AFD supports efficient skip via
            // FileChannel.position() under the hood.
            val stream = afd.createInputStream()
            if (stream == null) {
                Log.w(tag, "Failed to open input stream for $contentUri")
                afd.close()
                return
            }

            stream.use { input ->
                // Use FileChannel.position() for O(1) seeking instead of
                // InputStream.skip() which reads and discards bytes — on a
                // 50MB FLAC file, skip(40MB) reads 40MB of data before sending
                // anything, causing the Cast receiver to starve.
                if (rangeStart > 0 && input is java.io.FileInputStream) {
                    input.channel.position(rangeStart)
                } else if (rangeStart > 0) {
                    // Fallback for non-FileInputStream (shouldn't happen
                    // with ContentResolver but be safe)
                    var toSkip = rangeStart
                    while (toSkip > 0) {
                        val skipped = input.skip(toSkip)
                        if (skipped <= 0) break
                        toSkip -= skipped
                    }
                }

                // 256KB read buffer. Flush after every write so the Cast
                // receiver gets data continuously rather than in bursts.
                // Without per-write flushes, BufferedOutputStream holds
                // partial chunks until 256KB accumulates, creating gaps
                // in the TCP stream that the receiver hears as dropouts
                // on data-heavy FLAC passages.
                val buf = ByteArray(262144)
                var remaining = if (contentLength > 0) contentLength else Long.MAX_VALUE
                try {
                    while (remaining > 0) {
                        val toRead = minOf(buf.size.toLong(), remaining).toInt()
                        val read = input.read(buf, 0, toRead)
                        if (read == -1) break
                        buffered.write(buf, 0, read)
                        buffered.flush()
                        remaining -= read
                    }
                } catch (e: Exception) {
                    Log.d(tag, "Local stream interrupted: ${e.message}")
                }
            }
            afd.close()
        } catch (e: Exception) {
            Log.w(tag, "Local file error for $contentUri", e)
            runCatching { sendError(output, 500, "Internal error") }
        } finally {
            runCatching { socket.close() }
        }
    }

    private fun sendError(output: OutputStream, code: Int, message: String) {
        val body = message.toByteArray()
        val response = "HTTP/1.1 $code $message\r\n" +
            "Content-Type: text/plain\r\n" +
            "Content-Length: ${body.size}\r\n" +
            "Connection: close\r\n" +
            "\r\n"
        output.write(response.toByteArray())
        output.write(body)
        output.flush()
    }

    /** Phone's local IPv4 address on WiFi/ethernet. */
    private fun getLocalIp(): String? {
        try {
            for (iface in NetworkInterface.getNetworkInterfaces()) {
                if (iface.isLoopback || !iface.isUp) continue
                // Prefer wlan/eth interfaces
                val name = iface.name.lowercase()
                if (!name.startsWith("wlan") && !name.startsWith("eth") &&
                    !name.startsWith("en")) continue
                for (addr in iface.inetAddresses) {
                    if (addr is Inet4Address && !addr.isLoopbackAddress) {
                        return addr.hostAddress
                    }
                }
            }
            // Fallback: any non-loopback IPv4
            for (iface in NetworkInterface.getNetworkInterfaces()) {
                if (iface.isLoopback || !iface.isUp) continue
                for (addr in iface.inetAddresses) {
                    if (addr is Inet4Address && !addr.isLoopbackAddress) {
                        return addr.hostAddress
                    }
                }
            }
        } catch (e: Exception) {
            Log.w(tag, "Failed to get local IP", e)
        }
        return null
    }
}