IntroActivity.kt

package com.eatssu.android.presentation.intro

import android.content.Intent
import android.os.Bundle
import androidx.activity.enableEdgeToEdge
import androidx.activity.viewModels
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import com.eatssu.android.R
import com.eatssu.android.databinding.ActivityIntroBinding
import com.eatssu.android.presentation.MainActivity
import com.eatssu.android.presentation.common.ForceUpdateDialogActivity
import com.eatssu.android.presentation.login.LoginActivity
import com.eatssu.android.presentation.util.observeNetworkError
import com.eatssu.android.presentation.util.showToast
import com.eatssu.android.presentation.util.startActivity
import com.eatssu.common.EventLogger
import com.eatssu.common.UiEvent
import com.eatssu.common.UiState
import com.eatssu.common.UiText

import com.eatssu.common.enums.LaunchPath
import com.eatssu.common.enums.ScreenId
import com.eatssu.common.enums.ToastType
import com.google.android.play.core.appupdate.AppUpdateManager
import com.google.android.play.core.appupdate.AppUpdateManagerFactory
import com.google.android.play.core.install.model.AppUpdateType
import com.google.android.play.core.install.model.UpdateAvailability
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch

@AndroidEntryPoint
class IntroActivity : AppCompatActivity() {

    private val introViewModel: IntroViewModel by viewModels()
    private lateinit var binding: ActivityIntroBinding
    private lateinit var appUpdateManager: AppUpdateManager


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

        checkAppUpdate()

        observeState()
        observeEvents()
        observeNetworkError()

        lifecycleScope.launch {
            // 버전 체크 결과 관찰
            introViewModel.versionCheckResult.collectLatest { result ->
                result?.let {
                    when (it) {
                        is VersionCheckResult.ForceUpdateRequired -> {
                            showForceUpdateDialog()
                        }

                        VersionCheckResult.UpdateNotRequired -> {
                            // 업데이트 불필요 - 정상 진행
                        }
                    }
                }
            }
        }
    }

    private fun observeState() {
        lifecycleScope.launch {
            introViewModel.uiState.collectLatest { state ->
                when (state) {
                    is UiState.Success -> {
                        startActivity<MainActivity>()
                        finish()
                    }

                    is UiState.Error -> {
                        // 로그인 액티비티로 이동
                        startActivity<LoginActivity>()
                        finish()
                    }

                    else -> Unit
                }
            }
        }
    }

    private fun observeEvents() {
        lifecycleScope.launch {
            introViewModel.uiEvent.collectLatest { event ->
                when (event) {
                    is UiEvent.ShowToast -> {
                        // 에러 메시지 표시
                        showToast(event)
                    }
                }
            }
        }
    }

    private fun log() {
        val launchPath = intent.getStringExtra("launch_path")
        when (launchPath) {
            "widget" -> EventLogger.appLaunch(LaunchPath.WIDGET)
            "local_notification" -> EventLogger.appLaunch(LaunchPath.LOCAL_NOTIFICATION)
            "remote_notification" -> EventLogger.appLaunch(LaunchPath.REMOTE_NOTIFICATION)
            // launch_path가 없으면 일반적인 앱 아이콘 클릭으로 간주
            else -> EventLogger.appLaunch(LaunchPath.ICON)
        }
    }

    override fun onResume() {
        super.onResume()
        EventLogger.screenView(ScreenId.LOGIN_SPLASH)

        if (::appUpdateManager.isInitialized) {
            appUpdateManager.appUpdateInfo.addOnSuccessListener { appUpdateInfo ->
                if (appUpdateInfo.updateAvailability() == UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS) {
                    // If an in-app update is already in progress, resume the update.
                    appUpdateManager.startUpdateFlowForResult(
                        appUpdateInfo,
                        AppUpdateType.IMMEDIATE,
                        this,
                        UPDATE_REQUEST_CODE
                    )
                }
            }
        }
    }

    private fun showForceUpdateDialog() {
        val intent = Intent(this, ForceUpdateDialogActivity::class.java)
        startActivity(intent)
    }

    private fun checkAppUpdate() {
        appUpdateManager = AppUpdateManagerFactory.create(this)

        val appUpdateInfoTask = appUpdateManager.appUpdateInfo

        appUpdateInfoTask.addOnSuccessListener { appUpdateInfo ->
            if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE &&
                appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.IMMEDIATE)
            ) {
                appUpdateManager.startUpdateFlowForResult(
                    appUpdateInfo,
                    AppUpdateType.IMMEDIATE,
                    this,
                    UPDATE_REQUEST_CODE
                )
            } else {
                introViewModel.startAppChecks()
            }
        }.addOnFailureListener {
            introViewModel.startAppChecks()
        }
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)

        if (requestCode == UPDATE_REQUEST_CODE) {
            if (resultCode != RESULT_OK) {
                showToast(
                    UiEvent.ShowToast(
                        UiText.StringResource(R.string.toast_app_update_canceled), ToastType.INFO
                    )
                )
                // If the update is cancelled or fails,
                // you can request to start the update again.
                introViewModel.startAppChecks()
            }
        }
    }

    companion object {
        const val UPDATE_REQUEST_CODE = 500
    }
}