package com.rnthermalprinter.discovery

import android.app.Activity
import android.bluetooth.BluetoothAdapter
import android.bluetooth.BluetoothManager
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import com.facebook.react.bridge.*
import com.facebook.react.modules.core.DeviceEventManagerModule
import java.util.UUID

/**
 * Bluetooth State Manager - manages Bluetooth state and enable requests Based on
 * react-native-zywell-thermal-printer implementation
 */
class BluetoothStateManager(private val reactContext: ReactApplicationContext) {

    companion object {
        const val EVENT_STATE_CHANGED = "BluetoothStateChanged"
        private const val REQUEST_ENABLE_BT = 795
    }

    private val bluetoothAdapter: BluetoothAdapter? by lazy {
        val manager = reactContext.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager
        manager?.adapter
    }

    private var bluetoothStateReceiver: BroadcastReceiver? = null
    private var enablePromise: Promise? = null

    /** Get current Bluetooth state */
    fun getState(promise: Promise) {
        try {
            if (bluetoothAdapter == null) {
                promise.resolve("Unsupported")
                return
            }

            val adapter = bluetoothAdapter
            if (adapter == null) {
                promise.resolve("Unsupported")
                return
            }
            val state = getBluetoothStateString(adapter.state)
            promise.resolve(state)
        } catch (e: Exception) {
            promise.reject("ERROR_GET_STATE", "Failed to get bluetooth state", e)
        }
    }

    /** Start listening for Bluetooth state changes */
    fun startListening() {
        startListenForBluetoothStateChange()
    }

    /** Stop listening for Bluetooth state changes */
    fun stopListening() {
        stopListenForBluetoothStateChange()
    }

    /** Request to enable Bluetooth */
    fun requestToEnable(promise: Promise) {
        try {
            if (bluetoothAdapter == null) {
                promise.reject("ERROR_NO_ADAPTER", "Bluetooth adapter not available")
                return
            }

            val adapter = bluetoothAdapter
            if (adapter == null) {
                promise.reject("ERROR_NO_ADAPTER", "Bluetooth adapter not available")
                return
            }

            if (adapter.isEnabled) {
                promise.resolve("Bluetooth is already enabled")
                return
            }

            val currentActivity = reactContext.currentActivity
            if (currentActivity == null) {
                promise.reject("ERROR_NO_ACTIVITY", "No current activity")
                return
            }

            // Store promise to resolve later
            enablePromise = promise

            // Create activity result listener
            val activityEventListener =
                    object : BaseActivityEventListener() {
                        override fun onActivityResult(
                                activity: Activity,
                                requestCode: Int,
                                resultCode: Int,
                                data: Intent?
                        ) {
                            if (requestCode == REQUEST_ENABLE_BT) {
                                reactContext.removeActivityEventListener(this)

                                when (resultCode) {
                                    Activity.RESULT_OK -> {
                                        enablePromise?.resolve(null)
                                    }
                                    Activity.RESULT_CANCELED -> {
                                        enablePromise?.reject(
                                                "ERROR_CANCELLED",
                                                "The user canceled the action."
                                        )
                                    }
                                    else -> {
                                        enablePromise?.reject("ERROR_UNKNOWN", "Unknown error")
                                    }
                                }
                                enablePromise = null
                            }
                        }
                    }

            reactContext.addActivityEventListener(activityEventListener)

            // Request Bluetooth enable
            val enableBtIntent = Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
            currentActivity.startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT)
        } catch (e: Exception) {
            promise.reject("ERROR_ENABLE", "Failed to enable bluetooth", e)
        }
    }


    /** Convert Bluetooth state to string */
    private fun getBluetoothStateString(state: Int): String {
        return when (state) {
            BluetoothAdapter.STATE_ON -> "PoweredOn"
            BluetoothAdapter.STATE_OFF -> "PoweredOff"
            BluetoothAdapter.STATE_TURNING_ON, BluetoothAdapter.STATE_TURNING_OFF -> "Resetting"
            else -> "Unknown"
        }
    }

    /** Start listening for Bluetooth state changes */
    private fun startListenForBluetoothStateChange() {
        if (bluetoothStateReceiver != null) {
            return // Already listening
        }

        bluetoothStateReceiver =
                object : BroadcastReceiver() {
                    override fun onReceive(context: Context, intent: Intent) {
                        if (intent.action == BluetoothAdapter.ACTION_STATE_CHANGED) {
                            val state =
                                    intent.getIntExtra(
                                            BluetoothAdapter.EXTRA_STATE,
                                            BluetoothAdapter.ERROR
                                    )
                            val stateString = getBluetoothStateString(state)

                            // Send event to JavaScript
                            reactContext
                                    .getJSModule(
                                            DeviceEventManagerModule.RCTDeviceEventEmitter::class
                                                    .java
                                    )
                                    .emit(EVENT_STATE_CHANGED, stateString)
                        }
                    }
                }

        val filter = IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED)
        reactContext.registerReceiver(bluetoothStateReceiver, filter)
    }

    /** Stop listening for Bluetooth state changes */
    private fun stopListenForBluetoothStateChange() {
        bluetoothStateReceiver?.let {
            try {
                reactContext.unregisterReceiver(it)
            } catch (e: IllegalArgumentException) {
                // Receiver already unregistered
            }
            bluetoothStateReceiver = null
        }
    }

    /** Clean up */
    fun onDestroy() {
        stopListenForBluetoothStateChange()
    }
}