private lateinit var healthConnectClient: HealthConnectClient

val PERMISSIONS =
    setOf(
        HealthPermission.createReadPermission(HeartRateRecord::class),
        HealthPermission.createReadPermission(StepsRecord::class),
        HealthPermission.createReadPermission(DistanceRecord::class),
        HealthPermission.createReadPermission(ExerciseSessionRecord::class)
    )
// Create the permissions launcher.
private val requestPermissionActivityContract = PermissionController.createRequestPermissionResultContract()
private val requestPermissions =
    registerForActivityResult(requestPermissionActivityContract) { granted ->
        if (granted.containsAll(PERMISSIONS)) {
            // Permissions successfully granted
            Log.d(ContentValues.TAG, "Permissions successfully granted")
            // Now you can read the steps data
            val job = CoroutineScope(Dispatchers.Main).launch {
                val healthConnectClient = HealthConnectClient.getOrCreate(requireContext())
                checkPermissionsAndRun(healthConnectClient)
            }
        } else {
            // Lack of required permissions
            // Show an error message or request permissions again
            Log.d(ContentValues.TAG, "Permissions required failed")
        }
    }

    suspend fun checkPermissionsAndRun(healthConnectClient: HealthConnectClient) {

        val granted = healthConnectClient.permissionController.getGrantedPermissions(PERMISSIONS)

        if (granted.containsAll(PERMISSIONS)) {

            Log.d(ContentValues.TAG,"Permission Granted")

            // Get last exercise

            var lastExerciseMap: Map<String, String> = getLastExercise(healthConnectClient)

            if (lastExerciseMap["Key"] == "Value"){
                Log.d(TAG, "No Data")
            } else {
                Log.d(TAG, "Last Exercise: ${lastExerciseMap["Key"]}")
            }
        } else {
            Log.d(ContentValues.TAG,"Asking for Permission")
            requestPermissions.launch(PERMISSIONS)
        }
    }

    suspend fun getLastExercise(healthConnectClient: HealthConnectClient): Map<String, String> {
        val lastExercise = mutableMapOf<String, String>()
        val currentDate = LocalDate.now(zoneId)
        val currentDateTime = ZonedDateTime.now(zoneId)
        val sevenDaysAgoDateTime = currentDateTime.minusDays(7) // subtract 7 days from the current date time to get 7 days ago
        val startTime = getStartTime(sevenDaysAgoDateTime.toLocalDate())
        val endTime = ZonedDateTime.of(currentDate, currentDateTime.toLocalTime(), zoneId).toInstant() // combine the end time with the current date in Tokyo time
        val response =
            healthConnectClient.readRecords(
                ReadRecordsRequest(
                    ExerciseSessionRecord::class,
                    timeRangeFilter = TimeRangeFilter.between(startTime, endTime)
                )
            )
        if (response.records.isEmpty()) {
            // No records found, output step count as 0
            Log.d(ContentValues.TAG, "Exercise None Between ${startTime} ~ ${endTime}")
            lastExercise["Key"] = "Value"
        } else {

            val mostRecentRecord = response.records[response.records.size - 1]
            val durationStart = mostRecentRecord.startTime
            val formatter = DateTimeFormatter.ofPattern("MM月dd日 HH:mm").withZone(zoneId)
            val formattedDurationStart = formatter.format(durationStart)

            val durationEnd = mostRecentRecord.endTime
            lastExercise["Type"] = getExerciseType(mostRecentRecord.exerciseType)
//            lastExercise["Start"] = durationStart.toString()
            lastExercise["Start"] = formattedDurationStart
            lastExercise["End"] = durationEnd.toString()
            lastExercise["Duration"] = getActivityDuration(healthConnectClient, durationStart, durationEnd)
            lastExercise["HeartRate"] = getActivityHeartRate(healthConnectClient, durationStart, durationEnd).first
            lastExercise["StepsCount"] = getActivityStepsCount(healthConnectClient, durationStart, durationEnd).toString()
        }
        return lastExercise
    }