Androidアプリ制作 #14｜タイマーアプリ改造計画⑦ ワンタッチタイマー、ついに完成！

package com.example.myapplication6

import android.content.Context
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.graphics.ImageDecoder
import android.graphics.Matrix
import android.media.ExifInterface
import android.net.Uri
import android.os.Build
import android.media.AudioManager
import android.media.ToneGenerator
import android.os.Bundle
import android.os.SystemClock
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.ImageBitmap
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.compose.ui.text.font.FontWeight
import kotlinx.coroutines.delay
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.currentCoroutineContext
import kotlinx.coroutines.ensureActive
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import java.io.File
import java.io.IOException
import org.json.JSONArray
import org.json.JSONObject
import java.util.Locale
import java.util.UUID

// 1. データ：標準とカスタムを同じ型・同じ一覧で管理する。
// imageUriにはアプリ内へコピーした画像のファイル名を保存する。
// bodyImageUriにはワンタッチタイマーの壁紙画像のファイル名を保存する。
data class TimerPreset(
    val id: Long,
    val name: String,
    val durationSeconds: Int,
    val imageUri: String? = null,
    val builtInKey: String? = null
) {
    val isBuiltIn: Boolean get() = builtInKey != null
}

data class TimerSettings(
    val buttons: List<TimerPreset> = defaultButtons(),
    val bodyImageUri: String? = null
)

private fun defaultButtons() = listOf(
    TimerPreset(-1L, "ラーメン", 180, builtInKey = "ramen"),
    TimerPreset(-2L, "うどん", 300, builtInKey = "udon"),
    TimerPreset(-3L, "パスタ", 420, builtInKey = "pasta")
)

private fun newPresetId(existing: List<TimerPreset>): Long {
    var id: Long
    do { id = UUID.randomUUID().mostSignificantBits and Long.MAX_VALUE }
    while (id == 0L || existing.any { it.id == id })
    return id
}

private fun formatTime(seconds: Int): String =
    String.format(Locale.ROOT, "%02d:%02d", seconds / 60, seconds % 60)

// 2. 保存：UIからJSONやSharedPreferencesの詳細を切り離す。
// 新しいキーに保存するため、旧itemsを上書きせずに移行できる。
private class TimerRepository(context: Context) {
    private val prefs = context.getSharedPreferences("timer_presets", Context.MODE_PRIVATE)

    fun load(): TimerSettings {
        val raw = prefs.all[SETTINGS_KEY] as? String
        if (raw != null) {
            runCatching {
                val root = JSONObject(raw)
                val array = root.getJSONArray("buttons")
                val buttons = (0 until array.length()).map { index ->
                    decodePreset(array.getJSONObject(index))
                }
                require(buttons.map { it.id }.distinct().size == buttons.size)
                require(defaultButtons().all { original ->
                    buttons.count { it.builtInKey == original.builtInKey } == 1
                })
                return TimerSettings(buttons, root.optionalString("bodyImageUri"))
            }
        }
        // 旧版のitemsはStringSetとJSON文字列の両方を読み込む。
        val legacy = when (val value = prefs.all["items"]) {
            is Set<*> -> value.filterIsInstance<String>().sorted().mapNotNull { rawItem ->
                val parts = rawItem.split(":", limit = 3)
                if (parts.size != 3) null else {
                    val id = parts[0].toLongOrNull()
                    val seconds = parts[1].toIntOrNull()
                    if (id == null || seconds == null || seconds !in 1..5999 || parts[2].isBlank()) {
                        null
                    } else TimerPreset(id, parts[2], seconds)
                }
            }
            is String -> runCatching {
                val array = JSONArray(value)
                (0 until array.length()).mapNotNull { index ->
                    runCatching { decodePreset(array.getJSONObject(index)).copy(builtInKey = null) }
                        .getOrNull()
                }
            }.getOrDefault(emptyList())
            else -> emptyList()
        }
        val merged = defaultButtons().toMutableList()
        legacy.forEach { preset ->
            merged.add(if (merged.any { it.id == preset.id }) {
                preset.copy(id = newPresetId(merged))
            } else preset)
        }
        return TimerSettings(buttons = merged)
    }

    fun save(settings: TimerSettings) {
        val array = JSONArray()
        settings.buttons.forEach { preset ->
            array.put(JSONObject().apply {
                put("id", preset.id)
                put("name", preset.name)
                put("durationSeconds", preset.durationSeconds)
                put("imageUri", preset.imageUri ?: JSONObject.NULL)
                put("builtInKey", preset.builtInKey ?: JSONObject.NULL)
            })
        }
        val root = JSONObject().apply {
            put("version", 2)
            put("buttons", array) // 配列の順番がそのまま画面のボタン順になる。
            put("bodyImageUri", settings.bodyImageUri ?: JSONObject.NULL)
        }
        prefs.edit().putString(SETTINGS_KEY, root.toString()).apply()
    }

    private fun decodePreset(json: JSONObject): TimerPreset {
        val seconds = if (json.has("durationSeconds")) json.getInt("durationSeconds")
        else json.getInt("seconds")
        val name = json.getString("name")
        require(seconds in 1..5999 && name.isNotBlank())
        val key = json.optionalString("builtInKey")
        require(key == null || key in setOf("ramen", "udon", "pasta"))
        return TimerPreset(json.getLong("id"), name, seconds,
            json.optionalString("imageUri"), key)
    }

    private fun JSONObject.optionalString(key: String): String? =
        if (!has(key) || isNull(key)) null else getString(key).takeIf { it.isNotBlank() }

    companion object { private const val SETTINGS_KEY = "settings_v2" }
}

// 3. 計測：数字入力・開始・停止・リセットをここに集約。
// 画面を増やしても、同じ計測ルールを共有できる。
@Stable
private class TimerController {
    var remainingSeconds by mutableIntStateOf(0)
        private set
    var inputNumber by mutableIntStateOf(0)
        private set
    var isRunning by mutableStateOf(false)
        private set
    var hasStarted by mutableStateOf(false)
        private set
    var sessionId by mutableIntStateOf(0)
        private set
    private var deadlineMillis = 0L

    val canInput: Boolean get() = !hasStarted
    val displayText: String get() = if (hasStarted) formatTime(remainingSeconds)
    else String.format(Locale.ROOT, "%02d:%02d", inputNumber / 100, inputNumber % 100)

    fun inputDigit(digit: Int) {
        if (canInput && digit in 0..9 && inputNumber < 1000) {
            inputNumber = inputNumber * 10 + digit
        }
    }

    fun selectPreset(seconds: Int) {
        if (hasStarted) return // 開始・一時停止・終了後は別のプリセットで上書きしない。
        require(seconds > 0)
        remainingSeconds = seconds
        inputNumber = 0
        hasStarted = true
        start()
    }

    fun toggle() {
        if (isRunning) {
            updateRemaining()
            isRunning = false
        } else {
            if (!hasStarted) {
                // 入力中は99:99まで表示。開始時だけ実際の秒数へ変換。
                remainingSeconds = (inputNumber / 100) * 60 + inputNumber % 100
                if (remainingSeconds == 0) return
                inputNumber = 0
                hasStarted = true
            }
            if (remainingSeconds > 0) start()
        }
    }

    fun reset() {
        isRunning = false
        remainingSeconds = 0
        inputNumber = 0
        hasStarted = false
        sessionId++
    }

    private fun start() {
        deadlineMillis = SystemClock.elapsedRealtime() + remainingSeconds * 1000L
        sessionId++ // 計測中に別のボタンを押した場合も待機処理をやり直す。
        isRunning = true
    }

    // 時刻との差から残りを算出し、delayの遅れが積み重ならないようにする。
    private fun updateRemaining() {
        val millis = (deadlineMillis - SystemClock.elapsedRealtime()).coerceAtLeast(0L)
        remainingSeconds = ((millis + 999L) / 1000L).toInt()
    }

    fun tick(): Boolean {
        if (!isRunning) return false
        updateRemaining()
        if (remainingSeconds > 0) return false
        isRunning = false
        return true // 完了音を鳴らすのは完了した1回だけ。
    }
}

// 4. アプリの入口・画面共通処理。
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent { MaterialTheme { CustomTimer() } }
    }
}

@Composable
fun CustomTimer() {
    val context = LocalContext.current
    val repository = remember(context) { TimerRepository(context.applicationContext) }
    var settings by remember { mutableStateOf(repository.load()) }
    val imageStore = remember(context) { ButtonImageStore(context.applicationContext) }
    val timer = remember { TimerController() }
    // 編集キャンセルや差し替えで不要になったコピーは、次回起動時に片付ける。
    LaunchedEffect(imageStore) {
        withContext(Dispatchers.IO) {
            imageStore.deleteUnused(settings.buttons.mapNotNull { it.imageUri } + listOfNotNull(settings.bodyImageUri))
        }
    }
    var normalMode by remember { mutableStateOf(false) }
    var showEditor by remember { mutableStateOf(false) }
    var editingPreset by remember { mutableStateOf<TimerPreset?>(null) }
    var showDisplaySettings by remember { mutableStateOf(false) }
    var rearrangeMode by remember { mutableStateOf(false) }
    var selectedSwapId by remember { mutableStateOf<Long?>(null) }
    val tone = remember { ToneGenerator(AudioManager.STREAM_ALARM, 100) }

    DisposableEffect(tone) { onDispose { tone.release() } }
    LaunchedEffect(timer.isRunning, timer.sessionId) {
        while (timer.isRunning) {
            delay(100L)
            if (timer.tick()) {
                tone.startTone(ToneGenerator.TONE_CDMA_ALERT_CALL_GUARD, 2000)
            }
        }
    }

    fun updateSettings(next: TimerSettings) {
        settings = next
        repository.save(next)
    }

    if (showEditor) {
        PresetEditorDialog(
            preset = editingPreset,
            imageStore = imageStore,
            onDismiss = { showEditor = false },
            onSave = { name, seconds, imageFileName ->
                val current = editingPreset
                // 名前・時間・コピーした画像のファイル名をまとめて保存する。
                val item = current?.copy(name = name, durationSeconds = seconds, imageUri = imageFileName)
                    ?: TimerPreset(newPresetId(settings.buttons), name, seconds, imageUri = imageFileName)
                val buttons = if (current == null) settings.buttons + item
                else settings.buttons.map { if (it.id == current.id) item else it }
                updateSettings(settings.copy(buttons = buttons))
                showEditor = false
            },
            onDelete = {
                val current = editingPreset
                if (current != null && !current.isBuiltIn) {
                    updateSettings(settings.copy(buttons = settings.buttons.filterNot { it.id == current.id }))
                }
                showEditor = false
            }
        )
    }

    if (showDisplaySettings) {
        DisplaySettingsDialog(
            currentWallpaper = settings.bodyImageUri,
            imageStore = imageStore,
            rearrangeMode = rearrangeMode,
            onDismiss = { showDisplaySettings = false },
            onSaveWallpaper = { fileName ->
                updateSettings(settings.copy(bodyImageUri = fileName))
                showDisplaySettings = false
            },
            onToggleArrange = {
                rearrangeMode = !rearrangeMode
                selectedSwapId = null
                showDisplaySettings = false
            }
        )
    }

    // 背景を画面全体に敷いて、その上にスクロールできるUIを重ねる。
    // ワンタッチモードだけ、保存した壁紙を使う。通常モードはグレーのまま。
    val fullScreenWallpaper = rememberButtonImage(
        if (normalMode) null else settings.bodyImageUri
    )
    Box(modifier = Modifier.fillMaxSize().background(Color(0xFFD0D0D0))) {
        if (!normalMode && fullScreenWallpaper != null) {
            Image(
                bitmap = fullScreenWallpaper,
                contentDescription = null, // 装飾用の背景
                modifier = Modifier.matchParentSize(),
                contentScale = ContentScale.Crop // 比率を保って画面全面を埋める
            )
            // 背景が派手な場合にも文字やボタンが見えるように薄く覆う。
            Box(Modifier.matchParentSize().background(Color.White.copy(alpha = 0.12f)))
        }
        Column(
            modifier = Modifier.fillMaxSize()
                .windowInsetsPadding(WindowInsets.safeDrawing)
                .verticalScroll(rememberScrollState())
                .padding(start = 16.dp, end = 16.dp, top = 36.dp, bottom = 28.dp),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.spacedBy(16.dp)
        ) {
            Button(onClick = {
                timer.reset()
                tone.stopTone()
                normalMode = !normalMode
                selectedSwapId = null
                rearrangeMode = false
            }) { Text(if (normalMode) "ワンタッチタイマーへ" else "通常タイマーへ") }

            if (normalMode) {
                NormalTimerScreen(timer, onReset = { timer.reset(); tone.stopTone() })
            } else {
                OneTouchTimerScreen(
                    onFinishArrange = { rearrangeMode = false; selectedSwapId = null },
                    settings = settings,
                    timer = timer,
                    onAdd = { editingPreset = null; showEditor = true },
                    onEdit = { editingPreset = it; showEditor = true },
                    onReset = { timer.reset(); tone.stopTone() },
                    onOpenSettings = { showDisplaySettings = true },
                    rearrangeMode = rearrangeMode,
                    selectedSwapId = selectedSwapId,
                    onPresetTap = { preset ->
                        // カウント開始後（一時停止・終了後も含む）はプリセットの操作を禁止。
                        if (timer.hasStarted) {
                            // リセットされるまでは何もしない。
                        } else if (rearrangeMode) {
                            val fromId = selectedSwapId
                            if (fromId == null) {
                                selectedSwapId = preset.id
                            } else if (fromId == preset.id) {
                                selectedSwapId = null
                            } else {
                                val rearranged = settings.buttons.toMutableList()
                                val from = rearranged.indexOfFirst { it.id == fromId }
                                val to = rearranged.indexOfFirst { it.id == preset.id }
                                if (from >= 0 && to >= 0) {
                                    val temp = rearranged[from]
                                    rearranged[from] = rearranged[to]
                                    rearranged[to] = temp
                                    updateSettings(settings.copy(buttons = rearranged))
                                }
                                selectedSwapId = null
                            }
                        } else {
                            tone.stopTone()
                            timer.selectPreset(preset.durationSeconds)
                        }
                    }
                )
            }
        }
    }
}

// 5. モード別の画面。保存処理は親画面へコールバックする。
@Composable
private fun NormalTimerScreen(timer: TimerController, onReset: () -> Unit) {
    Text("通常タイマー", fontSize = 24.sp)
    TimerDisplay(timer.displayText)
    listOf(listOf(1, 2, 3), listOf(4, 5, 6), listOf(7, 8, 9), listOf(0)).forEach { digits ->
        Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceEvenly) {
            digits.forEach { digit ->
                Button(onClick = { timer.inputDigit(digit) }, enabled = timer.canInput,
                    modifier = Modifier.size(72.dp)) {
                    Text(digit.toString(), fontSize = 28.sp)
                }
            }
        }
    }
    TimerControls(timer, normalMode = true, onReset = onReset)
}

@Composable
private fun OneTouchTimerScreen(
    settings: TimerSettings,
    timer: TimerController,
    onFinishArrange: () -> Unit,
    onAdd: () -> Unit,
    onEdit: (TimerPreset) -> Unit,
    onReset: () -> Unit,
    onOpenSettings: () -> Unit,
    rearrangeMode: Boolean,
    selectedSwapId: Long?,
    onPresetTap: (TimerPreset) -> Unit
) {
    // 背景は親のCustomTimerで全面表示。ここでは操作UIだけを描く。
    Column(
        modifier = Modifier.fillMaxWidth().padding(horizontal = 4.dp),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.spacedBy(14.dp)
    ) {
        TimerDisplay(formatTime(timer.remainingSeconds))
        if (rearrangeMode) {
            Column(
                Modifier.fillMaxWidth()
                    .background(Color.White.copy(alpha = 0.92f), RoundedCornerShape(12.dp))
                    .padding(10.dp),
                verticalArrangement = Arrangement.spacedBy(6.dp)
            ) {
                Text(
                    if (selectedSwapId == null) "配置変更中：交換したいボタンを選んでください"
                    else "交換先のボタンを選択（同じボタンで解除）",
                    color = Color(0xFF263238), fontSize = 13.sp
                )
                Button(onClick = onFinishArrange, modifier = Modifier.fillMaxWidth()) {
                    Text("配置変更を完了")
                }
            }
        }
        Spacer(modifier = Modifier.height(80.dp))

        // プリセットボタンは開始後に入力禁止。リセットで再び選べる。
        // 6個までは従来どおり通常表示。
        // 7個以上では、プリセット一覧だけを2段分の高さに制限してスクロール。
        if (settings.buttons.size > 6) {
            Column(
                modifier = Modifier.fillMaxWidth()
                    .height(310.dp)
                    .verticalScroll(rememberScrollState()),
                verticalArrangement = Arrangement.spacedBy(8.dp)
            ) {
                PresetRows(settings.buttons, rearrangeMode, selectedSwapId, timer.hasStarted, onEdit, onPresetTap)
            }
            Text(
                "↑ ↓ プリセット一覧を上下にスクロールできます",
                fontSize = 12.sp,
                color = Color(0xFF263238),
                modifier = Modifier
                    .background(Color.White.copy(alpha = 0.88f), RoundedCornerShape(8.dp))
                    .padding(horizontal = 8.dp, vertical = 4.dp)
            )
        } else {
            // 1〜6個の場合はスクロール領域を作らない。
            Column(
                modifier = Modifier.fillMaxWidth(),
                verticalArrangement = Arrangement.spacedBy(8.dp)
            ) {
                PresetRows(settings.buttons, rearrangeMode, selectedSwapId, timer.hasStarted, onEdit, onPresetTap)
            }
        }
        // 壁紙に左右されず操作できるよう、操作ボタンを半透明のパネルでまとめる。
        Column(
            modifier = Modifier.fillMaxWidth()
                .background(Color.White.copy(alpha = 0.80f), RoundedCornerShape(18.dp))
                .padding(10.dp),
            verticalArrangement = Arrangement.spacedBy(10.dp)
        ) {
            Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                Button(
                    onClick = onAdd,
                    modifier = Modifier.weight(1f).heightIn(min = 48.dp),
                    enabled = !rearrangeMode,
                    contentPadding = PaddingValues(horizontal = 4.dp),
                    colors = ButtonDefaults.buttonColors(
                        containerColor = Color(0xFF6750A4), contentColor = Color.White
                    )
                ) { Text("＋ プリセット追加", fontSize = 12.sp) }
                Button(
                    onClick = onOpenSettings,
                    modifier = Modifier.weight(1f).heightIn(min = 48.dp),
                    contentPadding = PaddingValues(horizontal = 4.dp),
                    colors = ButtonDefaults.buttonColors(
                        containerColor = Color(0xFF3F568E), contentColor = Color.White
                    )
                ) { Text("⚙ 設定変更", fontSize = 12.sp) }
            }
            TimerControls(timer, normalMode = false, onReset = onReset)
        }
    }
}

// プリセットの3列表示を共通化し、通常表示・スクロール表示で同じ処理を使う。
@Composable
private fun PresetRows(
    buttons: List<TimerPreset>,
    rearrangeMode: Boolean,
    selectedSwapId: Long?,
    timerHasStarted: Boolean,
    onEdit: (TimerPreset) -> Unit,
    onPresetTap: (TimerPreset) -> Unit
) {
    buttons.chunked(3).forEach { items ->
        Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
            items.forEach { preset ->
                key(preset.id) {
                    Column(Modifier.weight(1f), horizontalAlignment = Alignment.CenterHorizontally) {
                        PresetButton(
                            preset = preset,
                            onClick = { onPresetTap(preset) },
                            swapSelected = rearrangeMode && selectedSwapId == preset.id,
                            enabled = !timerHasStarted
                        )
                        if (!rearrangeMode && !preset.isBuiltIn) {
                            TextButton(
                                onClick = { onEdit(preset) },
                                modifier = Modifier.padding(top = 2.dp).height(36.dp),
                                colors = ButtonDefaults.textButtonColors(
                                    containerColor = Color.White.copy(alpha = 0.88f),
                                    contentColor = Color(0xFF433283)
                                )
                            ) { Text("編集", fontSize = 13.sp, fontWeight = FontWeight.Bold) }
                        }
                    }
                }
            }
            repeat(3 - items.size) { Spacer(Modifier.weight(1f)) }
        }
    }
}

// 6. 共通パーツ：画像の表示方法を追加する場所もここに一本化する。
@Composable
private fun PresetButton(
    preset: TimerPreset,
    onClick: () -> Unit,
    swapSelected: Boolean = false,
    enabled: Boolean = true
) {
    val drawable = when (preset.builtInKey) {
        "ramen" -> R.drawable.ramen
        "udon" -> R.drawable.udon
        "pasta" -> R.drawable.pasta
        else -> null
    }
    val color = when (preset.builtInKey) {
        "ramen" -> Color.Yellow
        "udon" -> Color(0xFF81D4FA)
        "pasta" -> Color(0xFFFFAB91)
        else -> Color(0xFFE1BEE7)
    }
    Button(onClick = onClick, enabled = enabled,
        modifier = Modifier.fillMaxWidth().height(110.dp),
        shape = RoundedCornerShape(16.dp),
        border = BorderStroke(if (swapSelected) 5.dp else 2.dp,
            if (swapSelected) Color(0xFF7B1FA2) else Color.Black),
        contentPadding = PaddingValues(6.dp),
        colors = ButtonDefaults.buttonColors(
            containerColor = color,
            contentColor = Color.Black,
            disabledContainerColor = color,
            disabledContentColor = Color.Black
        )) {
        Column(horizontalAlignment = Alignment.CenterHorizontally) {
            // コピー画像を優先して表示。読めない画像は標準画像/文字へ戻す。
            val copiedImage = rememberButtonImage(preset.imageUri)
            if (copiedImage != null) {
                Image(bitmap = copiedImage, contentDescription = preset.name,
                    modifier = Modifier.fillMaxWidth().height(55.dp), contentScale = ContentScale.Crop)
            } else if (drawable != null) {
                Image(painterResource(drawable), contentDescription = preset.name,
                    modifier = Modifier.fillMaxWidth().height(55.dp), contentScale = ContentScale.Crop)
            }
            Text(preset.name, fontSize = 12.sp, maxLines = 2, fontWeight = FontWeight.Bold)
            Text(formatTime(preset.durationSeconds), fontSize = 12.sp)
        }
    }
}

@Composable
private fun TimerDisplay(text: String) {
    Box(Modifier.fillMaxWidth().background(Color(0xFF202124), RoundedCornerShape(24.dp))
        .padding(vertical = 24.dp), contentAlignment = Alignment.Center) {
        Text(text, fontSize = 56.sp, color = Color(0xFF00E676), maxLines = 1)
    }
}

@Composable
private fun TimerControls(timer: TimerController, normalMode: Boolean, onReset: () -> Unit) {
    Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
        Button(onClick = { timer.toggle() }, modifier = Modifier.weight(1f).heightIn(min = 48.dp),
            colors = ButtonDefaults.buttonColors(
                containerColor = Color(0xFF6750A4), contentColor = Color.White,
                disabledContainerColor = Color(0xFFDDD7EA),
                disabledContentColor = Color(0xFF615B6B)
            ),
            enabled = timer.isRunning || timer.remainingSeconds > 0 || (normalMode && timer.inputNumber > 0)) {
            Text(if (timer.isRunning) "ストップ" else if (timer.hasStarted) "再開" else "スタート")
        }
        Button(onClick = onReset, modifier = Modifier.weight(1f).heightIn(min = 48.dp)) { Text("リセット") }
    }
}

// 7. 編集画面：選択画像のプレビューを表示し、「保存」でアプリ内へコピー。
@Composable
private fun PresetEditorDialog(
    preset: TimerPreset?,
    imageStore: ButtonImageStore,
    onDismiss: () -> Unit,
    onSave: (String, Int, String?) -> Unit,
    onDelete: () -> Unit
) {
    var name by remember(preset?.id) { mutableStateOf(preset?.name ?: "") }
    var minutes by remember(preset?.id) { mutableStateOf(preset?.let { (it.durationSeconds / 60).toString() } ?: "") }
    var seconds by remember(preset?.id) { mutableStateOf(preset?.let { (it.durationSeconds % 60).toString() } ?: "") }
    var imageReference by remember(preset?.id) { mutableStateOf(preset?.imageUri) }
    var selectedUri by remember(preset?.id) { mutableStateOf<Uri?>(null) }
    var error by remember(preset?.id) { mutableStateOf("") }
    var isSaving by remember { mutableStateOf(false) }
    val scope = rememberCoroutineScope()
    val imagePicker = rememberLauncherForActivityResult(ActivityResultContracts.GetContent()) { uri ->
        // 選択画面でキャンセルした場合は元の画像を維持する。
        if (uri != null) {
            selectedUri = uri
            imageReference = uri.toString()
            error = ""
        }
    }
    val preview = rememberButtonImage(imageReference)

    AlertDialog(onDismissRequest = { if (!isSaving) onDismiss() },
        title = { Text(if (preset == null) "タイマーを追加" else "タイマーを編集") },
        text = {
            Column(Modifier.verticalScroll(rememberScrollState()), verticalArrangement = Arrangement.spacedBy(8.dp)) {
                OutlinedTextField(value = name, onValueChange = { name = it }, enabled = !isSaving,
                    label = { Text("ボタン名（日本語も使えます）") }, singleLine = true)
                NumberInputField(minutes, "分（0〜99）", enabled = !isSaving) { minutes = it }
                NumberInputField(seconds, "秒（0〜59）", enabled = !isSaving) { seconds = it }
                Text("ボタンの画像")
                if (preview != null) {
                    Image(bitmap = preview, contentDescription = "選択画像のプレビュー",
                        modifier = Modifier.fillMaxWidth().height(120.dp), contentScale = ContentScale.Fit)
                } else {
                    Text(if (imageReference == null) "画像なし（文字だけで表示）" else "画像を読み込み中、またはプレビューできません")
                }
                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                    OutlinedButton(onClick = { imagePicker.launch("image/*") }, enabled = !isSaving) {
                        Text(if (imageReference == null) "画像を選ぶ" else "画像を変更")
                    }
                    TextButton(onClick = {
                        selectedUri = null
                        imageReference = null
                        error = ""
                    }, enabled = !isSaving && imageReference != null) { Text("画像を外す") }
                }
                Text("保存すると、画像をアプリ専用の場所へコピーします。", fontSize = 12.sp)
                if (isSaving) {
                    LinearProgressIndicator(modifier = Modifier.fillMaxWidth())
                    Text("画像をコピーしています…")
                }
                if (error.isNotEmpty()) Text(error, color = MaterialTheme.colorScheme.error)
            }
        },
        confirmButton = {
            TextButton(enabled = !isSaving, onClick = {
                val trimmed = name.trim()
                val m = if (minutes.isEmpty()) 0 else minutes.toIntOrNull()
                val s = if (seconds.isEmpty()) 0 else seconds.toIntOrNull()
                if (trimmed.length !in 1..20 || m == null || s == null || m !in 0..99 || s !in 0..59 || m * 60 + s == 0) {
                    error = "名前は1〜20文字、時間は00:01〜99:59で入力してください"
                } else {
                    val uriToCopy = selectedUri
                    val existingImage = imageReference
                    isSaving = true
                    scope.launch {
                        try {
                            val savedImage = if (uriToCopy != null) {
                                imageStore.copyFrom(uriToCopy)
                            } else existingImage
                            onSave(trimmed, m * 60 + s, savedImage)
                        } catch (cancelled: CancellationException) {
                            throw cancelled
                        } catch (exception: Exception) {
                            error = exception.message ?: "画像を保存できませんでした。別の画像を選んでください。"
                        } finally {
                            isSaving = false
                        }
                    }
                }
            }) { Text("保存") }
        },
        dismissButton = {
            Row {
                if (preset != null && !preset.isBuiltIn) {
                    TextButton(onClick = onDelete, enabled = !isSaving) {
                        Text("削除", color = MaterialTheme.colorScheme.error)
                    }
                }
                TextButton(onClick = onDismiss, enabled = !isSaving) { Text("キャンセル") }
            }
        }
    )
}

// 8. 壁紙・ボタン配置の設定。画像保存は既存のButtonImageStoreを再利用する。
@Composable
private fun DisplaySettingsDialog(
    currentWallpaper: String?,
    imageStore: ButtonImageStore,
    rearrangeMode: Boolean,
    onDismiss: () -> Unit,
    onSaveWallpaper: (String?) -> Unit,
    onToggleArrange: () -> Unit
) {
    var imageReference by remember(currentWallpaper) { mutableStateOf(currentWallpaper) }
    var selectedUri by remember(currentWallpaper) { mutableStateOf<Uri?>(null) }
    var saving by remember { mutableStateOf(false) }
    var error by remember { mutableStateOf("") }
    val scope = rememberCoroutineScope()
    val imagePicker = rememberLauncherForActivityResult(ActivityResultContracts.GetContent()) { uri ->
        if (uri != null) {
            selectedUri = uri
            imageReference = uri.toString()
            error = ""
        }
    }
    val preview = rememberButtonImage(imageReference)

    AlertDialog(
        onDismissRequest = { if (!saving) onDismiss() },
        title = { Text("ワンタッチタイマー設定") },
        text = {
            Column(
                modifier = Modifier.verticalScroll(rememberScrollState()),
                verticalArrangement = Arrangement.spacedBy(10.dp)
            ) {
                Text("壁紙を変更", style = MaterialTheme.typography.titleMedium)
                if (preview != null) {
                    Image(bitmap = preview, contentDescription = "壁紙プレビュー",
                        modifier = Modifier.fillMaxWidth().height(160.dp),
                        contentScale = ContentScale.Fit)
                } else {
                    Text(if (imageReference == null) "現在の壁紙：なし" else "プレビューできません")
                }
                OutlinedButton(onClick = { imagePicker.launch("image/*") }, enabled = !saving) {
                    Text("画像を選択・変更")
                }
                Text(
                    text = "推奨画像サイズ：1080 × 2400 px（縦長）\n" +
                            "※画面サイズによって画像の端が切れる場合があります。",
                    fontSize = 12.sp,
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )
                TextButton(onClick = {
                    imageReference = null
                    selectedUri = null
                    error = ""
                }, enabled = !saving && imageReference != null) { Text("壁紙を外す") }
                Button(enabled = !saving, onClick = {
                    saving = true
                    scope.launch {
                        try {
                            val fileName = if (selectedUri != null) imageStore.copyFrom(selectedUri!!)
                            else imageReference
                            onSaveWallpaper(fileName)
                        } catch (cancelled: CancellationException) {
                            throw cancelled
                        } catch (exception: Exception) {
                            error = exception.message ?: "壁紙を保存できませんでした"
                        } finally {
                            saving = false
                        }
                    }
                }) { Text("壁紙を保存") }
                if (saving) LinearProgressIndicator(Modifier.fillMaxWidth())
                if (error.isNotEmpty()) Text(error, color = MaterialTheme.colorScheme.error)
                HorizontalDivider()
                Text("ボタンの配置変更", style = MaterialTheme.typography.titleMedium)
                Text("2つのボタンを順にタップすると位置を交換します。既存のボタンとカスタムボタンの両方に対応しています。")
                Button(onClick = onToggleArrange, enabled = !saving) {
                    Text(if (rearrangeMode) "配置変更モードを終了" else "配置変更モードを開始")
                }
            }
        },
        confirmButton = {
            TextButton(enabled = !saving, onClick = onDismiss) { Text("閉じる") }
        }
    )
}

// 9. 画像処理：外部の画像への参照ではなく、元の画像データを内部へコピーする。
// 画像の読み込み・コピーはバックグラウンドで行い、画面操作を止めない。
private class ButtonImageStore(private val context: Context) {
    private val directory get() = File(context.filesDir, "button_images")

    suspend fun copyFrom(uri: Uri): String = withContext(Dispatchers.IO) {
        if (!directory.exists() && !directory.mkdirs()) throw IOException("画像の保存場所を作れませんでした")
        val file = File(directory, "button_${UUID.randomUUID()}.img")
        var complete = false
        try {
            val input = context.contentResolver.openInputStream(uri)
                ?: throw IOException("画像を開けませんでした")
            input.use { source ->
                file.outputStream().use { destination ->
                    val buffer = ByteArray(8192)
                    var total = 0L
                    while (true) {
                        currentCoroutineContext().ensureActive()
                        val count = source.read(buffer)
                        if (count == -1) break
                        total += count
                        if (total > MAX_BYTES) throw IOException("画像は25MB以下のものを選んでください")
                        destination.write(buffer, 0, count)
                    }
                    if (total == 0L) throw IOException("画像が空でした。別の画像を選んでください")
                }
            }
            // 画像として表示できることを確認してから保存を確定する。
            val bitmap = decode(file.name) ?: throw IOException("この画像形式は表示できません。別の画像を選んでください")
            bitmap.recycle()
            currentCoroutineContext().ensureActive()
            complete = true
            file.name // 絶対パスを保存せず、アプリ内のファイル名だけ記録。
        } finally {
            if (!complete) file.delete()
        }
    }

    fun decode(reference: String): Bitmap? {
        return try {
            val uri = if (reference.startsWith("content://")) Uri.parse(reference) else null
            val file = if (uri == null) managedFile(reference) ?: return null else null
            if (file != null && !file.isFile) return null
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
                val source = if (uri != null) ImageDecoder.createSource(context.contentResolver, uri)
                else ImageDecoder.createSource(file!!)
                ImageDecoder.decodeBitmap(source) { decoder, info, _ ->
                    decoder.allocator = ImageDecoder.ALLOCATOR_SOFTWARE
                    val longest = maxOf(info.size.width, info.size.height)
                    if (longest > PREVIEW_SIZE) {
                        val ratio = PREVIEW_SIZE.toFloat() / longest
                        decoder.setTargetSize((info.size.width * ratio).toInt().coerceAtLeast(1),
                            (info.size.height * ratio).toInt().coerceAtLeast(1))
                    }
                }
            } else {
                // Android 8以前：画像全体をそのままメモリへ展開せず縮小して読み込む。
                fun open() = if (uri != null) context.contentResolver.openInputStream(uri) else file!!.inputStream()
                val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
                open()?.use { BitmapFactory.decodeStream(it, null, bounds) }
                if (bounds.outWidth <= 0 || bounds.outHeight <= 0) return null
                var sample = 1
                while (maxOf(bounds.outWidth, bounds.outHeight) / sample > PREVIEW_SIZE) sample *= 2
                val options = BitmapFactory.Options().apply { inSampleSize = sample }
                val bitmap = open()?.use { BitmapFactory.decodeStream(it, null, options) } ?: return null
                // 写真のEXIF情報に従って、縦向き・反転を補正する。
                val orientation = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) runCatching {
                    open()?.use { ExifInterface(it).getAttributeInt(ExifInterface.TAG_ORIENTATION,
                        ExifInterface.ORIENTATION_NORMAL) }
                }.getOrNull() ?: ExifInterface.ORIENTATION_NORMAL else ExifInterface.ORIENTATION_NORMAL
                orientBitmap(bitmap, orientation)
            }
        } catch (_: Exception) { null }
    }

    fun deleteUnused(references: List<String>) {
        val keep = references.toSet()
        // コピー開始と起動時の片付けが重なっても、新しい画像は消さない。
        val cutoff = System.currentTimeMillis() - 60L * 60 * 1000
        directory.listFiles()?.filter { it.name.startsWith("button_") && it.name.endsWith(".img") }
            ?.forEach { if (it.name !in keep && it.lastModified() < cutoff) it.delete() }
    }

    private fun managedFile(name: String): File? {
        // この機能で作った画像以外のパスを読み書きしない。
        if (!name.startsWith("button_") || !name.endsWith(".img") || '/' in name || '\\' in name) return null
        return File(directory, name)
    }

    private fun orientBitmap(bitmap: Bitmap, orientation: Int): Bitmap {
        val matrix = Matrix()
        when (orientation) {
            ExifInterface.ORIENTATION_FLIP_HORIZONTAL -> matrix.setScale(-1f, 1f)
            ExifInterface.ORIENTATION_ROTATE_180 -> matrix.setRotate(180f)
            ExifInterface.ORIENTATION_FLIP_VERTICAL -> matrix.setScale(1f, -1f)
            ExifInterface.ORIENTATION_TRANSPOSE -> { matrix.setRotate(90f); matrix.postScale(-1f, 1f) }
            ExifInterface.ORIENTATION_ROTATE_90 -> matrix.setRotate(90f)
            ExifInterface.ORIENTATION_TRANSVERSE -> { matrix.setRotate(-90f); matrix.postScale(-1f, 1f) }
            ExifInterface.ORIENTATION_ROTATE_270 -> matrix.setRotate(-90f)
            else -> return bitmap
        }
        val oriented = Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
        if (oriented !== bitmap) bitmap.recycle()
        return oriented
    }

    companion object {
        private const val MAX_BYTES = 25L * 1024 * 1024
        private const val PREVIEW_SIZE = 512
    }
}

@Composable
private fun rememberButtonImage(reference: String?): ImageBitmap? {
    val context = LocalContext.current
    val store = remember(context) { ButtonImageStore(context.applicationContext) }
    val image by produceState<ImageBitmap?>(initialValue = null, key1 = reference) {
        value = null
        if (reference != null) {
            value = withContext(Dispatchers.IO) { store.decode(reference)?.asImageBitmap() }
        }
    }
    return image
}

@Composable
private fun NumberInputField(value: String, label: String, enabled: Boolean = true, onValueChange: (String) -> Unit) {
    OutlinedTextField(value = value, enabled = enabled,
        onValueChange = { if (it.length <= 2 && it.all { char -> char in '0'..'9' }) onValueChange(it) },
        label = { Text(label) }, singleLine = true,
        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number))
}