package com.brickmodule

import android.util.Log
import com.facebook.react.bridge.ReactContext
import java.util.concurrent.ConcurrentHashMap

/**
 * Registry for Brick modules - instance-based approach Each BrickActivity maintains its own
 * registry instance
 */
class BrickModuleRegistry {
    // Simple module storage - no context tracking needed
    private val modules: ConcurrentHashMap<String, BrickModuleBase> = ConcurrentHashMap()
    private var isRegistered: Boolean = false

    /**
     * Registers an array of Brick modules Each module must implement their respective Spec
     * interface
     *
     * @param modules List of module instances to register
     */
    @Synchronized
    fun register(modules: List<BrickModuleBase>) {
        modules.forEach { module -> registerSingleModule(module) }
        isRegistered = true
        Log.d(
            TAG,
            "Successfully registered ${modules.size} modules (total: ${this.modules.size})"
        )
    }

    /**
     * Registers a single module (push-style registration) Useful for manual module registration or
     * testing
     *
     * @param module The module instance to register
     */
    @Synchronized
    fun push(module: BrickModuleBase) {
        registerSingleModule(module)
        Log.d(TAG, "Module pushed successfully (total: ${modules.size})")
    }

    private fun registerSingleModule(module: BrickModuleBase) {
        val moduleName = module.moduleName
        if (moduleName.isEmpty()) {
            Log.e(TAG, "Module has empty moduleName")
            return
        }

        // Register or update the module
        val isUpdate = modules.containsKey(moduleName)
        modules[moduleName] = module

        if (isUpdate) {
            Log.d(TAG, "Module '$moduleName' updated (replaced existing)")
        } else {
            Log.d(TAG, "Registered module '$moduleName'")
        }
    }

    /**
     * Returns the actual module instance for reflection-based method calls Used by BrickModuleImpl
     * for direct protocol casting
     *
     * @param moduleName The name of the module to retrieve
     */
    fun getModuleInstance(moduleName: String): BrickModuleBase? {
        return modules[moduleName]
    }

    /** Returns list of registered module names */
    fun getRegisteredModules(): List<String> {
        return modules.keys.toList().sorted()
    }

    // No DeviceEventEmitter-based event path; events handled via RN Codegen EventEmitter

    /** Returns all constants from registered modules */
    fun getAllConstants(): Map<String, Any> {
        val allConstants = mutableMapOf<String, Any>()

        // Create a snapshot to avoid concurrent modification
        val moduleSnapshot = modules.toMap()
        moduleSnapshot.forEach { (moduleName, module) ->
            try {
                // Get constants directly from BrickModuleBase
                allConstants[moduleName] = module.getConstants()
            } catch (e: Exception) {
                Log.e(
                    TAG,
                    "Failed to get constants for $moduleName: ${e.message}",
                    e
                )
            }
        }

        return allConstants
    }

    /**
     * Unregisters all modules. This should be called when the activity is destroyed to prevent
     * memory leaks.
     */
    @Synchronized
    fun unregister() {
        val count = modules.size

        // Clear all modules
        modules.clear()
        isRegistered = false

        Log.d(TAG, "Unregistered $count modules")
    }

    /** Clears all registered modules (for testing purposes only) */
    @Synchronized
    fun clearRegistry() {
        modules.clear()
        isRegistered = false
        Log.d(TAG, "Registry cleared")
    }
    
    companion object {
        private const val TAG = "BrickModuleRegistry"
    }
}