@Stable
sealed class Event {
    val id = UUID.randomUUID().toString()
    data class Message(val message: String) : Event()
}

class AppViewModel : ViewModel() {
    private val _uiEvents = MutableStateFlow<List<Event>>(emptyList())
    val uiEvents = _uiEvents.asStateFlow()

    fun stub() = viewModelScope.launch {
        val message = listOf(
            "おはよう",
            "こんにちわ",
            "こんばんわ",
        )

        repeat(5) {
            val msg = message.random()
            _uiEvents.update {
                it + Event.Message(msg)
            }
        }
    }

    fun consumeEvent(event: Event) {
        _uiEvents.update {
            e -> e.filterNot { it.id == event.id }
        }
    }
}

@Composable
fun AppContent(viewModel: AppViewModel = viewModel()) {
    val uiEvents by viewModel.uiEvents.collectAsState()
    var message by remember { mutableStateOf("") }

    LaunchedEffect(uiEvents) {
        if (uiEvents.isNotEmpty()) {
            when (val event = uiEvents.first()) {
                is Event.Message -> {
                    message = "${event.message}(${event.id})"
                    Log.d("App", message)
                    launch {
                        delay(1_000)
                        viewModel.consumeEvent(event)
                    }
                }
            }
        }
    }

    Column {
        Button(onClick = { viewModel.stub() }) {
            Text("Start")
        }
        Text(message)
    }
}

buildscript {
    ext {
        room_version = '2.4.3'
    }
}
plugins {
    id 'com.google.devtools.ksp' version '1.7.20-1.0.7' apply false
}

plugins {
    id 'com.google.devtools.ksp'
}
dependencies {
    implementation "androidx.room:room-ktx:$room_version"
    implementation "androidx.room:room-runtime:$room_version"
    ksp "androidx.room:room-compiler:$room_version"
}

@Composable fun AppContent(viewModel: MainViewModel = viewModel()) {
    val datasList = viewModel.datasList.collectAsState()
    var count: Int by rememberSaveable { mutableStateOf( 0) }

    MaterialTheme {
        Surface(
            modifier = Modifier.fillMaxSize(),
            color = MaterialTheme.colorScheme.background
        ) {
            Column {
                Row(modifier = Modifier.padding(4.dp)) {
                    Button(onClick = {
                        val name = "test_${++count}"
                        if (datasList.value.find { it.name == name } == null) {
                            viewModel.insert(Datas(name, SecureRandom().nextInt(100)))
                        }
                        else {
                            viewModel.update(Datas(name, SecureRandom().nextInt(100)))
                        }
                    }) {
                        Text("click")
                    }

                    Button(onClick = { viewModel.deleteAll() }) {
                        Text("clear")
                    }
                }

                datasList.value?.let { datas ->
                    LazyColumn {
                        items(datas) { item ->
                            Text("${item.name} ${item.num}")
                        }
                    }
                }
            }
        }
    }
}

@Entity(tableName = "datas_table")
data class Datas(
    @PrimaryKey @ColumnInfo(name = "name") var name: String = "",
    @ColumnInfo(name = "num") var num: Int = 0,
)

@Dao interface DatasDao {
    @Query("SELECT * FROM datas_table ORDER BY name ASC")
    fun getAlphabetizedDatasList(): Flow<List<Datas>>

    @Insert(onConflict = OnConflictStrategy.IGNORE)
    suspend fun insert(datas: Datas)

    @Update(onConflict = OnConflictStrategy.REPLACE)
    suspend fun update(datas: Datas)

    @Query("DELETE FROM datas_table")
    suspend fun deleteAll()
}

@Database(entities = [Datas::class], version = 1, exportSchema = false)
abstract class DatasRoomDatabase : RoomDatabase() {
    abstract fun dao(): DatasDao

    companion object {
        @Volatile private var INSTANCE: DatasRoomDatabase? = null

        fun getDatabase(context: Context): DatasRoomDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    DatasRoomDatabase::class.java,
                    "app_database"
                ).build()
                INSTANCE = instance
                // return instance
                instance
            }
        }
    }
}

class DatasRepository(
    application: Application,
    private val db: DatasRoomDatabase = DatasRoomDatabase.getDatabase(application),
    private val dao: DatasDao = db.dao()
) {
    val datasList = dao.getAlphabetizedDatasList()

    // ワーカースレッド以外で使用した場合警告
    @Suppress("RedundantSuspendModifier")
    @WorkerThread
    suspend fun insert(datas: Datas) {
        dao.insert(datas)
    }
    @Suppress("RedundantSuspendModifier")
    @WorkerThread
    suspend fun update(datas: Datas) {
        dao.update(datas)
    }
    @Suppress("RedundantSuspendModifier")
    @WorkerThread
    suspend fun deleteAll() {
        dao.deleteAll()
    }
}

class MainViewModel(
    application: Application
) : AndroidViewModel(application) {
    private val repo: DatasRepository = DatasRepository(getApplication())
    val datasList: StateFlow<List<Datas>> = repo.datasList.stateIn(
        scope = viewModelScope,
        started = SharingStarted.WhileSubscribed(5000),
        initialValue = listOf()
    )

    fun insert(datas: Datas) = viewModelScope.launch {
        repo.insert(datas)
    }
    fun update(datas: Datas) = viewModelScope.launch {
        repo.update(datas)
    }
    fun deleteAll() = viewModelScope.launch {
        repo.deleteAll()
    }
}

// numはダミーで使いません
data class Datas(var name: String = "", var num: Int = 0)
class MainViewModel : ViewModel() {
    var datas by mutableStateOf(Datas("none"))
        private set

    fun setName(name: String) {
        datas = datas.copy(name = name)
    }
}

@Composable fun AppContent(viewModel: MainViewModel = viewModel()) {
    MaterialTheme {
        Surface(modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.background) {
            Column {
                Text(viewModel.datas.name)
                Button(onClick = { viewModel.setName("test") }) {
                    Text("click")
                }
            }
        }
    }
}

class MainViewModel(private val savedStateHandle: SavedStateHandle) : ViewModel() {
    var datas: Datas by savedStateHandle.saveable { mutableStateOf(Datas("none")) }
        private set

    fun setName(name: String) {
        datas = datas.copy(name = name)
    }
}

@Composable fun AppContent(viewModel: MainViewModel = viewModel()) {
    MaterialTheme {
        Surface(modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.background) {
            Column {
                Text(viewModel.datas.name)
                Button(onClick = { viewModel.setName("test") }) {
                    Text("click")
                }
            }
        }
    }
}

class MainViewModel() : ViewModel() {
    var datas: MutableLiveData<Datas> = MutableLiveData()
        private set

    fun setName(name: String) {
        // datas.value?.copy(name = name) はできません
        datas.value = Datas(name)
    }
}

@Composable fun AppContent(viewModel: MainViewModel = viewModel()) {
    MaterialTheme {
        Surface(modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.background) {
            val datas: Datas by viewModel.datas.observeAsState(Datas("none"))

            Column {
                Text(datas.name)
                Button(onClick = { viewModel.setName("test") }) {
                    Text("click")
                }
            }
        }
    }
}

class MainViewModel(private val savedStateHandle: SavedStateHandle) : ViewModel() {
    var datas = MutableStateFlow<Datas>(Datas("none"))
        private set

    fun setName(name: String) {
        //datas.value = datas.value.copy(name = name)
        datas.update { datas.value.copy(name = name) }
    }
}

@Composable fun AppContent(viewModel: MainViewModel = viewModel()) {
    MaterialTheme {
        Surface(modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.background) {
            val datas = viewModel.datas.collectAsState()

            Column {
                Text(datas.value.name)
                Button(onClick = { viewModel.setName("test") }) {
                    Text("click")
                }
            }
        }
    }
}