package com.hikoncont.util

import android.content.Context
import android.util.Log
import org.json.JSONObject
import java.io.IOException

/**
 * 配置文件读取工具类
 * 用于读取assets目录下的server_config.json文件
 */
object ConfigReader {
    
    private const val TAG = "ConfigReader"
    private const val CONFIG_FILE_NAME = "server_config.json"
    
    /**
     * 读取server_config.json配置文件
     * 优先读取应用内部存储的配置文件，如果不存在则读取assets目录的默认配置
     * @param context 上下文
     * @return JSONObject配置对象，失败时返回null
     */
    fun readServerConfig(context: Context): JSONObject? {
        return try {
            // 1. 优先读取应用内部存储的配置文件（用户修改过的配置）
            val internalConfigFile = java.io.File(context.filesDir, CONFIG_FILE_NAME)
            if (internalConfigFile.exists()) {
                val jsonString = internalConfigFile.readText()
                val configJson = JSONObject(jsonString)
                
                Log.d(TAG, "✅ 从内部存储读取配置文件: $CONFIG_FILE_NAME")
                Log.d(TAG, "配置内容: $configJson")
                
                return configJson
            }
            
            // 2. 如果内部存储没有配置文件，则读取assets目录的默认配置
            Log.d(TAG, "⚠️ 内部存储配置文件不存在，读取assets默认配置")
            val inputStream = context.assets.open(CONFIG_FILE_NAME)
            val jsonString = inputStream.bufferedReader().use { it.readText() }
            val configJson = JSONObject(jsonString)
            
            Log.d(TAG, "✅ 从assets读取默认配置文件: $CONFIG_FILE_NAME")
            Log.d(TAG, "配置内容: $configJson")
            
            configJson
        } catch (e: IOException) {
            Log.e(TAG, "❌ 读取配置文件失败: $CONFIG_FILE_NAME", e)
            null
        } catch (e: Exception) {
            Log.e(TAG, "❌ 解析配置文件失败: $CONFIG_FILE_NAME", e)
            null
        }
    }
    
    /**
     * 获取Web URL配置
     * @param context 上下文
     * @return Web URL字符串，失败时返回null
     */
    fun getWebUrl(context: Context): String? {
        return try {
            val config = readServerConfig(context)
            val webUrl = config?.optString("webUrl")
            
            if (webUrl.isNullOrBlank()) {
                Log.w(TAG, "配置文件中没有webUrl或为空")
                null
            } else {
                Log.d(TAG, "获取到webUrl: $webUrl")
                webUrl
            }
        } catch (e: Exception) {
            Log.e(TAG, "获取webUrl失败", e)
            null
        }
    }
    
    /**
     * 获取服务器URL配置
     * @param context 上下文
     * @return 服务器URL字符串，失败时返回null
     */
    fun getServerUrl(context: Context): String? {
        return try {
            val config = readServerConfig(context)
            val serverUrl = config?.optString("serverUrl")
            
            if (serverUrl.isNullOrBlank()) {
                Log.w(TAG, "配置文件中没有serverUrl或为空")
                null
            } else {
                Log.d(TAG, "获取到serverUrl: $serverUrl")
                serverUrl
            }
        } catch (e: Exception) {
            Log.e(TAG, "获取serverUrl失败", e)
            null
        }
    }
    
    /**
     * 获取配置项
     * @param context 上下文
     * @param key 配置键
     * @return 配置值，失败时返回null
     */
    fun getConfigValue(context: Context, key: String): String? {
        return try {
            val config = readServerConfig(context)
            val value = config?.optString(key)
            
            if (value.isNullOrBlank()) {
                Log.w(TAG, "配置文件中没有${key}或为空")
                null
            } else {
                Log.d(TAG, "获取到${key}: $value")
                value
            }
        } catch (e: Exception) {
            Log.e(TAG, "获取配置项${key}失败", e)
            null
        }
    }
    
    /**
     * 检查配置文件是否存在
     * 优先检查内部存储，然后检查assets目录
     * @param context 上下文
     * @return 是否存在
     */
    fun isConfigFileExists(context: Context): Boolean {
        return try {
            // 1. 检查内部存储的配置文件
            val internalConfigFile = java.io.File(context.filesDir, CONFIG_FILE_NAME)
            if (internalConfigFile.exists()) {
                Log.d(TAG, "✅ 内部存储配置文件存在: $CONFIG_FILE_NAME")
                return true
            }
            
            // 2. 检查assets目录的配置文件
            context.assets.open(CONFIG_FILE_NAME).use { true }
        } catch (e: Exception) {
            Log.w(TAG, "❌ 配置文件不存在: $CONFIG_FILE_NAME")
            false
        }
    }
    
    /**
     * 获取配置文件路径信息
     * @param context 上下文
     * @return 配置文件路径信息
     */
    fun getConfigFileInfo(context: Context): Map<String, Any> {
        val internalConfigFile = java.io.File(context.filesDir, CONFIG_FILE_NAME)
        val assetsExists = try {
            context.assets.open(CONFIG_FILE_NAME).use { true }
        } catch (e: Exception) {
            false
        }
        
        return mapOf(
            "internalStorageExists" to internalConfigFile.exists(),
            "internalStoragePath" to internalConfigFile.absolutePath,
            "assetsExists" to assetsExists,
            "lastModified" to if (internalConfigFile.exists()) internalConfigFile.lastModified() else 0L,
            "fileSize" to if (internalConfigFile.exists()) internalConfigFile.length() else 0L
        )
    }
}
