var _refreshing = mutableStateOf(false)
suspend fun test() = coroutineScope {
    _refreshing.value = true
    delay(3_000)
    _refreshing.value = false
}

@OptIn(ExperimentalMaterialApi::class)
@Composable AppContent() {
    val coroutineScope = rememberCoroutineScope()
    val refreshing by remember { _refreshing }
    val pullRefreshState = rememberPullRefreshState(refreshing, {
        coroutineScope.launch {
            test()
        }
    })

    Box(
        Modifier
            .fillMaxSize()
            .pullRefresh(pullRefreshState)
            .verticalScroll(rememberScrollState())
            //.horizontalScroll(rememberScrollState())
    ) {
        PullRefreshIndicator(
            refreshing,
            pullRefreshState,
            Modifier.align(Alignment.TopCenter)
        )
    }
}

@Composable
fun TransformableImage() {
    val scaleMax = 5.0f
    var scale by remember { mutableStateOf(1.0f) }
    var offset by remember { mutableStateOf(Offset.Zero) }
    val state = rememberTransformableState { zoomChange, offsetChange, _ ->
        val scale_ = scale * zoomChange
        if (scale_ >= 1.0f && scale_ <= scaleMax) scale = scale_
        offset += Offset(offsetChange.x * scale, offsetChange.y * scale)
    }

    var animating by remember { mutableStateOf(false) }
    val zoom by animateFloatAsState(
        label = "",
        targetValue = if (scale <= scaleMax / 2) {
            if (animating) scaleMax else scale
        } else {
            if (animating) 1.0f else scale
        },
        animationSpec = tween(durationMillis = if (animating) 300 else 0),
        finishedListener = {
            if (animating) {
                animating = false
                scale = it
            }
        }
    )

    Box(
        Modifier
            .pointerInput(Unit) {
                detectTapGestures(
                    onPress = { /* Called when the gesture starts */ },
                    onDoubleTap = {
                        animating = true
                        offset = Offset.Zero
                    },
                    onLongPress = { /* Called on Long Press */ },
                    onTap = { /* Called on Tap */ }
                )
            }
            .graphicsLayer(
                scaleX = if (animating) zoom else scale,
                scaleY = if (animating) zoom else scale,
                translationX = offset.x,
                translationY = offset.y
            )
            .transformable(state = state)
            .background(Color.Blue)
            .fillMaxSize()
    ) {
        // <uses-permission android:name="android.permission.INTERNET" />
        val url = "https://..."
        Image(
            painter = rememberAsyncImagePainter(url), // io.coil-kt:coil-compose
            contentDescription = null,
            modifier = Modifier.fillMaxSize(),
            contentScale = ContentScale.FillWidth
        )
    }
}

var visible by remember { mutableStateOf(false) }
AnimatedVisibility(
    visible = visible,
    enter = slideInHorizontally(tween(50)) { width -> width },
    exit = slideOutHorizontally(tween(50)) { width -> width },
) {
...
}

var text by remember { mutableStateOf("テキスト") }
TextField(
    value = text,
    onValueChange = { text = it },
    colors = TextFieldDefaults.colors(
        focusedContainerColor = Color.Transparent,
        unfocusedContainerColor = Color.Transparent,
        focusedIndicatorColor = Color.Transparent,
        unfocusedIndicatorColor = Color.Transparent,
    )
)

val drawLine = true
BasicTextField(
    value = text,
    onValueChange = { text = it },
    textStyle = LocalTextStyle.current.copy(
        color = MaterialTheme.colorScheme.onSurface
    ),
) { innerTextField ->
    Column {
        innerTextField()
        if (drawLine) {
            Spacer(Modifier.height(1.dp))
            Divider(thickness = 1.dp, color = MaterialTheme.colorScheme.onSurface)
        }
    }
}

val enabled = true
val singleLine = true
val visualTransformation = VisualTransformation.None
val interactionSource = remember { MutableInteractionSource() }
BasicTextField(
    value = text,
    onValueChange = { text = it },
    textStyle = LocalTextStyle.current.copy(
        color = MaterialTheme.colorScheme.onSurface
    ),
    enabled = enabled,
    singleLine = singleLine,
    visualTransformation = visualTransformation,
    interactionSource = interactionSource,
) { innerTextField ->
    TextFieldDefaults.DecorationBox(
        value = text,
        innerTextField = innerTextField,
        enabled = enabled,
        singleLine = singleLine,
        visualTransformation = VisualTransformation.None,
        interactionSource = interactionSource,
        shape = RectangleShape, // TextFieldDefaults.shape
        contentPadding = PaddingValues(0.dp)
    )
}

@OptIn(ExperimentalFoundationApi::class)
@Composable
fun PagerScreen(modifier: Modifier = Modifier) {
    val coroutineScope = rememberCoroutineScope()
    var tabIndex by remember { mutableStateOf(0) }
    val category = remember { mutableStateListOf<String>() }
    var pagerState = rememberPagerState(pageCount = {
        if (category.size == 0) 1
        else category.size
    })

    LaunchedEffect(pagerState) {
        snapshotFlow { pagerState.currentPage }.collect { page ->
            tabIndex = page
        }
    }

    Column(modifier) {
        ScrollableTabRow(selectedTabIndex = tabIndex) {
            category.forEachIndexed { index, title ->
                LeadingIconTab(
                    selected = tabIndex == index,
                    onClick = {
                        tabIndex = index
                        coroutineScope.launch {
                            //pagerState.scrollToPage(index)
                            pagerState.animateScrollToPage(index, animationSpec = tween(400))
                        }
                    },
                    text = {
                        val max = LocalConfiguration.current.screenWidthDp.dp * (1F / 3F)
                        Text(title, overflow = TextOverflow.Ellipsis, maxLines = 1, modifier = Modifier.widthIn(max = max))
                    },
                    icon = {}
                )
            }
            // 固定Tab
            LeadingIconTab(
                selected = false,
                onClick = {
                    category.add("ページ ${category.size + 1}")
                },
                text = { Text("＋ タブ追加") },
                icon = {}
            )
        }

        HorizontalPager(
            state = pagerState,
        ) { page ->
            if (category.size == 0) {
                Text("まだ何も登録されていません", modifier = Modifier.fillMaxSize())
            }
            else {
                Text("${category[page]}", modifier = Modifier.fillMaxSize())
            }
        }
    }
}

@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)
    }
}

Column {
    Button(onClick = { throw RuntimeException("Test Crash") }) {
        Text("Test Crash")
    }
}

@Entity(tableName = "stat")
data class Stat(
    @PrimaryKey val id: Int,
    val name: String,
    // language, name
    val names: Map<String, String>,
)
@Dao
interface StatDao {
    @Query("SELECT * FROM stat")
    override fun getAll(): Flow<List<Stat>>
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    suspend fun insert(list: List<Stat>)
}

class ListTypeConverter {
    @TypeConverter
    fun fromList(list: List<String>): String {
        return Json.encodeToString(list)
    }
    @TypeConverter
    fun toList(str: String): List<String> {
        return Json.decodeFromString<List<String>>(str)
    }
}
class MapTypeConverter {
    @TypeConverter
    fun fromMap(map: Map<String, String>): String {
        return Json.encodeToString(map)
    }
    @TypeConverter
    fun toMap(str: String): Map<String, String> {
        return Json.decodeFromString<Map<String, String>>(str)
    }
}

@Database(entities = [Stat::class], version = 1, exportSchema = false)
@TypeConverters(ListTypeConverter::class, MapTypeConverter::class)
abstract class AppDatabase : RoomDatabase() {
    abstract fun dao(): StatDao
}

@Entity(tableName = "stat_name")
data class StatName(
    @PrimaryKey(autoGenerate = true) @ColumnInfo(name = "id") val count: Int = 0,
    @ColumnInfo(name = "name_id") val id: Int,
    val language: String,
    val name: String,
)
@Entity(tableName = "stat")
data class StatEntry(
    @PrimaryKey val id: Int,
    val name: String,
)

data class Stat(
    @Embedded val stat: StatEntry,
    @Relation(
        parentColumn = "id",
        entityColumn = "name_id",
        entity = StatName::class
    )
    val names: List<StatName>,
)

@Dao
interface StatNameDao {
    @Transaction
    @Query("SELECT * FROM stat_name")
    override fun getAll(): Flow<List<StatName>>
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    suspend fun insert(list: List<StatName>)
}
@Dao
interface StatDao {
    @Query("SELECT * FROM stat")
    override fun getAll(): Flow<List<Stat>>
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    suspend fun insert(list: List<StatEntry>)
}

@Database(entities = [Stat::class, StatName::class], version = 1, exportSchema = false)
abstract class AppDatabase : RoomDatabase() {
    abstract fun stadDao(): StatDao
    abstract fun stadNameDao(): StatNameDao
}

[versions]
com-google-devtools-ksp = "1.9.0-1.0.13"
androidx-room = "2.6.0-beta01"
androidx-paging = "3.2.0"
dagger-hilt = "2.48"

[libraries]
kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version = "1.6.0" }
androidx-room-ktx = { group = "androidx.room", name = "room-ktx", version.ref = "androidx-room" }
androidx-room-runtime = { group = "androidx.room", name = "room-runtime", version.ref = "androidx-room" }
androidx-room-compiler = { group = "androidx.room", name = "room-compiler", version.ref = "androidx-room" }
androidx-room-paging = { group = "androidx.room", name = "room-paging", version.ref = "androidx-room" }
androidx-paging-runtime-ktx = { group = "androidx.paging", name = "paging-runtime-ktx", version.ref = "androidx-paging" }
androidx-paging-compose = { group = "androidx.paging", name = "paging-compose", version.ref = "androidx-paging" }
hilt-android = { group = "com.google.dagger", name = "hilt-android", version.ref = "dagger-hilt" }
hilt-compiler = { group = "com.google.dagger", name = "hilt-compiler", version.ref = "dagger-hilt" }
androidx-hilt-navigation-compose = { group = "androidx.hilt", name = "hilt-navigation-compose", version = "1.1.0-alpha01" }

[plugins]
com-google-devtools-ksp = {id = "com.google.devtools.ksp", version.ref = "com-google-devtools-ksp" }
com-google-dagger-hilt-android = { id = "com.google.dagger.hilt.android", version.ref = "dagger-hilt" }

plugins {
    kotlin("plugin.serialization") version "1.9.0"
    alias(libs.plugins.com.google.devtools.ksp) apply false
    alias(libs.plugins.com.google.dagger.hilt.android) apply false
}

plugins {
    id("kotlinx-serialization")
    alias(libs.plugins.com.google.devtools.ksp)
    alias(libs.plugins.com.google.dagger.hilt.android)
}

dependencies {
    implementation(libs.kotlinx.serialization.json)
    implementation(libs.androidx.room.ktx)
    implementation(libs.androidx.room.runtime)
    implementation(libs.androidx.room.paging)
    implementation(libs.androidx.paging.runtime.ktx)
    implementation(libs.androidx.paging.compose)
    implementation(libs.hilt.android)
    ksp(libs.hilt.compiler)
    implementation(libs.androidx.hilt.navigation.compose)
    ksp(libs.androidx.room.compiler)
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar", "*.aar"))))
}

/**
 * ```AndroidManifest.xml
 * <application
 *     android:name=".Application"
 * ```
 */
@HiltAndroidApp
class Application : android.app.Application() {
    override fun onCreate() {
        super.onCreate()
    }
}

@AndroidEntryPoint
class MainActivity : ComponentActivity() {
    ...
}

const val TABLE_POKEMON = "pokemon"
@Entity(tableName = TABLE_POKEMON)
data class Pokemon(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    val name: String,
)

@Dao
interface PokemonDao {
    @Query("SELECT * FROM $TABLE_POKEMON")
    fun pagingSource(): PagingSource<Int, Pokemon>
    @Query("SELECT COUNT(*) FROM $TABLE_POKEMON")
    suspend fun count(): Long
    @Query("DELETE FROM $TABLE_POKEMON")
    suspend fun deleteAll()
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    suspend fun insert(data: Pokemon)
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    suspend fun insert(list: List<Pokemon>)
}

@Database(entities = [Pokemon::class], version = 1, exportSchema = false)
abstract class AppDatabase : RoomDatabase() {
    abstract fun dao(): PokemonDao
}

class PokemonRepository @Inject constructor(
    private val pager: Pager<Int, Pokemon>,
) {
    fun getPagingStream() = pager.flow
}

const val PAGE_SIZE = 20

@OptIn(ExperimentalPagingApi::class)
class PokemonRemoteMediator @Inject constructor(
    private val db: AppDatabase,
) : RemoteMediator<Int, Pokemon>() {
    override suspend fun initialize(): InitializeAction {
        return InitializeAction.SKIP_INITIAL_REFRESH
    }

    override suspend fun load(
        loadType: LoadType,
        state: PagingState<Int, Pokemon>,
    ): MediatorResult {
        return try {
            val dao = db.dao()
            val count = dao.count()
            val offset = when (loadType) {
                LoadType.REFRESH -> if (count == 0L) 0L else return MediatorResult.Success(true)
                LoadType.PREPEND -> return MediatorResult.Success(true)
                LoadType.APPEND -> count
            }

            var poke_count = 0
            val result = mutableListOf<Pokemon>()
            PokeApi.Pokemon(limit = PAGE_SIZE, offset = offset.toInt(), onError = {
                Log.e("App", it.localizedMessage ?: "")
            }) { poke ->
                poke_count = poke.count
                result.addAll(poke.results.map {
                    Pokemon(name = it.name)
                })
            }

            if (result.isNotEmpty()) {
                db.withTransaction {
                    dao.insert(result)
                }
            }

            return MediatorResult.Success(poke_count < count + PAGE_SIZE)
        }
        catch (e: Exception) {
            MediatorResult.Error(e)
        }
    }
}

@Module
@InstallIn(ViewModelComponent::class)
object PokemonModule {
    @Provides
    fun provideDatabase(
        @ApplicationContext context: Context
    ) = Room.databaseBuilder(context, AppDatabase::class.java, "app.db").build()

    @Provides
    fun provideDao(db: AppDatabase) = db.dao()

    @OptIn(ExperimentalPagingApi::class)
    @Provides
    fun providePager(
        db: AppDatabase,
    ): Pager<Int, Pokemon> {
        return Pager(
            config = PagingConfig(pageSize = PAGE_SIZE),
            remoteMediator = PokemonRemoteMediator(
                db = db
            ),
            pagingSourceFactory = {
                db.dao().pagingSource()
            },
        )
    }

    @Provides
    fun provideRepository(pager: Pager<Int, Pokemon>) = PokemonRepository(pager)
}

@HiltViewModel
class PokeViewModel @Inject constructor(
    private val repo: PokemonRepository,
) : ViewModel() {
    val pokemon = repo.getPagingStream().cachedIn(viewModelScope)
}

@Composable
fun AppScreen(
    modifier: Modifier = Modifier,
    viewModel: PokeViewModel = hiltViewModel(),
) {
    val items = viewModel.pokemon.collectAsLazyPagingItems()

    LazyColumn(modifier.fillMaxSize(), verticalArrangement = Arrangement.spacedBy(8.dp)) {
        items(
            count = items.itemCount,
            key = items.itemKey { it.id },
        ) { index ->
            val poke = items[index]
            poke?.apply {
                ListItem(headlineContent = {
                    Text("$index. $name")
                })
                Divider(color = Color.LightGray)
            }
        }
    }
}