package com.flacksta.chef.journeygpstracker

import android.Manifest
import android.app.ActivityManager
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.os.Bundle
import android.util.Log
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.core.content.ContextCompat
import androidx.fragment.app.Fragment
import com.flacksta.chef.journeygpstracker.databinding.ActivityMainScreenBinding


class MainActivity : AppCompatActivity() {

    private lateinit var binding: ActivityMainScreenBinding
    private var mPermApproved: Boolean = false

    private val mTag: String = "MainActivity"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainScreenBinding.inflate(layoutInflater)
        setContentView(binding.root)

        /*binding.bottomNavigationView.setOnItemSelectedListener {
            val fragment = when (it.itemId) {
                R.id.map -> {
                    MapFragment()
                }
                R.id.settings -> {
                    SettingsFragment()
                }
                else -> {
                    null//HomeFragment()
                }
            }
            if( fragment == null ) closeFragment() else loadFragment(fragment)
            true
        }*/
        //loadFragment(HomeFragment())

        val locationPermissionRequest = registerForActivityResult(
                ActivityResultContracts.RequestMultiplePermissions()
        ) { permissions ->
            when {
                permissions.getOrDefault(Manifest.permission.ACCESS_FINE_LOCATION, false) -> {
                    Log.i(mTag,"Fine permission granted")
                    mPermApproved = true
                }
                permissions.getOrDefault(Manifest.permission.ACCESS_COARSE_LOCATION, false) -> {
                    Log.i(mTag,"Only Coarse permission granted")
                } else -> {
                Log.i(mTag,"No Permission granted")
            }
            }
        }

        if( ContextCompat.checkSelfPermission(
                        this,
                        Manifest.permission.ACCESS_FINE_LOCATION
                ) != PackageManager.PERMISSION_GRANTED ) {
                locationPermissionRequest.launch(arrayOf(
                        Manifest.permission.ACCESS_FINE_LOCATION,
                        Manifest.permission.ACCESS_COARSE_LOCATION))
        }
        else {
            mPermApproved = true
        }

        val serviceRunning : Boolean = isServiceActuallyRunning<TrackingService>()
        Log.i(mTag,"Service is actually running: $serviceRunning")

        val state : Boolean = isServiceStateRunning(this)

        if( state != serviceRunning ) {
            Log.e(mTag,"Missmatch state=$state vs actual=$serviceRunning. Correcting...")
            setServiceState(this, if( serviceRunning) ServiceState.STARTED else ServiceState.STOPPED)
        }

        binding.buttonStart.isEnabled = !serviceRunning
        binding.buttonStop.isEnabled = serviceRunning

        binding.buttonStart.setOnClickListener {
            actionOnService(Actions.START)
            binding.buttonStart.isEnabled = false
            binding.buttonStop.isEnabled = true
        }
        binding.buttonStop.setOnClickListener{
            actionOnService(Actions.STOP)
            binding.buttonStart.isEnabled = true
            binding.buttonStop.isEnabled = false
        }
    }

    private fun actionOnService(action: Actions) {
        Log.i(mTag, "actionOnService() ${action.toString()}")
        val state : ServiceState = getServiceState(this)
        if( state == ServiceState.STOPPED && action == Actions.STOP) return
        if( state == ServiceState.STARTED && action == Actions.START) return
        Intent(this, TrackingService::class.java).also {
            it.action = action.name
            startForegroundService(it)
        }
    }

    private fun loadFragment(fragment: Fragment) {
        supportFragmentManager
                .beginTransaction()
                .replace(R.id.main_frame_layout, fragment)
                .commit()
    }

    private fun closeFragment() {
        val fragment = supportFragmentManager.findFragmentById(R.id.main_frame_layout)
        if( fragment != null ) {
            supportFragmentManager
                    .beginTransaction()
                    .remove(fragment)
                    .commit()
        }
    }

    override fun onDestroy() {
/*        if (::mTrackingServiceIntent.isInitialized) {
            stopService(mTrackingServiceIntent)
            Log.i(mTag,"Stopping service")
        }*/
        Log.i(mTag,"onDestroy()")
        super.onDestroy()
    }

}