package eu.ztsh.garmin

import android.Manifest
import android.annotation.SuppressLint
import android.bluetooth.BluetoothAdapter
import android.bluetooth.BluetoothDevice
import android.bluetooth.BluetoothManager
import android.content.Intent
import android.content.pm.PackageManager
import android.os.Build
import android.os.Bundle
import android.util.Log
import android.view.WindowManager
import android.widget.Toast
import androidx.activity.result.ActivityResultCallback
import androidx.activity.result.contract.ActivityResultContracts.StartActivityForResult
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.lifecycle.DefaultLifecycleObserver
import com.mapbox.navigation.base.options.NavigationOptions
import com.mapbox.navigation.core.MapboxNavigation
import com.mapbox.navigation.core.lifecycle.MapboxNavigationApp
import com.mapbox.navigation.core.lifecycle.MapboxNavigationObserver
import com.mapbox.navigation.core.lifecycle.requireMapboxNavigation
import eu.ztsh.garmin.databinding.ActivityMainBinding
import eu.ztsh.garmin.mapbox.MapControl
import eu.ztsh.garmin.util.PermissionsHelper
import java.lang.ref.WeakReference

@SuppressLint("MissingPermission")
class MainActivity : AppCompatActivity() {

    lateinit var garmin: Garmin

    private lateinit var binding: ActivityMainBinding
    private lateinit var mapControl: MapControl

    private val permissionsHelper = PermissionsHelper(WeakReference(this))

    val mapboxNavigation: MapboxNavigation by requireMapboxNavigation(
        onResumedObserver = object : DefaultLifecycleObserver, MapboxNavigationObserver {
            override fun onAttached(mapboxNavigation: MapboxNavigation) {
                mapControl.onAttached(mapboxNavigation)
            }

            override fun onDetached(mapboxNavigation: MapboxNavigation) {
                mapControl.onDetached(mapboxNavigation)
            }
        },
        onInitialize = fun() {
            mapControl.initNavigation()
        }
    )

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)
        binding.mapView
        permissionsHelper.checkPermissions {
            mapControl = MapControl(this, UI(binding), resources)
            mapControl.init()

            MapboxNavigationApp.setup(
                NavigationOptions.Builder(applicationContext)
                    .build()
            )
        }
        bluetoothInit()
        window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
    }


    override fun onDestroy() {
        super.onDestroy()
        mapControl.onDestroy()
        window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
    }

    private fun bluetoothInit() {
        val bluetoothManager: BluetoothManager = getSystemService(BluetoothManager::class.java)
        val bluetoothAdapter: BluetoothAdapter = bluetoothManager.adapter
            ?: // Device doesn't support Bluetooth
            throw Exception()
        if (!bluetoothAdapter.isEnabled) {
            // TODO: Start intent
            val enableBtIntent = Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
            registerForActivityResult(StartActivityForResult(), ActivityResultCallback { })
        }
        checkBt()

        val pairedDevices: Set<BluetoothDevice>? = bluetoothAdapter.bondedDevices
        val context = this
        pairedDevices?.firstOrNull { device ->
            Log.d(TAG, device.name)
            device.name.equals("GARMIN HUD")
        }?.apply {
            garmin = Garmin(context, this, bluetoothAdapter)
            garmin.start()
        }

    }

    fun checkBt(): Boolean {
        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.S) {
            checkBt(Manifest.permission.BLUETOOTH_SCAN)
            checkBt(Manifest.permission.BLUETOOTH_CONNECT)
        } else {
            checkBt(Manifest.permission.BLUETOOTH)
            checkBt(Manifest.permission.BLUETOOTH_ADMIN)
        }
        return true
    }

    private fun checkBt(permission: String): Boolean {
        if (ActivityCompat.checkSelfPermission(
                this,
                permission
            ) != PackageManager.PERMISSION_GRANTED
        ) {
            ActivityCompat.requestPermissions(this, arrayOf(permission), 1)
        }
        return true
    }

    fun setConnectionStatus(success: Boolean) {
        this.runOnUiThread {
            if (success) {
                Toast.makeText(this, "Garmin connected", Toast.LENGTH_LONG).show()
            } else {
                // TODO: Make snackbar with reconnect option
                Toast.makeText(this, "Garmin not connected", Toast.LENGTH_LONG).show()
            }
        }
    }

    companion object {

        private const val TAG = "bt"
    }

}