MainActivity.kt

package com.flexicharge.bolt.activities

import android.app.Activity
import android.content.Context
import android.content.Intent
import android.location.Location
import android.os.Bundle
import android.transition.ChangeBounds
import android.transition.Fade
import android.transition.TransitionManager
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.view.animation.AnimationUtils
import android.view.inputmethod.InputMethodManager
import android.widget.*
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.appcompat.content.res.AppCompatResources
import androidx.constraintlayout.widget.ConstraintLayout
import androidx.core.widget.doOnTextChanged
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.chaos.view.PinView
import com.flexicharge.bolt.R
import com.flexicharge.bolt.SpacesItemDecoration
import com.flexicharge.bolt.activities.businessLogic.*
import com.flexicharge.bolt.adapters.ChargePointListAdapter
import com.flexicharge.bolt.adapters.ChargersListAdapter
import com.flexicharge.bolt.adapters.TimeCalculation
import com.flexicharge.bolt.api.flexicharge.ChargePoints
import com.flexicharge.bolt.api.flexicharge.Charger
import com.flexicharge.bolt.api.flexicharge.TransactionSession
import com.flexicharge.bolt.databinding.ActivityMainBinding
import com.flexicharge.bolt.foregroundServices.ChargingService
import com.flexicharge.bolt.helpers.LoginChecker
import com.flexicharge.bolt.helpers.MapHelper
import com.flexicharge.bolt.helpers.MapHelper.addNewMarkers
import com.flexicharge.bolt.helpers.MapHelper.currLocation
import com.flexicharge.bolt.helpers.MapHelper.currentLocation
import com.flexicharge.bolt.helpers.MapHelper.fetchLocation
import com.flexicharge.bolt.helpers.MapHelper.panToPos
import com.google.android.gms.maps.GoogleMap
import com.google.android.gms.maps.OnMapReadyCallback
import com.google.android.gms.maps.SupportMapFragment
import com.google.android.material.bottomsheet.BottomSheetBehavior
import com.google.android.material.bottomsheet.BottomSheetDialog
import com.google.android.material.button.MaterialButton
import java.util.*
import kotlin.collections.ArrayList
import kotlin.math.roundToInt
import kotlinx.coroutines.*

class MainActivity :
    AppCompatActivity(),
    OnMapReadyCallback,
    ChargePointListAdapter.ShowChargePointInterface,
    ChargersListAdapter.ChangeInputInterface {
    private lateinit var binding: ActivityMainBinding // the bindings in the Main Activity (camera, user, charger, position).
    private lateinit var chargerInputDialog: BottomSheetDialog
    private lateinit var paymentSummaryDialog: BottomSheetDialog
    private lateinit var pinView: PinView
    private lateinit var chargerInputStatus: MaterialButton
    private lateinit var listOfChargersRecyclerView: RecyclerView
    private var isBottomSheetVisible = false
    private val timeCalculation = TimeCalculation()

    private companion object {
        const val REMOTE_CHARGERS_REFRESH_INTERVAL_MS: Long = 10000
    }

    private val remoteChargers = RemoteChargers()
    private val remoteChargePoints = RemoteChargePoints()
    private val currentRemoteTransaction = RemoteTransaction()
    private val remoteChargersRefresher =
        RemoteObjectRefresher(remoteChargers, REMOTE_CHARGERS_REFRESH_INTERVAL_MS)

    override fun onCreate(savedInstanceState: Bundle?) {
        checkPendingTransaction()
        super.onCreate(savedInstanceState)

        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)
        remoteChargers.setOnRefreshedCallBack {
            lifecycleScope.launch(Dispatchers.Main) {
                addNewMarkers(
                    this@MainActivity,
                    remoteChargers.value,
                    fun(charger: Charger?): Boolean {
                        if (charger != null && validateChargerId(charger.connectorID.toString())) {
                            lifecycleScope.launch(Dispatchers.Main) {
                                setupChargerInputDialog(charger.connectorID)
                            }
                        }
                        return false
                    }
                )
            }
        }
        remoteChargersRefresher.run(lifecycleScope)

        binding.mainActivityButtonPinPosition.setOnClickListener {
            currLocation(this)
        }

        val resultLauncher =
            registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
                if (it.resultCode == Activity.RESULT_OK) {
                    val data: Intent? = it.data
                    try {
                        setupChargerInputDialog()
                        changeInput(data?.getStringExtra("QR_SCAN_RESULT").toString())
                    } catch (e: Exception) {
                        Toast.makeText(this, e.message, Toast.LENGTH_SHORT)
                            .show() // exception handling
                    }
                }
            }

        binding.mainActivityButtonCamera.setOnClickListener {
            val intent = Intent(this, QrActivity::class.java)
            resultLauncher.launch(intent)
        }

        val mapFragment =
            supportFragmentManager.findFragmentById(R.id.mainActivity_fragment_map) as SupportMapFragment
        mapFragment.getMapAsync(this)

        binding.mainActivityButtonIdentifyCharger.setOnClickListener {
            setupChargerInputDialog()
        }

        val loginSharedPref = getSharedPreferences("loginPreference", Context.MODE_PRIVATE)
        val accessToken = loginSharedPref.getString("accessToken", Context.MODE_PRIVATE.toString())
        val userId = loginSharedPref.getString("userId", Context.MODE_PRIVATE.toString())

        if (accessToken != null) {
            currentRemoteTransaction.localAccessToken = accessToken
        }

        binding.mainActivityButtonUser.setOnClickListener {
            if (LoginChecker.LOGGED_IN) {
                val intent = Intent(this, ProfileMenuLoggedInActivity::class.java)
                intent.putExtra("accessToken", accessToken)
                intent.putExtra("userId", userId)
                startActivity(intent)
            } else {
                startActivity(Intent(this, RegisterActivity::class.java))
            }
        }
    }

    override fun onResume() { // Called after onRestoreInstanceState, onRestart, or onPause
        super.onResume()
        Log.d("StartVerify", "On resume")

        val loginSharedPref = getSharedPreferences("loginPreference", Context.MODE_PRIVATE)
        val accessToken = loginSharedPref.getString("accessToken", Context.MODE_PRIVATE.toString())

        if (accessToken != null) {
            currentRemoteTransaction.localAccessToken = accessToken
        }

        remoteChargersRefresher.run(lifecycleScope)
        val refreshChargers = remoteChargers.refresh(lifecycleScope)
        refreshChargers.invokeOnCompletion {
            if (refreshChargers.isCancelled) {
                return@invokeOnCompletion
            }
        }
        val refreshChargePoints = remoteChargePoints.refresh(lifecycleScope)

        refreshChargePoints.invokeOnCompletion {
            if (refreshChargePoints.isCancelled) {
                return@invokeOnCompletion
            }
        }

        if (!isBottomSheetVisible) {
            Log.d("StartVerify", "Check Pending transaction")
            checkPendingTransaction()
        }

        fetchLocation(this)
    }

    override fun changeInput(newInput: String) {
        pinView.setText(newInput)
    }

    override fun showChargePoint(
        latitude: Double,
        longitude: Double,
        chargePointID: Int
    ) {
        panToPos(latitude, longitude)
        showCheckout(true, chargePointID, false, -1)
    }

    override fun onMapReady(googleMap: GoogleMap) {
        MapHelper.onMapReady(this, googleMap)
    }

    private fun Context.hideKeyboard(view: View) {
        val inputMethodManager =
            getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
        inputMethodManager.hideSoftInputFromWindow(view.windowToken, 0)
    }

    private fun stopChargingProcess(
        bottomSheetDialog: BottomSheetDialog
    ) {
        // currentRemoteTransaction.refresh(lifecycleScope)

        try {
            val stopRemoteTransactionJob = currentRemoteTransaction.stop(lifecycleScope)
            stopRemoteTransactionJob.invokeOnCompletion {
                if (stopRemoteTransactionJob.isCancelled) {
                    return@invokeOnCompletion
                }
                lifecycleScope.launch(Dispatchers.Main) {
                    Intent(applicationContext, ChargingService::class.java).also {
                        it.action = ChargingService.Actions.STOP.toString()
                        startService(it)
                    }

                    val dateTime =
                        timeCalculation.unixToDateTime(
                            currentRemoteTransaction.value.endTimestamp!!
                        )

                    Log.d("EndVerify3", dateTime)

                    val sharedPreferences =
                        getSharedPreferences("sharedPrefs", Context.MODE_PRIVATE)
                    sharedPreferences.edit().apply { putInt("TransactionId", -1) }.apply()
                    bottomSheetDialog.dismiss()
                    displayPaymentSummaryDialog(dateTime)
                }
            }
        } catch (e: Exception) {
            lifecycleScope.launch(Dispatchers.Main) {
                Toast.makeText(applicationContext, e.message, Toast.LENGTH_LONG).show()
                val sharedPreferences = getSharedPreferences("sharedPrefs", Context.MODE_PRIVATE)
                sharedPreferences.edit().apply { putInt("TransactionId", -1) }.apply()
                bottomSheetDialog.dismiss()

                // displayPaymentSummaryDialog(dateTime)
            }
        }
    }

    private val scope = CoroutineScope(Dispatchers.IO)
    private var isPolling = false

    private fun setupChargingInProgressDialog() {
        if (this::chargerInputDialog.isInitialized) {
            Log.d("CheckTransaction", "it is initialized")
            chargerInputDialog.dismiss()
        }
        val retrieveJob =
            currentRemoteTransaction.retrieve(lifecycleScope)

        try {
            retrieveJob.invokeOnCompletion {
                if (retrieveJob.isCancelled) {
                    Log.d("StartVerify", "retrieve job cancelled")
                    return@invokeOnCompletion
                }
            }
        } catch (e: Exception) {
            Log.d("StartVerify", "catch error remote trans")
            println("Error when retrieving")
        }

        val bottomSheetDialog = BottomSheetDialog(this@MainActivity)
        val bottomSheetView = LayoutInflater.from(applicationContext).inflate(
            R.layout.layout_charger_in_progress,
            findViewById<ConstraintLayout>(R.id.chargerInProgress)
        )

        val progressbarPercent =
            bottomSheetView.findViewById<TextView>(
                R.id.chargeInProgressLayout_textView_progressbarPercent
            )
        val progressbar =
            bottomSheetView.findViewById<ProgressBar>(R.id.chargeInProgressLayout_progressBar)
        val chargeSpeed =
            bottomSheetView.findViewById<TextView>(R.id.chargeInProgressLayout_textView_chargeSpeed)
        val location =
            bottomSheetView.findViewById<TextView>(R.id.chargeInProgressLayout_textView_location)
        val chargeDuration = bottomSheetView.findViewById<TextView>(
            R.id.chargeInProgressLayout_textview_chargingTimeStatus
        )

        bottomSheetDialog.behavior.state = BottomSheetBehavior.STATE_EXPANDED
        bottomSheetDialog.behavior.isDraggable = false
        bottomSheetDialog.setCancelable(false)

        val currentPercentage = currentRemoteTransaction.value.currentChargePercentage
        progressbar.progress = currentPercentage!!

        isPolling = true
        val foundCharger =
            remoteChargers.value.find { it.connectorID == currentRemoteTransaction.value.connectorID }
        val currentChargePoint =
            remoteChargePoints.value.find { it.chargePointID == foundCharger?.chargePointID }

        location.text = currentChargePoint?.name

        scope.launch {
            while (isPolling) {
                currentRemoteTransaction.retrieve(lifecycleScope)

                withContext(Dispatchers.Main) {
                    if (currentRemoteTransaction.value.endTimestamp != null) {
                        isPolling = false
                        stopChargingProcess(bottomSheetDialog)
                    } else {
                        if (currentRemoteTransaction.value.startTimestamp != null) {
                            val currentTime = System.currentTimeMillis()
                            val duration = timeCalculation.checkDuration(
                                currentRemoteTransaction.value.startTimestamp!! * 1000,
                                currentTime
                            )
                            chargeDuration.text = duration
                        } else {
                            // chargeDuration.text = chargeDuration.text
                        }

                        progressbar.progress =
                            currentRemoteTransaction.value.currentChargePercentage!!
                        progressbarPercent.text =
                            currentRemoteTransaction.value.currentChargePercentage.toString()
                        chargeSpeed.text = currentRemoteTransaction.value.kwhTransferred.toString()
                    }
                }
                delay(3000)
            }
        }

        bottomSheetView.findViewById<MaterialButton>(
            R.id.chargeInProgressLayout_button_stopCharging
        )
            .setOnClickListener {
                isPolling = false
                stopChargingProcess(bottomSheetDialog)
            }

        bottomSheetDialog.setContentView(bottomSheetView)
        isBottomSheetVisible = true
        bottomSheetDialog.show()
    }

    private fun displayPaymentSummaryDialog(dateTime: String) {
        Log.d("EndVerify1234", "we get here")
        if (this::paymentSummaryDialog.isInitialized) {
            paymentSummaryDialog.dismiss()
        }

        // TODO Look over values before final commit

        paymentSummaryDialog = BottomSheetDialog(this@MainActivity, R.style.BottomSheetDialogTheme)
        val bottomSheetView = LayoutInflater.from(applicationContext).inflate(
            R.layout.layout_payment_summary,
            findViewById<ConstraintLayout>(R.id.paymentSummaryLayout)
        )
        val energyUsedTextView =
            bottomSheetView.findViewById<TextView>(
                R.id.paymentSummaryLayout_textView_energyUsedValue
            )
        val durationTextView =
            bottomSheetView.findViewById<TextView>(R.id.paymentSummaryLayout_textView_durationValue)
        val chargingStopTimeTextView =
            bottomSheetView.findViewById<TextView>(R.id.paymentSummaryLayout_textView_finishedTime)
        val totalCostTextView =
            bottomSheetView.findViewById<TextView>(R.id.paymentPriceLayout_textView_price)
        val crossButton =
            bottomSheetView.findViewById<ImageButton>(R.id.paymentSummaryLayout_button_close)

        crossButton.setOnClickListener {
            paymentSummaryDialog.dismiss()
            isBottomSheetVisible = false
        }

        Log.d("EndVerify666", currentRemoteTransaction.value.toString())
        val transaction = currentRemoteTransaction.value
        val kwhTransferred = transaction.kwhTransferred
        val totalCost = transaction.price?.toFloat()?.div(100)
        val pricePerKwh = totalCost?.div(transaction.kwhTransferred!!)
        val duration = timeCalculation.checkDuration(
            transaction.startTimestamp!! * 1000,
            transaction.endTimestamp!! * 1000
        )

        var roundedPrice = 0.0
        var roundedKwh = 0.0

        if (pricePerKwh != null) {
            roundedPrice = String.format(Locale.US, "%.2f", pricePerKwh).toDouble()
            roundedKwh = String.format(Locale.US, "%.2f", kwhTransferred).toDouble()
        }
        val rounded = (pricePerKwh?.times(100))?.toFloat()?.div(100)
        lifecycleScope.launch(Dispatchers.Main) {
            val energyUsedText = "$roundedKwh  kWh @ $roundedPrice + kr kWh"
            val chargingStopTimeText = "Charging stopped at $dateTime"
            val totalCostText = "$totalCost kr"

            energyUsedTextView.text = energyUsedText

            durationTextView.text = duration
            chargingStopTimeTextView.text = chargingStopTimeText
            totalCostTextView.text = totalCostText

            paymentSummaryDialog.setContentView(bottomSheetView)
            paymentSummaryDialog.show()
        }
    }

    private fun setupChargerInputDialog(chargerId: Int? = null) {
        chargerInputDialog = BottomSheetDialog(
            this@MainActivity,
            R.style.BottomSheetDialogTheme
        )

        val bottomSheetView = LayoutInflater.from(applicationContext).inflate(
            R.layout.layout_charger_input,
            findViewById<ConstraintLayout>(R.id.chargerInputLayout)
        )

        val arrow =
            bottomSheetView.findViewById<ImageView>(R.id.chargePointsNearMeLayout_imageView_arrow)
        arrow.setOnClickListener {
            displayChargePointList(bottomSheetView, arrow)
        }

        val backButton = bottomSheetView.findViewById<ImageButton>(R.id.checkoutLayout_button_back)
        backButton.setOnClickListener {
            showCheckout(false, -1, false, -1)
        }

        setupChargerInput(bottomSheetView, chargerId)

        chargerInputDialog.setContentView(bottomSheetView)
        chargerInputDialog.show()
    }

    private fun setupChargerInput(bottomSheetView: View, chargerId: Int? = null) {
        Log.d("displayChargerList", "displayChargerList")

        pinView = bottomSheetView.findViewById(R.id.chargerInputLayout_pinView_chargerInput)
        chargerInputStatus =
            bottomSheetView.findViewById(R.id.chargerInputLayout_textView_chargerStatus)

        if (chargerId != null) {
            if (validateChargerId(chargerId.toString())) {
                pinView.setText(chargerId.toString())
                displayChargerStatus(chargerId, chargerInputStatus)
            }
        }

        pinView.doOnTextChanged { text, _, _, _ ->
            if (text?.length == 6) {
                val newChargerId = text.toString().toUInt().toInt()
                if (validateChargerId(text.toString())) {
                    displayChargerStatus(newChargerId, chargerInputStatus)

                    hideKeyboard(bottomSheetView)
                } else {
                    setChargerButtonStatus(
                        chargerInputStatus,
                        false,
                        "ChargerId has to consist of 6 digits",
                        0
                    )
                    hideKeyboard(bottomSheetView)
                }
            }
        }
    }

    private fun displayChargerList(bottomSheetView: View, chargePointId: Int) {
        val chargerId = pinView.text.toString()
        val refreshJob = remoteChargers.refresh(lifecycleScope)
        refreshJob.invokeOnCompletion {
            if (refreshJob.isCancelled) {
                return@invokeOnCompletion
            }
        }
        val refreshRemoteChargePointsJob = remoteChargePoints.refresh(lifecycleScope)
        refreshRemoteChargePointsJob.invokeOnCompletion {
            if (refreshRemoteChargePointsJob.isCancelled) {
                return@invokeOnCompletion
            }
            lifecycleScope.launch(Dispatchers.Main) {
                listOfChargersRecyclerView =
                    bottomSheetView.findViewById(R.id.checkoutLayout_recyclerView_chargerList)
                listOfChargersRecyclerView.layoutManager = LinearLayoutManager(
                    this@MainActivity,
                    LinearLayoutManager.HORIZONTAL,
                    false
                )

                val chargersInCp = remoteChargers.value.filter { it.chargePointID == chargePointId }
                listOfChargersRecyclerView.adapter =
                    ChargersListAdapter(chargersInCp, chargerId, this@MainActivity)

                // Only add decoration on first-time display
                if (listOfChargersRecyclerView.itemDecorationCount == 0) {
                    listOfChargersRecyclerView.addItemDecoration(SpacesItemDecoration(15))
                }
            }
        }
    }

    private fun displayChargePointList(bottomSheetView: View, arrow: ImageView) {
        val listOfChargePointsRecyclerView =
            bottomSheetView.findViewById<RecyclerView>(
                R.id.chargePointsNearMeLayout_recyclerView_chargePointList
            )
        val chargePointsNearMe =
            bottomSheetView.findViewById<TextView>(R.id.chargePointsNearMeLayout_textView_nearMe)
        TransitionManager.beginDelayedTransition(bottomSheetView as ViewGroup?, Fade())
        if (listOfChargePointsRecyclerView.visibility == View.GONE) {
            arrow.startAnimation(AnimationUtils.loadAnimation(this, R.anim.rotate_reverse))
            listOfChargePointsRecyclerView.visibility = View.VISIBLE
            chargePointsNearMe.visibility = View.GONE
        } else {
            arrow.startAnimation(AnimationUtils.loadAnimation(this, R.anim.rotate))
            listOfChargePointsRecyclerView.visibility = View.GONE
            chargePointsNearMe.visibility = View.VISIBLE
        }
        listOfChargePointsRecyclerView.layoutManager = LinearLayoutManager(this)
        val refreshChargePoints = remoteChargePoints.refresh(lifecycleScope)
        refreshChargePoints.invokeOnCompletion {
            if (refreshChargePoints.isCancelled) {
                return@invokeOnCompletion
            }

            val distanceToChargePoint = mutableListOf<Float>()
            val chargerCount = mutableListOf<Int>()

            Log.d("Distance", "${remoteChargePoints.value}")

            remoteChargePoints.value.forEachIndexed { _, chargePoint ->
                val dist = FloatArray(1)
                try {
                    Location.distanceBetween(
                        chargePoint.location[0],
                        chargePoint.location[1],
                        currentLocation.latitude,
                        currentLocation.longitude,
                        dist
                    )
                } catch (e: UninitializedPropertyAccessException) {
                    dist[0] = 0f
                }

                val distanceFloat = (dist[0] / 1000)
                val roundedDistance = (distanceFloat * 100).roundToInt() / 100f
                val count =
                    remoteChargers.value.count { it.chargePointID == chargePoint.chargePointID }

                distanceToChargePoint.add(roundedDistance)
                chargerCount.add(count)
            }

            val chargePointList = ArrayList(remoteChargePoints.value)

            val indices = distanceToChargePoint.indices.sortedBy { distanceToChargePoint[it] }

            val sortedDistanceToChargePoint = indices.map { distanceToChargePoint[it] }
            val sortedChargerCount = indices.map { chargerCount[it] }.toMutableList()
            val sortedChargePoints = indices.map { chargePointList[it] }

            val sortedChargePointsList = ChargePoints()
            sortedChargePointsList.addAll(sortedChargePoints)

            val distanceAsString = mutableListOf<String>()
            distanceAsString.addAll(sortedDistanceToChargePoint.map { it.toString() })

            lifecycleScope.launch(Dispatchers.Main) {
                listOfChargePointsRecyclerView.adapter = ChargePointListAdapter(
                    sortedChargePointsList,
                    this@MainActivity,
                    distanceAsString,
                    sortedChargerCount
                )
            }
        }
    }

    private fun createKlarnaTransactionSession(
        chargerId: Int
    ) {
        val retrieveJob = currentRemoteTransaction.retrieve(lifecycleScope)

        try {
            retrieveJob.invokeOnCompletion {
                if (retrieveJob.isCancelled) {
                    return@invokeOnCompletion
                }

                lifecycleScope.launch(Dispatchers.Main) {
                    val intent = Intent(this@MainActivity, KlarnaActivity::class.java)
                    intent.putExtra("ChargerId", chargerId)
                    intent.putExtra(
                        "klarna_consumer_token",
                        currentRemoteTransaction.klarnaConsumerToken
                    )
                    intent.putExtra("TransactionId", currentRemoteTransaction.transactionId)
                    startActivity(intent)
                }
            }
        } catch (e: Exception) {
            println("Error when retrieving")
        }
    }

    private fun reserveCharger(chargerId: Int, chargerInputStatus: MaterialButton) {
        val sharedPreferences = getSharedPreferences("loginPreference", Context.MODE_PRIVATE)
        val transactionSession = TransactionSession(chargerId, "klarna")
        val accessToken =
            sharedPreferences.getString("accessToken", Context.MODE_PRIVATE.toString())

        val createSessionJob =
            currentRemoteTransaction.createSession(
                lifecycleScope,
                transactionSession,
                accessToken!!
            )

        try {
            createSessionJob.invokeOnCompletion {
                if (createSessionJob.isCancelled) {
                    return@invokeOnCompletion
                }

                when (currentRemoteTransaction.status) {
                    "Accepted" -> {
                        createKlarnaTransactionSession(chargerId)
                    }

                    "Faulted" -> {
                        setChargerButtonStatus(chargerInputStatus, false, "Charger Faulted", 2)
                    }

                    "Occupied" -> {
                        setChargerButtonStatus(chargerInputStatus, false, "Charger Occupied", 2)
                    }

                    "Rejected" -> {
                        setChargerButtonStatus(chargerInputStatus, false, "Charger Rejected", 2)
                    }

                    "Unavailable" -> {
                        setChargerButtonStatus(chargerInputStatus, false, "Charger Unavailable", 2)
                    }
                    "Unauthorized" -> {
                        val intent = Intent(this, RegisterActivity::class.java)
                        startActivity(intent)
                        finish()
                    }
                    "OldToken" -> {
                        val intent = Intent(this, LoginActivity::class.java)
                        startActivity(intent)
                        finish()
                    }

                    else -> {
                        setChargerButtonStatus(
                            chargerInputStatus,
                            false,
                            "Charger Unknown status",
                            2
                        )
                    }
                }
            }
        } catch (e: CancellationException) {
            lifecycleScope.launch(Dispatchers.Main) {
                setChargerButtonStatus(chargerInputStatus, false, "Could not reserve charger", 0)
            }
            Toast.makeText(
                applicationContext,
                "Could not reserve charger: " + e.message,
                Toast.LENGTH_LONG
            ).show()
        }
    }

    private fun displayChargerStatus(chargerId: Int, chargerInputStatus: MaterialButton) {
        val remoteCharger = RemoteCharger(chargerId)
        try {
            val refreshJob = remoteCharger.refresh(lifecycleScope)
            refreshJob.invokeOnCompletion {
                if (refreshJob.isCancelled) {
                    return@invokeOnCompletion
                }

                val charger = remoteCharger.value
                Log.d("validateConnection", "Connected to charger " + charger.connectorID)
                lifecycleScope.launch(Dispatchers.Main) {
                    when (charger.status) {
                        "Available" -> {
                            showCheckout(true, charger.chargePointID, true, chargerId)
                            setChargerButtonStatus(chargerInputStatus, true, "Continue", 2)
                        }

                        "Faulted" -> {
                            setChargerButtonStatus(chargerInputStatus, false, "Charger Faulted", 0)
                        }

                        "Occupied" -> {
                            setChargerButtonStatus(chargerInputStatus, false, "Charger Occupied", 0)
                        }

                        "Rejected" -> {
                            setChargerButtonStatus(chargerInputStatus, false, "Charger Rejected", 0)
                        }

                        "Unavailable" -> {
                            setChargerButtonStatus(
                                chargerInputStatus,
                                false,
                                "Charger Unavailable",
                                0
                            )
                        }

                        "Charging" -> {
                            setChargerButtonStatus(
                                chargerInputStatus,
                                false,
                                "Charger is occupied",
                                0
                            )
                        }

                        "Reserved" -> {
                            setChargerButtonStatus(
                                chargerInputStatus,
                                false,
                                "Charger is reserved",
                                0
                            )
                        }

                        else -> {
                            setChargerButtonStatus(
                                chargerInputStatus,
                                false,
                                "Charger is " + charger.status,
                                2
                            )
                        }
                    }
                }
            }
        } catch (e: CancellationException) {
            lifecycleScope.launch(Dispatchers.Main) {
                setChargerButtonStatus(chargerInputStatus, false, e.message!!, 2)
            }
        }
    }

    private fun setChargerButtonStatus(
        chargerInputStatus: MaterialButton,
        active: Boolean,
        text: String,
        color: Int
    ) {
        chargerInputStatus.isClickable = active
        chargerInputStatus.text = text
        when (color) {
            0 -> {
                chargerInputStatus.setBackgroundColor(getColor(R.color.red))
                chargerInputStatus.setTextColor(getColor(R.color.white))
            }

            1 -> {
                chargerInputStatus.setBackgroundColor(getColor(R.color.green))
                chargerInputStatus.setTextColor(getColor(R.color.white))
            }

            2 -> {
                chargerInputStatus.setBackgroundColor(getColor(R.color.light_grey))
                chargerInputStatus.setTextColor(getColor(R.color.black))
            }

            3 -> {
                chargerInputStatus.setBackgroundColor(getColor(R.color.dark_grey))
                chargerInputStatus.setTextColor(getColor(R.color.white))
            }
        }
    }

    fun validateChargerId(chargerId: String): Boolean {
        if (chargerId.length != 6) {
            return false
        }
        if (chargerId.count { it.isDigit() } != 6) {
            return false
        }
        return true
    }

    private fun checkPendingTransaction() {
        // TODO Fix fetching transaction ID smartly
        val sharedPreferences = getSharedPreferences("sharedPrefs", Context.MODE_PRIVATE)
        val transactionId = sharedPreferences.getInt("TransactionId", -1)

        if (transactionId == -1) {
            Log.d("StartVerify", "No active transaction")
            return
        }
        currentRemoteTransaction.transactionId = transactionId

        val refreshJob = currentRemoteTransaction.refresh(lifecycleScope)
        refreshJob.invokeOnCompletion {
            if (refreshJob.isCancelled) {
                Log.d("StartVerify", "Refresh fail")
                return@invokeOnCompletion
            }

            lifecycleScope.launch(Dispatchers.Main) {
                try {
                    Log.d("StartVerify", "Set up charger")
                    setupChargingInProgressDialog()
                } catch (e: Exception) {
                    Log.d("CheckTransaction", "Found an errors")
                    Toast.makeText(
                        applicationContext,
                        e.message + " : " + e.cause,
                        Toast.LENGTH_LONG
                    ).show()
                }
            }
        }
    }

    private fun showCheckout(
        bool: Boolean,
        chargePointId: Int,
        showPayment: Boolean,
        chargerId: Int
    ) {
        val checkoutLayout =
            chargerInputDialog.findViewById<ConstraintLayout>(R.id.charger_checkout_layout)
        val chargersNearMeLayout =
            chargerInputDialog.findViewById<ConstraintLayout>(R.id.chargePoints_near_me_layout)
        val chargerInput =
            chargerInputDialog.findViewById<EditText>(R.id.chargerInputLayout_pinView_chargerInput)
        val chargerInputStatus =
            chargerInputDialog.findViewById<MaterialButton>(
                R.id.chargerInputLayout_textView_chargerStatus
            )
        val chargerInputView =
            chargerInputDialog.findViewById<ConstraintLayout>(R.id.chargerInputLayout)
        val chargerLocationText =
            chargerInputDialog.findViewById<TextView>(R.id.checkoutLayout_textView_currentLocation)
        val paymentText =
            chargerInputDialog.findViewById<TextView>(R.id.checkoutLayout_textView_payment)
        val klarnaButton =
            chargerInputDialog.findViewById<ImageButton>(R.id.checkoutLayout_button_klarna)

        TransitionManager.beginDelayedTransition(chargerInputView as ViewGroup?, ChangeBounds())

        if (bool) {
            chargersNearMeLayout?.visibility = View.GONE
            checkoutLayout?.visibility = View.VISIBLE
            if (showPayment) {
                klarnaButton?.background =
                    AppCompatResources.getDrawable(this, R.drawable.rounded_background)
                klarnaButton?.visibility = View.VISIBLE
                paymentText?.visibility = View.VISIBLE
                chargerInput?.isEnabled = false
                chargerInputStatus?.isEnabled = false

                klarnaButton?.setOnClickListener {
                    klarnaButton.background =
                        AppCompatResources.getDrawable(this, R.drawable.rounded_background_selected)
                    chargerInputStatus?.isEnabled = true
                    if (chargerInputStatus != null) {
                        setChargerButtonStatus(chargerInputStatus, true, "Continue", 1)
                    }
                    // reserveCharger(chargerId, chargerInputStatus!!)
                }

                chargerInputStatus?.setOnClickListener {
                    reserveCharger(chargerId, chargerInputStatus)
                }
            } else {
                klarnaButton?.visibility = View.GONE
                paymentText?.visibility = View.GONE
                chargerInput?.isEnabled = true
            }
            try {
                val chargerWithChargePointId =
                    remoteChargePoints.value.first { it.chargePointID == chargePointId }
                chargerLocationText?.text = chargerWithChargePointId.name
            } catch (e: NoSuchElementException) {
                Log.d(
                    "remoteChargePoints",
                    "couldn't find a charger with chargePointID $chargePointId"
                )
            }

            if (chargerInputView != null) {
                displayChargerList(chargerInputView, chargePointId)
            }
        } else {
            chargerInput?.isEnabled = true
            chargersNearMeLayout?.visibility = View.VISIBLE
            checkoutLayout?.visibility = View.GONE
            chargerInput?.text?.clear()
            setChargerButtonStatus(
                chargerInputStatus!!,
                false,
                getString(R.string.charger_status_enter_code),
                3
            )
        }
    }

    override fun finish() {
        super.finish()
        remoteChargersRefresher.stop()
    }
}