package com.lukouguoji.module_base.ui.weight.search.layout.manager

import android.text.Editable
import android.text.TextWatcher
import android.widget.EditText
import androidx.lifecycle.ViewTreeLifecycleOwner
import androidx.lifecycle.lifecycleScope
import com.alibaba.fastjson.JSONArray
import com.lukouguoji.module_base.http.net.NetApply
import com.lukouguoji.module_base.ktx.getActivity
import com.lukouguoji.module_base.ktx.launchCollect
import com.lukouguoji.module_base.ktx.toJson
import com.lukouguoji.module_base.ktx.toRequestBody
import com.lukouguoji.module_base.ui.weight.data.layout.AutoQueryConfig
import com.lukouguoji.module_base.util.Common
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Job
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch

/**
 * 搜索框专用自动查询管理器
 * 负责处理输入监听、防抖、查询请求、结果处理
 *
 * 功能：
 * 1. 监听 EditText 输入变化
 * 2. 防抖延迟（避免频繁请求）
 * 3. 防重复查询（相同值不重复请求）
 * 4. 调用接口查询数据
 * 5. 处理查询结果（单条填充、多条弹框）
 * 6. 自动管理协程生命周期
 */
class SearchAutoQueryManager(
    private val editText: EditText,
    private val config: AutoQueryConfig,
    private val onValueSelected: (String) -> Unit
) {

    /** 协程作用域（从 ViewTree 获取） */
    private var scope: CoroutineScope? = null

    /** 上次查询的值（防重复查询） */
    private var lastQueriedValue: String = ""

    /** 防抖任务 */
    private var debounceJob: Job? = null

    /** 文本监听器 */
    private var textWatcher: TextWatcher? = null

    /**
     * 绑定到视图（添加文本监听）
     */
    fun attach() {
        // 获取协程作用域（从 ViewTree 获取 LifecycleOwner）
        val lifecycleOwner = ViewTreeLifecycleOwner.get(editText)
        if (lifecycleOwner == null) {
            // 延迟绑定（等待 ViewTree 附加）
            editText.post { attach() }
            return
        }
        scope = lifecycleOwner.lifecycleScope

        // 添加文本监听
        textWatcher = object : TextWatcher {
            override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
            override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}

            override fun afterTextChanged(s: Editable?) {
                val text = s?.toString() ?: ""
                handleTextChanged(text)
            }
        }

        editText.addTextChangedListener(textWatcher)
    }

    /**
     * 解绑（移除监听、取消协程）
     */
    fun detach() {
        textWatcher?.let { editText.removeTextChangedListener(it) }
        textWatcher = null
        debounceJob?.cancel()
        debounceJob = null
        scope = null
    }

    /**
     * 处理文本变化
     */
    private fun handleTextChanged(text: String) {
        val trimmedText = text.trim()
        val length = trimmedText.length

        // 取消之前的防抖任务
        debounceJob?.cancel()

        // 判断是否需要触发查询
        if (length in config.minLength..config.maxLength) {
            // 防抖延迟
            debounceJob = scope?.launch {
                delay(config.debounceMillis)
                performQuery(trimmedText)
            }
        } else {
            // 长度不符合，清空上次查询记录
            lastQueriedValue = ""
        }
    }

    /**
     * 执行查询
     */
    private fun performQuery(value: String) {
        // 防重复查询
        if (value == lastQueriedValue) {
            return
        }
        lastQueriedValue = value

        // 构建查询参数（合并额外参数）
        val baseParams = mutableMapOf<String, Any?>(config.paramKey to value)
        config.extraParamsProvider?.invoke()?.forEach { (key, v) ->
            if (!v.isNullOrEmpty()) baseParams[key] = v
        }
        val params = baseParams.toRequestBody()

        // 发起网络请求
        scope?.launchCollect({ NetApply.api.getWbNoList(config.url, params) }) {
            onSuccess = { result ->
                val results = result.data ?: emptyList()
                handleQueryResults(results)
            }
            onFailed = { code, msg ->
                // 查询失败，清空记录（允许重试）
                lastQueriedValue = ""
            }
        }
    }

    /**
     * 处理查询结果
     */
    private fun handleQueryResults(results: List<String>) {
        when {
            // 1 条结果：直接填充
            results.size == 1 -> {
                onValueSelected(results[0])
            }

            // 多条结果：显示弹框选择
            results.size > 1 -> {
                showSelectionDialog(results)
            }

            // 0 条结果：不做处理
            else -> {
                // 可选：showToast("未找到匹配数据")
            }
        }
    }

    /**
     * 显示选择弹框
     */
    private fun showSelectionDialog(results: List<String>) {
        val activity = editText.context.getActivity()

        // 转换为 Common.singleSelect 需要的格式
        val jsonArray = JSONArray.parseArray(
            results.map { mapOf("name" to it, "code" to it) }.toJson(false)
        )

        Common.singleSelect(
            activity,
            config.title,
            jsonArray,
            null
        ) { position, _ ->
            // 用户选择后更新值
            onValueSelected(results[position])
        }
    }
}
