package com.example.service

import android.net.Uri
import android.util.Log
import com.example.action.BaseAction
import com.example.action.HttpActionRequest
import com.example.action.HttpMethod
import com.example.action.NameValue
import com.example.action.NameVariable
import com.example.action.Next
import com.example.http.HttpClient
import com.example.http.HttpClient.call
import com.example.http.Request
import com.example.http.Response
import com.example.logger.LogUtils
import com.example.report.ActionExec
import com.example.task.TaskConfig
import com.example.utils.toJsonString
import com.example.utils.toJsonString1
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import java.net.URI
import java.net.URL
import kotlin.time.DurationUnit
import kotlin.time.toDuration

class HttpService(
    private val action: BaseAction.HttpAction,
    override val taskConfig: TaskConfig
) : BaseService(taskConfig) {

    companion object {
        private const val MAX_REDIRECT_COUNT = 30
        private val HTTP_REDIRECT_PATTERN = Regex("^[a-zA-Z0-9]+://.*")
        private val HTTP_STATUS_SUCCESS = 100 until 300
        private val HTTP_STATUS_REDIRECT = 300 until 400
    }

    // ==================== 主执行方法 ====================

    override suspend fun execute(onFinish: (List<ActionExec>) -> Unit) =
        withContext(Dispatchers.Default) {
            val actionExecList = mutableListOf<ActionExec>()
            val currentStep = taskConfig.currentStep
            
            try {
                handleActionDelay()
                val actionRequest = action.request ?: throw NullPointerException("request is null")
                
                amendActionRequest(actionRequest)
                val httpRequest = actionRequest.buildHttpRequest()
                
                val result = if (action.async) {
                    handleAsyncRequest(httpRequest, actionExecList)
                } else {
                    handleSyncRequest(httpRequest, actionExecList)
                }
                
                updateTaskStep(result, currentStep, httpRequest)
            } catch (e: Exception) {
                LogUtils.error(throwable = e)
                handleException(e, actionExecList, currentStep)
            }
            
            LogUtils.info("finish action: ${action.request?.url}")
            onFinish(actionExecList)
        }

    // ==================== 请求处理 ====================

    private suspend fun handleActionDelay() {
        if (action.delay > 0) {
            LogUtils.info("action delay: ${action.delay} s, it's async: ${action.async}")
            delay(action.delay.toDuration(DurationUnit.SECONDS))
        }
    }

    private data class RequestResult(
        val proceedTask: Boolean,
        val httpResponse: Response?
    )

    private fun handleAsyncRequest(
        httpRequest: Request,
        actionExecList: MutableList<ActionExec>
    ): RequestResult {
        httpRequest.makeAsyncRequest()
        val actionExec = httpRequest.genActionExec(null, 1)
        actionExec.respCode = ASYNC_EXEC_CODE
        actionExecList += actionExec
        return RequestResult(proceedTask = true, httpResponse = null)
    }

    private suspend fun handleSyncRequest(
        httpRequest: Request,
        actionExecList: MutableList<ActionExec>
    ): RequestResult {
        val request = httpRequest
        val response = request.call()
        val stepCallHttpCount = 1
        
        val actionExec = request.genActionExec(response, stepCallHttpCount)
        actionExecList += actionExec
        
        return when (response.code) {
            in HTTP_STATUS_SUCCESS -> {
                RequestResult(proceedTask = true, httpResponse = response)
            }
            
            in HTTP_STATUS_REDIRECT -> {
                handleRedirects(request, response, actionExecList).let { redirectResult ->
                    RequestResult(
                        proceedTask = redirectResult.proceedTask,
                        httpResponse = redirectResult.response
                    )
                }
            }
            
            else -> {
                RequestResult(proceedTask = action.skipError, httpResponse = response)
            }
        }
    }

    private data class RedirectResult(
        val proceedTask: Boolean,
        val response: Response?
    )

    private suspend fun handleRedirects(
        initialRequest: Request,
        initialResponse: Response,
        actionExecList: MutableList<ActionExec>
    ): RedirectResult {
        var request = initialRequest
        var response = initialResponse
        var stepCallHttpCount = 1
        var redirectUrl = getRedirectUrl(response)
        
        while (shouldContinueRedirect(response, redirectUrl, stepCallHttpCount)) {
            stepCallHttpCount++
            
            runCatching {
                request = request.buildRedirectHttpRequest(redirectUrl!!, request.url)
                response = request.call()
                
                if (response.code !in HTTP_STATUS_REDIRECT) {
                    updateResponseReferer(request, response)
                }
                
                redirectUrl = getRedirectUrl(response)
                LogUtils.info("redirectUrl: $redirectUrl")
                
                request.genActionExec(response, stepCallHttpCount)
            }.onFailure { e ->
                LogUtils.error(throwable = e)
                val errorExec = request.genActionExec(null, stepCallHttpCount).apply {
                    respCode = HttpClient.ErrorCode.ERROR_CODE_HTTP_BUILD_CONNECTION_FAILED
                }
                actionExecList += errorExec
                return RedirectResult(proceedTask = action.skipError, response = null)
            }.onSuccess { actionExec ->
                actionExecList += actionExec
            }
        }
        
        return RedirectResult(proceedTask = true, response = response)
    }

    private fun shouldContinueRedirect(
        response: Response?,
        redirectUrl: String?,
        stepCallHttpCount: Int
    ): Boolean {
        return response != null &&
                response.code in HTTP_STATUS_REDIRECT &&
                stepCallHttpCount <= MAX_REDIRECT_COUNT &&
                !redirectUrl.isNullOrBlank() &&
                redirectUrl.isHttpRedirect()
    }

    private fun getRedirectUrl(response: Response?): String? {
        return response?.headers?.get(
            HttpClient.Params.REQUEST_HEADER_LOCATION,
            ignoreCase = true
        )?.firstOrNull()
    }

    private fun updateResponseReferer(request: Request, response: Response) {
        if (response.headers.isNotEmpty()) {
            response.headers = response.headers.toMutableMap().apply {
                put(
                    HttpClient.Params.REQUEST_HEADER_REFERER,
                    listOf(
                        request.headers.getOrDefault(
                            HttpClient.Params.REQUEST_HEADER_REFERER,
                            ignoreCase = true,
                            ""
                        )
                    )
                )
            }
        }
    }

    private fun updateTaskStep(
        result: RequestResult,
        currentStep: Int,
        httpRequest: Request
    ) {
        if (result.proceedTask) {
            result.httpResponse?.let { response ->
                extractResponseVariableToCache(action, httpRequest, response)
                val nextStep = action.next.httpGetNextStepIndex(
                    httpRequest, response, currentStep
                )
                taskConfig.currentStep = nextStep
            } ?: run {
                taskConfig.currentStep = currentStep + 1
            }
        } else {
            taskConfig.currentStep = Int.MAX_VALUE
        }
    }

    private fun handleException(
        e: Exception,
        actionExecList: MutableList<ActionExec>,
        currentStep: Int
    ) {
        val actionExec = genExceptionActionExec(
            action, ERROR_CODE_HTTP_ACTION_EXEC_FAILED, Log.getStackTraceString(e)
        )
        actionExecList += actionExec
        
        taskConfig.currentStep = if (action.skipError) {
            currentStep + 1
        } else {
            Int.MAX_VALUE
        }
    }

    // ==================== ActionExec 生成 ====================

    private fun Request.genActionExec(
        httpResponse: Response?,
        redirectCount: Int
    ): ActionExec {
        val actionExec = ActionExec(
            step = taskConfig.currentStep,
            index = redirectCount,
            time = System.currentTimeMillis(),
            url = url,
            method = method?.value ?: "GET",
            reqHeader = headers.toJsonString1()
        )

        if (body.isNotEmpty()) {
            actionExec.reqData = String(body)
        }

        httpResponse?.let { response ->
            saveCookiesFromResponse(response, url)
            fillResponseData(actionExec, response)
        }
        
        return actionExec
    }

    private fun saveCookiesFromResponse(response: Response, url:String) {
        if (response.headers.isEmpty()) return
        
        runCatching {
            URL(url).apply {
                val uri = URI(protocol, host, path, query, null)
                taskConfig.cookieManager.put(uri, response.headers)
            }
        }.onFailure {
            LogUtils.error(throwable = it)
        }
    }

    private fun fillResponseData(actionExec: ActionExec, response: Response) {
        if (response.headers.isNotEmpty()) {
            actionExec.respHeader = response.headers.toJsonString()
        }
        
        actionExec.respCode = response.code
        
        if (response.data.isNotEmpty()) {
            actionExec.respData = String(response.data)
        }
        
        actionExec.cost = response.endTime - response.startTime
    }

    // ==================== 异步请求处理 ====================

    private fun Request.makeAsyncRequest() = scope.launch {
        var request = copy()
        var response = request.call()
        var stepCallHttpCount = 0
        var redirectUrl = getRedirectUrl(response)
        
        while (shouldContinueRedirect(response, redirectUrl, stepCallHttpCount)) {
            stepCallHttpCount++
            
            runCatching {
                request = request.buildRedirectHttpRequest(redirectUrl!!, request.url)
                response = request.call()
                redirectUrl = getRedirectUrl(response)
            }.onFailure {
                LogUtils.error(throwable = it)
                return@launch
            }
        }
    }

    // ==================== URL 处理 ====================

    private fun String.isHttpRedirect(): Boolean {
        return HTTP_REDIRECT_PATTERN.find(this)?.let {
            startsWith("http", ignoreCase = true)
        } ?: true
    }

    private fun HttpActionRequest.buildHttpRequest(): Request = Request(
        url = url,
        method = method,
        body = data.toByteArray(),
        headers = headers.nameValueToMap()
    )

    private fun genWholeResponse(httpRequest: Request, httpResponse: Response?): String {
        val responseData = httpResponse?.data?.takeIf { it.isNotEmpty() }?.let { 
            String(it) 
        } ?: ""
        
        val responseHeaders = httpResponse?.headers?.takeIf { it.isNotEmpty() }?.toJsonString() ?: ""
        
        return "[${httpRequest.url}]$responseData[$responseHeaders]"
    }

    // ==================== 步骤控制 ====================

    private fun List<Next>.httpGetNextStepIndex(
        httpRequest: Request,
        httpResponse: Response?,
        currentStep: Int
    ): Int {
        val wholeResponse = genWholeResponse(httpRequest, httpResponse)
        return getNextStepIndex(wholeResponse, currentStep)
    }

    // ==================== 变量提取 ====================

    private fun extractResponseVariableToCache(
        action: BaseAction.HttpAction,
        httpRequest: Request,
        httpResponse: Response
    ) {
        val actionResponse = action.response ?: return
        val responseHeaders = httpResponse.headers
        
        extractCookieVariableToCache(actionResponse.cookies, responseHeaders)
        extractHeaderVariableToCache(actionResponse.headers, responseHeaders)
        extractBodyVariableToCache(
            action,
            genWholeResponse(httpRequest, httpResponse),
            httpResponse.data
        )
    }

    private fun extractCookieVariableToCache(
        cookies: List<NameVariable>,
        responseHeaders: Map<String, List<String>>
    ) {
        if (cookies.isEmpty()) return
        
        runCatching {
            val cookieList = responseHeaders.get(
                HttpClient.Params.RESPONSE_HEADER_SET_COOKIE,
                ignoreCase = true
            ) ?: return
            
            cookies.forEach { nameVariable ->
                cookieList.forEach { cookie ->
                    parseCookieValue(cookie, nameVariable.name)?.let { value ->
                        taskConfig.variableCache[nameVariable.variable] = value
                    }
                }
            }
        }.onFailure {
            LogUtils.error(throwable = it)
        }
    }

    private fun parseCookieValue(cookie: String, targetName: String): String? {
        val cookieValues = cookie.split(";")
        cookieValues.forEach { cookieValue ->
            val keyPair = cookieValue.split("=", limit = 2)
            val key = keyPair.first().trim()
            val value = keyPair.getOrElse(1) { "" }.trim()
            
            if (key == targetName) {
                return value
            }
        }
        return null
    }

    private fun extractHeaderVariableToCache(
        headers: List<NameVariable>,
        responseHeaders: Map<String, List<String>>
    ) {
        if (headers.isEmpty() || responseHeaders.isEmpty()) return
        
        headers.forEach { nameVariable ->
            responseHeaders[nameVariable.name]?.firstOrNull()?.let { value ->
                taskConfig.variableCache[nameVariable.variable] = value
            }
        }
    }

    // ==================== 请求构建 ====================

    private fun amendActionRequest(actionRequest: HttpActionRequest) {
        // 替换变量
        actionRequest.headers.replaceVariableData()
        actionRequest.cookies.replaceVariableData()
        actionRequest.params.replaceVariableData()
        if (actionRequest.data.isNotBlank()) {
            actionRequest.data = actionRequest.data.toVariableData()
        }
        
        // 添加基础 Header
        actionRequest.headers = actionRequest.headers.amendBaseHeader(true).toMutableList()
        
        // 处理 URL
        actionRequest.url = when (actionRequest.method) {
            HttpMethod.Get -> buildGetUrl(actionRequest)
            else -> actionRequest.url.toVariableData()
        }
        
        // 添加 Sec-CH-UA Header (HTTPS)
        if (actionRequest.url.isHttps()) {
            actionRequest.headers = actionRequest.headers.addSecChUa()
        }
        
        // 处理 Cookie
        actionRequest.amendCookie()
        
        // 处理 POST 数据
        if (actionRequest.method != HttpMethod.Get) {
            val sendData = actionRequest.genPostData()
            if (sendData.isNotEmpty()) {
                actionRequest.data = String(sendData)
            }
        }
    }

    private fun buildGetUrl(actionRequest: HttpActionRequest): String {
        val baseUrl = actionRequest.url.toVariableData()
        return baseUrl.toUri().buildUpon().apply {
            actionRequest.params.forEach { nameValue ->
                appendQueryParameter(nameValue.name, nameValue.value)
            }
        }.build().toString()
    }

    private fun HttpActionRequest.amendCookie() {
        val cookies = mutableSetOf<NameValue>()
        
        // 从 CookieManager 获取 Cookie
        if (autoCookie) {
            cookies += cookieFromCookieManager(url)
        }
        
        // 添加手动指定的 Cookie（覆盖同名 Cookie）
        this.cookies.forEach {
            cookies.remove(it)
            cookies += it
        }
        
        // 构建 Cookie Header
        if (cookies.isNotEmpty()) {
            headers += cookies.toList().buildCookie()
        }
    }

    private fun HttpActionRequest.genPostData(): ByteArray {
        // 优先使用 params（form-data）
        if (params.isNotEmpty()) {
            return params.joinToString("&") {
                "${it.name.urlEncode()}=${it.value.urlEncode()}"
            }.toByteArray()
        }
        
        // 否则使用 data（raw data）
        if (data.isNotBlank()) {
            return data.toByteArray(Charsets.UTF_8)
        }
        
        return byteArrayOf()
    }

    // ==================== 重定向请求构建 ====================

    private fun Request.buildRedirectHttpRequest(
        redirectUrl: String,
        originUrl: String
    ): Request {
        val headers = genBaseHeaderMap().toMutableMap()
        headers[HttpClient.Params.REQUEST_HEADER_REFERER] = originUrl
        
        val normalizedUrl = URL(URL(originUrl), redirectUrl.replace(" ", "%20")).toString()
        
        // 添加 Cookie
        val cookies = cookieFromCookieManager(normalizedUrl)
        if (cookies.isNotEmpty()) {
            cookies.toList().buildCookie().let { cookie ->
                headers[cookie.name] = cookie.value
            }
        }
        
        // 添加 Sec-CH-UA Header (HTTPS)
        if (normalizedUrl.isHttps()) {
            mutableListOf<NameValue>().addSecChUa().forEach {
                headers[it.name] = it.value
            }
        }
        
        return Request(
            url = normalizedUrl,
            method = HttpMethod.Get,
            headers = headers
        )
    }
}

// ==================== Map 扩展函数 ====================

fun <V> Map<String, V>.get(key: String, ignoreCase: Boolean): V? {
    return entries.firstOrNull {
        it.key.equals(key, ignoreCase = ignoreCase)
    }?.value
}

fun <V> Map<String, V>.getOrDefault(key: String, ignoreCase:Boolean, defaultValue:V): V =
    this.get(key, ignoreCase) ?: defaultValue


fun String.toUri():Uri = Uri.parse(this)