package com.narutohuo.xindazhou.common.dialog

import android.app.Activity
import android.app.AlertDialog
import android.app.Dialog
import android.content.Context
import android.graphics.Color
import android.graphics.drawable.ColorDrawable
import android.view.Gravity
import android.view.View
import android.view.ViewGroup
import android.view.Window
import android.widget.EditText
import android.widget.LinearLayout
import android.widget.TextView
import androidx.fragment.app.Fragment
import com.narutohuo.xindazhou.common.ui.MessageHelper

/**
 * 对话框管理器
 * 
 * 统一封装常用对话框，提供简洁美观的对话框体验（参考现代移动端设计风格）
 * 
 * 使用方式：
 * ```kotlin
 * // 简单提示（只有一个确定按钮）
 * DialogHelper.showAlert(context, "提示", "这是一个提示框")
 * 
 * // 确认对话框
 * DialogHelper.showConfirm(context, "确认", "确定要删除吗？") {
 *     // 确认操作
 * }
 * 
 * // 输入对话框
 * DialogHelper.showInput(context, "输入", "请输入用户名") { input ->
 *     // 处理输入
 * }
 * 
 * // 列表选择对话框
 * DialogHelper.showList(context, "选择", listOf("选项1", "选项2")) { index, item ->
 *     // 处理选择
 * }
 * ```
 */
object DialogHelper {
    
    /**
     * 显示提示框（只有一个确定按钮）
     * 
     * @param context 上下文
     * @param title 标题（可选）
     * @param message 消息内容
     * @param confirmText 确认按钮文本（默认"确定"）
     * @param onConfirm 确认回调（可选）
     * @return Dialog 实例
     */
    fun showAlert(
        context: Context,
        title: String? = null,
        message: String,
        confirmText: String = "确定",
        onConfirm: (() -> Unit)? = null
    ): Dialog {
        return createConfirmDialog(context, title, message, confirmText, null, onConfirm, null)
    }
    
    /**
     * 显示确认对话框（有确定和取消按钮）
     * 
     * @param context 上下文
     * @param title 标题（可选）
     * @param message 消息内容
     * @param confirmText 确认按钮文本（默认"确定"）
     * @param cancelText 取消按钮文本（默认"取消"）
     * @param onConfirm 确认回调
     * @param onCancel 取消回调（可选）
     * @return Dialog 实例
     */
    fun showConfirm(
        context: Context,
        title: String? = null,
        message: String,
        confirmText: String = "确定",
        cancelText: String = "取消",
        onConfirm: () -> Unit,
        onCancel: (() -> Unit)? = null
    ): Dialog {
        return createConfirmDialog(context, title, message, confirmText, cancelText, onConfirm, onCancel)
            }
    
    /**
     * 显示提示框（Activity 扩展函数）
     */
    fun Activity.showAlert(
        title: String? = null,
        message: String,
        confirmText: String = "确定",
        onConfirm: (() -> Unit)? = null
    ): Dialog {
        return showAlert(this, title, message, confirmText, onConfirm)
    }
    
    /**
     * 显示确认对话框（Activity 扩展函数）
     */
    fun Activity.showConfirm(
        title: String? = null,
        message: String,
        confirmText: String = "确定",
        cancelText: String = "取消",
        onConfirm: () -> Unit,
        onCancel: (() -> Unit)? = null
    ): Dialog {
        return showConfirm(this, title, message, confirmText, cancelText, onConfirm, onCancel)
    }
    
    /**
     * 显示提示框（Fragment 扩展函数）
     */
    fun Fragment.showAlert(
        title: String? = null,
        message: String,
        confirmText: String = "确定",
        onConfirm: (() -> Unit)? = null
    ): Dialog {
        return showAlert(requireContext(), title, message, confirmText, onConfirm)
    }
    
    /**
     * 显示确认对话框（Fragment 扩展函数）
     */
    fun Fragment.showConfirm(
        title: String? = null,
        message: String,
        confirmText: String = "确定",
        cancelText: String = "取消",
        onConfirm: () -> Unit,
        onCancel: (() -> Unit)? = null
    ): Dialog {
        return showConfirm(requireContext(), title, message, confirmText, cancelText, onConfirm, onCancel)
    }
    
    /**
     * 显示输入对话框
     * 
     * @param context 上下文
     * @param title 标题
     * @param hint 输入框提示文本
     * @param defaultText 默认文本（可选）
     * @param confirmText 确认按钮文本（默认"确定"）
     * @param cancelText 取消按钮文本（默认"取消"）
     * @param onConfirm 确认回调（参数为输入的内容）
     * @param onCancel 取消回调（可选）
     */
    fun showInput(
        context: Context,
        title: String,
        hint: String = "",
        defaultText: String = "",
        confirmText: String = "确定",
        cancelText: String = "取消",
        onConfirm: (String) -> Unit,
        onCancel: (() -> Unit)? = null
    ) {
        val editText = EditText(context)
        editText.hint = hint
        editText.setText(defaultText)
        
        AlertDialog.Builder(context)
            .setTitle(title)
            .setView(editText)
            .setPositiveButton(confirmText) { _, _ ->
                val input = editText.text.toString().trim()
                if (input.isNotEmpty()) {
                    onConfirm(input)
                } else {
                    MessageHelper.showToast(editText, "输入不能为空")
                }
            }
            .setNegativeButton(cancelText) { _, _ ->
                onCancel?.invoke()
            }
            .setCancelable(true)
            .show()
    }
    
    /**
     * 显示输入对话框（Activity 扩展函数）
     */
    fun Activity.showInput(
        title: String,
        hint: String = "",
        defaultText: String = "",
        confirmText: String = "确定",
        cancelText: String = "取消",
        onConfirm: (String) -> Unit,
        onCancel: (() -> Unit)? = null
    ) {
        showInput(this, title, hint, defaultText, confirmText, cancelText, onConfirm, onCancel)
    }
    
    /**
     * 显示输入对话框（Fragment 扩展函数）
     */
    fun Fragment.showInput(
        title: String,
        hint: String = "",
        defaultText: String = "",
        confirmText: String = "确定",
        cancelText: String = "取消",
        onConfirm: (String) -> Unit,
        onCancel: (() -> Unit)? = null
    ) {
        requireContext().let {
            showInput(it, title, hint, defaultText, confirmText, cancelText, onConfirm, onCancel)
        }
    }
    
    /**
     * 显示列表选择对话框
     * 
     * @param context 上下文
     * @param title 标题
     * @param items 列表项
     * @param onSelect 选择回调（参数为索引和选中项）
     */
    fun showList(
        context: Context,
        title: String,
        items: List<String>,
        onSelect: (Int, String) -> Unit
    ) {
        AlertDialog.Builder(context)
            .setTitle(title)
            .setItems(items.toTypedArray()) { _, which ->
                onSelect(which, items[which])
            }
            .setCancelable(true)
            .show()
    }
    
    /**
     * 显示列表选择对话框（Activity 扩展函数）
     */
    fun Activity.showList(
        title: String,
        items: List<String>,
        onSelect: (Int, String) -> Unit
    ) {
        showList(this, title, items, onSelect)
    }
    
    /**
     * 显示列表选择对话框（Fragment 扩展函数）
     */
    fun Fragment.showList(
        title: String,
        items: List<String>,
        onSelect: (Int, String) -> Unit
    ) {
        requireContext().let {
            showList(it, title, items, onSelect)
        }
    }
    
    /**
     * 显示加载对话框（简单实现，可扩展）
     * 
     * @param context 上下文
     * @return AlertDialog 实例，用于后续关闭
     */
    fun showLoading(context: Context): AlertDialog {
        return AlertDialog.Builder(context)
            .setMessage("加载中...")
            .setCancelable(false)
            .show()
    }
    
    /**
     * 显示加载对话框（Activity 扩展函数）
     */
    fun Activity.showLoading(): AlertDialog {
        return showLoading(this)
    }
    
    /**
     * 显示加载对话框（Fragment 扩展函数）
     */
    fun Fragment.showLoading(): AlertDialog {
        return requireContext().let { showLoading(it) }
    }
    
    // ==================== 私有方法 ====================
    
    /**
     * 创建确认对话框（使用圆角、居中、简洁的样式）
     */
    private fun createConfirmDialog(
        context: Context,
        title: String?,
        message: String,
        confirmText: String,
        cancelText: String?,
        onConfirm: (() -> Unit)?,
        onCancel: (() -> Unit)?
    ): Dialog {
        val dialog = Dialog(context)
        dialog.requestWindowFeature(Window.FEATURE_NO_TITLE)
        dialog.window?.apply {
            setBackgroundDrawable(ColorDrawable(Color.TRANSPARENT))
            setLayout(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
        }
        
        // 创建主容器
        val container = LinearLayout(context).apply {
            orientation = LinearLayout.VERTICAL
            // 设置圆角背景
            background = createRoundRectDrawable(context, 14f)
            layoutParams = LinearLayout.LayoutParams(
                ViewGroup.LayoutParams.MATCH_PARENT,
                ViewGroup.LayoutParams.WRAP_CONTENT
            ).apply {
                setMargins(dpToPx(context, 40f), 0, dpToPx(context, 40f), 0)
            }
        }
        
        // 标题
        if (!title.isNullOrEmpty()) {
            val titleView = TextView(context).apply {
                text = title
                textSize = 17f
                setTextColor(Color.parseColor("#000000"))
                gravity = Gravity.CENTER
                setPadding(0, dpToPx(context, 20f), 0, dpToPx(context, 12f))
            }
            container.addView(titleView)
        }
        
        // 消息内容
        val messageView = TextView(context).apply {
            text = message
            textSize = 13f
            setTextColor(Color.parseColor("#000000"))
            gravity = Gravity.CENTER
            setPadding(dpToPx(context, 20f), 0, dpToPx(context, 20f), dpToPx(context, 20f))
        }
        container.addView(messageView)
        
        // 按钮容器
        val buttonContainer = LinearLayout(context).apply {
            orientation = LinearLayout.HORIZONTAL
            if (cancelText != null) {
                // 有取消按钮时，添加分隔线
                val divider = View(context).apply {
                    layoutParams = LinearLayout.LayoutParams(
                        dpToPx(context, 1f),
                        ViewGroup.LayoutParams.MATCH_PARENT
                    )
                    setBackgroundColor(Color.parseColor("#D1D1D6"))
                }
                addView(divider)
            }
        }
        
        // 取消按钮
        if (cancelText != null) {
            val cancelButton = createButton(context, cancelText, Color.parseColor("#007AFF"), false) {
                dialog.dismiss()
                onCancel?.invoke()
            }
            buttonContainer.addView(cancelButton, LinearLayout.LayoutParams(
                0,
                dpToPx(context, 44f),
                1f
            ))
        }
        
        // 确定按钮
        val confirmButton = createButton(context, confirmText, Color.parseColor("#007AFF"), cancelText == null) {
            dialog.dismiss()
            onConfirm?.invoke()
        }
        buttonContainer.addView(confirmButton, LinearLayout.LayoutParams(
            0,
            dpToPx(context, 44f),
            1f
        ))
        
        container.addView(buttonContainer)
        
        dialog.setContentView(container)
        dialog.setCancelable(true)
        dialog.setCanceledOnTouchOutside(true)
        dialog.show()
        
        return dialog
    }
    
    /**
     * 创建按钮
     */
    private fun createButton(
        context: Context,
        text: String,
        textColor: Int,
        isBold: Boolean,
        onClick: () -> Unit
    ): TextView {
        return TextView(context).apply {
            this.text = text
            this.setTextColor(textColor)
            textSize = 17f
            if (isBold) {
                setTypeface(null, android.graphics.Typeface.BOLD)
            }
            gravity = Gravity.CENTER
            setOnClickListener { onClick() }
            setBackgroundResource(android.R.drawable.list_selector_background)
        }
    }
    
    /**
     * 创建圆角背景
     */
    private fun createRoundRectDrawable(context: Context, radius: Float): android.graphics.drawable.GradientDrawable {
        return android.graphics.drawable.GradientDrawable().apply {
            setColor(Color.WHITE)
            cornerRadius = radius * context.resources.displayMetrics.density
        }
    }
    
    /**
     * dp 转 px
     */
    private fun dpToPx(context: Context, dp: Float): Int {
        val density = context.resources.displayMetrics.density
        return (dp * density + 0.5f).toInt()
    }
}
