data class AlarmDisplayModel(
    val hour:Int,
    val minute:Int,
    var onOff:Boolean
){
    val timeText:String
        get(){
            val h = "%02d".format(if(hour<12) hour else hour-12 )
            val m = "%02d".format(minute)
            return "$h:$m"
        }

    val ampmText:String
        get(){
            return if(hour>12) "pm" else "am"
        }

    val onOffButtonText:String
        get(){
            return if(onOff) "알람 끄기" else "알람 켜기"
        }
    fun makeData() = "$hour:$minute"
}

    // MainActivity OnCreate 밑

    private fun initChangeTimeButton() {
        val changeTimeButton = findViewById<Button>(R.id.changeTimeButton)

        val calendar = Calendar.getInstance()

        changeTimeButton.setOnClickListener{
            TimePickerDialog(this, { picker, hour, minute->

                // 기존 알람을 삭제하는 코드, 밑에서 구현
                // pending event가 설정되어있다면 삭제!
                val pendingIntent = PendingIntent.getBroadcast(this, ALARM_REQUEST_CODE, Intent(this, AlarmReceiver::class.java), PendingIntent.FLAG_NO_CREATE)
                pendingIntent?.cancel()
                
                val model = saveAlarm(hour,minute, false)
                renderModel(model) // 밑에서 구현

            }, calendar.get(Calendar.HOUR_OF_DAY), calendar.get(Calendar.MINUTE), false).show()
        }
    }

    private fun saveAlarm(hour:Int, minute:Int, onOff:Boolean): AlarmDisplayModel{
        val model = AlarmDisplayModel(
            hour=hour,
            minute=minute,
            onOff=onOff
        )

        // SharedPreferences 사용, Data store은 이번에 사용하지 않음
        val sharedPreferences = getSharedPreferences(SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE)

        // Scope Function with() 실행, sharedPreferences.edit() 의 함수들을 스코프 내에서 실행
        with(sharedPreferences.edit()){
            putString(ALARM_KEY, model.makeData())
            putBoolean(ON_OFF_KEY, model.onOff)
            commit()
        }

        return model
    }

    companion object{
        private const val SHARED_PREFERENCES_NAME = "time"
        private const val ALARM_KEY = "alarm"
        private const val ON_OFF_KEY = "onOff"
        private const val ALARM_REQUEST_CODE = 1000
    }

import android.app.NotificationChannel
import android.app.NotificationManager
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.os.Build
import androidx.core.app.NotificationCompat
import androidx.core.app.NotificationManagerCompat

class AlarmReceiver:BroadcastReceiver() {

    override fun onReceive(context: Context?, intent: Intent?) {
        createNotificationChannel(context!!)
        notifyNotification(context!!)
    }

    private fun createNotificationChannel(context: Context) {

        // sdk 26이상부터는 채널이 필요함
        if(Build.VERSION.SDK_INT>= Build.VERSION_CODES.O){
            // 채널 id, 이름, 중요도
            val notificationChannel = NotificationChannel(
                CHANNEL_ID,
                "기상 알림",
                NotificationManager.IMPORTANCE_DEFAULT
            )
            NotificationManagerCompat.from(context).createNotificationChannel( notificationChannel )
        }
    }

    private fun notifyNotification(context: Context){
        with(NotificationManagerCompat.from(context)){
            val builder = NotificationCompat.Builder(context,CHANNEL_ID)
                .setSmallIcon(R.drawable.ic_launcher_foreground)
                .setContentTitle("알람")
                .setContentText("일어날 시간입니다.")
                .setPriority(NotificationCompat.PRIORITY_DEFAULT)

            // 주의 !!!!!!!!! 채널 아이디가 아니라 Noti ID
            notify(NOTIFICATION_ID, builder.build())
        }
    }

    companion object{
        private const val CHANNEL_ID = "1000"
        private const val NOTIFICATION_ID = 100
    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        initOnOffButton()
        initChangeTimeButton()

        val model = fetchDataFromSharedPreferences()
        renderModel(model)
    }
    
    ...

    private fun fetchDataFromSharedPreferences(): AlarmDisplayModel {
        val sharedPreferences = getSharedPreferences(SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE)

        // nullable 반환이라 null safe 필요
        val timeValue = sharedPreferences.getString(ALARM_KEY,"09:30") ?: "09:30"
        val onOffValue = sharedPreferences.getBoolean(ON_OFF_KEY, false)
        val alarmData = timeValue.split(':')

        val model = AlarmDisplayModel(alarmData[0].toInt(), alarmData[1].toInt(),onOffValue)

        // 예외처리
        val pendingIntent = PendingIntent.getBroadcast(this, ALARM_REQUEST_CODE, Intent(this, AlarmReceiver::class.java), PendingIntent.FLAG_NO_CREATE)
        if(pendingIntent== null && model.onOff){
            // pending event는 없는데 알람이 켜져있는 경우 알람 끄기
            model.onOff = false
        }
        else if( pendingIntent != null && model.onOff.not()){
            // pending event는 있는데 알람이 꺼저있는 경우 pending event 끄기
            pendingIntent.cancel()
        }
        return model
    }

    private fun renderModel(model: AlarmDisplayModel){
        findViewById<TextView>(R.id.ampmTextView).apply{
            text = model.ampmText
        }
        findViewById<TextView>(R.id.timeTextView).apply{
            text = model.timeText
        }
        findViewById<Button>(R.id.onOffButton).apply{
            text = model.onOffButtonText

            // 현재 model을 전역변수로 설정하지 않았다 따라서 버튼에 태그를 달아서 오브젝트를 서정, 불러오기 가능
            tag = model
        }
    }

    ...
}

    // onCreate 밑
    private fun initOnOffButton() {
        val onOffButton = findViewById<Button>(R.id.onOffButton)

        onOffButton.setOnClickListener {
            val model = it.tag as? AlarmDisplayModel ?: return@setOnClickListener
            val newModel = saveAlarm(model.hour, model.minute, model.onOff.not())
            renderModel(newModel)
            if(newModel.onOff){
                // 알람이 켜진 경우 -> 알람을 등록
                val calendar = Calendar.getInstance().apply{
                    set(Calendar.HOUR_OF_DAY, newModel.hour)
                    set(Calendar.MINUTE, newModel.minute)

                    // 현재 시각보다 이전의 시간이면 다음날로 설정
                    if(before(Calendar.getInstance())){
                        add(Calendar.DATE, 1)
                    }
                }

                val alarmManager = getSystemService(Context.ALARM_SERVICE) as AlarmManager
                val intent = Intent(this, AlarmReceiver::class.java)
                val pendingIntent = PendingIntent.getBroadcast(this, ALARM_REQUEST_CODE,intent, PendingIntent.FLAG_UPDATE_CURRENT)

                alarmManager.setInexactRepeating(
                    AlarmManager.RTC_WAKEUP,    // 시간 방식
                    calendar.timeInMillis,      // 원하는 시간
                    AlarmManager.INTERVAL_DAY,  // 하루 한번
                    pendingIntent               // pending event 등록
                )
            }else{
                Log.d("tag","cancel")
                // 알람이 꺼진 경우 -> 알람 삭제
                cancelAlarm()
            }
        }
    }