@file:Suppress("DEPRECATION")

package com.brickmodule

import com.facebook.react.TurboReactPackage
import com.facebook.react.bridge.NativeModule
import com.facebook.react.bridge.ReactApplicationContext
import com.facebook.react.bridge.ReactContext
import com.facebook.react.module.model.ReactModuleInfo
import com.facebook.react.module.model.ReactModuleInfoProvider
import android.util.Log
import java.util.HashMap

class BrickModulePackage : TurboReactPackage() {

    init {
        Log.d(TAG, "BrickModulePackage initialized")
    }

    override fun getModule(
            name: String,
            reactContext: ReactApplicationContext,
    ): NativeModule? {
        Log.d(TAG, "getModule called with name: $name")
        return if (name == "BrickModule") {
            // Try to find the generated BrickModule class
            try {
                // Try with app's class loader first
                val classLoader = reactContext.applicationContext.classLoader
                val generatedClass =
                        Class.forName("com.brickmodule.codegen.BrickModule", true, classLoader)
                val constructor = generatedClass.getConstructor(ReactContext::class.java)
                val instance = constructor.newInstance(reactContext) as NativeModule
                Log.d(TAG, "BrickModule successfully created: ${instance.javaClass.name}")
                Log.d(TAG, "BrickModule ${instance.javaClass.methods.map { it.name }}")
                instance
            } catch (e: ClassNotFoundException) {
                // Try with current thread class loader as fallback
                try {
                    val currentClassLoader = Thread.currentThread().contextClassLoader
                    val generatedClass =
                            Class.forName("com.brickmodule.BrickModule", true, currentClassLoader)
                    val constructor = generatedClass.getConstructor(ReactContext::class.java)
                    val instance = constructor.newInstance(reactContext) as NativeModule
                    Log.d(
                        TAG,
                        "BrickModule successfully created with thread classloader: ${instance.javaClass.name}"
                    )
                    instance
                } catch (e2: Exception) {
                    e.printStackTrace()
                    e2.printStackTrace()
                    throw RuntimeException(
                            "BrickModule not found in any classloader. Please run 'brick-codegen' to generate the bridge code. " +
                                    "The generated BrickModule.kt should be in your app's source directory. " +
                                    "Original error: ${e.message}, Fallback error: ${e2.message}"
                    )
                }
            } catch (e: Exception) {
                e.printStackTrace()
                throw RuntimeException("Failed to create BrickModule instance: ${e.message}", e)
            }
        } else {
            null
        }
    }

    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
        Log.d(TAG, "getReactModuleInfoProvider called")
        val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
        // Force TurboModule to true since we're using NativeBrickModuleSpec
        val isTurboModule: Boolean = true
        moduleInfos["BrickModule"] =
                ReactModuleInfo(
                        "BrickModule",
                        "com.brickmodule.codegen.BrickModule",
                        false, // canOverrideExistingModule
                        false, // needsEagerInit
                        true, // hasConstants
                        false, // isCxxModule
                        isTurboModule, // isTurboModule
                )
        moduleInfos
    }

    companion object {
        private const val TAG = "BrickModulePackage"
        const val NAME = "BrickModulePackage"
    }
}