A!leys Galerie

```kotlin
import android.app.NotificationChannel
import android.app.NotificationManager
import android.content.Context
import android.os.Build
import androidx.compose.foundation.Canvas
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Chapter
import androidx.compose.material.icons.filled.Palette
import androidx.compose.material.icons.filled.Pause
import androidx.compose.material.icons.filled.PlayArrow
import androidx.compose.material.icons.filled.Restore
import androidx.compose.material.icons.filled.Stop
import androidx.compose.material.icons.filled.Timer
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.SnackbarHost
import androidx.compose.material3.SnackbarHostState
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.drawscope.Stroke
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.core.app.NotificationCompat
import androidx.core.app.NotificationManagerCompat
import kotlinx.coroutines.delay
import kotlinx.coroutines.isActive
import java.util.Calendar
import java.util.Locale
import kotlin.time.Duration
import kotlin.time.Duration.Companion.seconds

//Art Prompts for focus breaks
val artisticPrompts = listOf(
    "Skizziere ein Objekt aus deinem täglichen Leben in nur 30 Sekunden mit einer abstrakten Farbpalette.",
    "Schreibe einen Haiku über das, was dich gerade umgibt — aber mit einer unerwarteten Metapher.",
    "Erfindet eine fantastische Kreatur und beschreibt sie in einem Satz.",
    "Malt eine lineare Zeichnung (nur Linien, keine Füllung) die deine aktuelle Stimmung darstellt.",
    "Denkt an eine einfache Form (Kreis, Quadrat) und transformiert sie in etwas völlig Neues."
)

sealed class TimerState {
    object Stopped : TimerState()
    data class Running(val remainingTime: Duration, val isWorkSession: Boolean) : TimerState()
    object Paused : TimerState()
}

@Composable
fun PomodoroApp() {
    val context = LocalContext.current
    val snackbarHostState = remember { SnackbarHostState() }
    var timerState by rememberSaveable { mutableStateOf<TimerState>(TimerState.Stopped) }
    var workDuration by rememberSaveable { mutableStateOf(25.seconds) }
    var restDuration by rememberSaveable { mutableStateOf(5.seconds) }
    var currentSession by rememberSaveable { mutableStateOf(1) }
    var isWorkSession by rememberSaveable { mutableStateOf(true) }

    // Initialize notification channel
    LaunchedEffect(Unit) {
        createNotificationChannel(context)
    }

    Scaffold(
        snackbarHost = { SnackbarHost(snackbarHostState) },
        modifier = Modifier.fillMaxSize()
    ) { padding ->
        Surface(
            modifier = Modifier
                .padding(padding)
                .fillMaxSize(),
            color = MaterialTheme.colorScheme.background
        ) {
            Column(
                modifier = Modifier
                    .fillMaxSize()
                    .padding(16.dp),
                verticalArrangement = Arrangement.SpaceBetween,
                horizontalAlignment = Alignment.CenterHorizontally
            ) {
                TimerDisplay(
                    timerState = timerState,
                    remainingTime = if (timerState is TimerState.Running) (timerState as TimerState.Running).remainingTime else null,
                    isWorkSession = isWorkSession,
                    onTimeUpdated = { newWork, newRest ->
                        workDuration = newWork.seconds
                        restDuration = newRest.seconds
                        snackbarHostState.showMessage("Updated timer durations!")
                    }
                )

                TimerControls(
                    timerState = timerState,
                    onStart = {
                        timerState = TimerState.Running(Duration.infinite, true)
                        isWorkSession = true
                        currentSession = 1
                        startTimer(context, workDuration)
                    },
                    onPause = {
                        timerState = TimerState.Paused
                        cancelTimer(context)
                    },
                    onStop = {
                        timerState = TimerState.Stopped
                        cancelTimer(context)
                    },
                    onReset = {
                        timerState = TimerState.Stopped
                        cancelTimer(context)
                        currentSession = 1
                        isWorkSession = true
                    },
                    onSessionComplete = {
                        // This is called when timer completes (via TimerManager)
                        if (timerState is TimerState.Running) {
                            val completedDuration = (timerState as TimerState.Running).remainingTime
                            if (completedDuration.isZero()) {
                                currentSession++
                                isWorkSession = !isWorkSession
                                val nextDuration = if (isWorkSession) workDuration else restDuration
                                timerState = TimerState.Running(nextDuration, isWorkSession)
                                startTimer(context, nextDuration)
                                showNotification(
                                    context,
                                    "Session completed!",
                                    if (isWorkSession) "Time to rest!" else "Ready for the next work session!",
                                    currentSession
                                )
                            }
                        }
                    }
                )
            }
        }
    }
}

@Composable
fun TimerDisplay(
    timerState: TimerState,
    remainingTime: Duration?,
    isWorkSession: Boolean,
    onTimeUpdated: (Duration, Duration) -> Unit
) {
    val workSessionColor = if (isWorkSession) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.secondary
    val backgroundColor = if (isWorkSession) MaterialTheme.colorScheme.primaryContainer else MaterialTheme.colorScheme.secondaryContainer

    Column(
        horizontalAlignment = Alignment.CenterHorizontally,
        modifier = Modifier.weight(1f)
    ) {
        // Artistic focus break suggestion
        if (timerState is TimerState.Paused || timerState is TimerState.Stopped) {
            ArtisticPromptDisplay(
                isWorkSession = isWorkSession,
                onTimeUpdated = onTimeUpdated
            )
        }

        // Timer visualization
        when (timerState) {
            is TimerState.Running -> {
                val progress = 1f - (remainingTime?.inSeconds?.toFloat() ?: 1f) / 25f
                val animatedProgress = remember { mutableStateOf(0f) }
                LaunchedEffect(remainingTime) {
                    while (isActive) {
                        animatedProgress.value = (animatedProgress.value + 0.05f).coerceAtMost(1f)
                        delay(50)
                    }
                }

                // Progress indicator with artistic brush effect
                Box(
                    modifier = Modifier
                        .fillMaxWidth()
                        .height(20.dp),
                    contentAlignment = Alignment.CenterEnd
                ) {
                    Canvas(
                        modifier = Modifier
                            .fillMaxWidth()
                            .height(20.dp)
                    ) {
                        val brush = Brush.linear(
                            start = Offset(0f, size.height / 2),
                            end = Offset(size.width, size.height / 2),
                            colors = listOf(
                                Color.Transparent,
                                workSessionColor,
                                Color.Transparent
                            )
                        )
                        drawRect(
                            brush = brush,
                            size = size
                        )
                        drawLine(
                            color = workSessionColor,
                            start = Offset(0f, size.height / 2),
                            end = Offset(size.width * (1 - progress), size.height / 2),
                            strokeWidth = 2.dp.toPx()
                        )
                    }
                    Text(
                        text = formatDuration(remainingTime),
                        color = workSessionColor,
                        fontSize = 18.sp,
                        fontWeight = FontWeight.Bold,
                        textAlign = TextAlign.End,
                        modifier = Modifier.padding(end = 8.dp)
                    )
                }

                // Circular progress with artistic stroke
                Box(
                    contentAlignment = Alignment.Center,
                    modifier = Modifier
                        .size(120.dp)
                        .padding(vertical = 16.dp)
                ) {
                    Canvas(modifier = Modifier.size(120.dp)) {
                        val circleRadius = size.minDimension / 2 - Stroke(4.dp.toPx()).strokeWidth / 2
                        drawCircle(
                            color = workSessionColor.copy(alpha = 0.2f),
                            radius = circleRadius,
                            center = center
                        )
                        drawCircle(
                            color = workSessionColor,
                            radius = circleRadius,
                            center = center,
                            style = Stroke(width = 4.dp.toPx())
                        )
                        drawArc(
                            color = workSessionColor,
                            startAngle = -90f,
                            sweepAngle = 360f * animatedProgress.value,
                            useCenter = false,
                            size = Size(circleRadius * 2, circleRadius * 2),
                            topLeft = Offset(center.x - circleRadius, center.y - circleRadius),
                            style = Stroke(width = 4.dp.toPx())
                        )
                    }
                    Text(
                        text = if (isWorkSession) "WORK" else "REST",
                        color = workSessionColor,
                        fontSize = 14.sp,
                        fontWeight = FontWeight.Medium,
                        modifier = Modifier.align(Alignment.BottomCenter)
                    )
                }

                // Session counter
                Text(
                    text = "Session ${currentSession}",
                    color = workSessionColor.copy(alpha = 0.7f),
                    fontSize = 12.sp,
                    fontWeight = FontWeight.Medium,
                    modifier = Modifier.align(Alignment.BottomCenter)
                )
            }
            TimerState.Stopped -> {
                Box(
                    modifier = Modifier
                        .size(120.dp)
                        .padding(vertical = 16.dp),
                    contentAlignment = Alignment.Center
                ) {
                    Icon(
                        Icons.Default.Timer,
                        contentDescription = "Timer",
                        tint = workSessionColor,
                        modifier = Modifier.size(60.dp)
                    )
                }
            }
            TimerState.Paused -> {
                Box(
                    modifier = Modifier
                        .size(120.dp)
                        .padding(vertical = 16.dp),
                    contentAlignment = Alignment.Center
                ) {
                    Icon(
                        Icons.Default.Pause,
                        contentDescription = "Paused",
                        tint = workSessionColor,
                        modifier = Modifier.size(60.dp)
                    )
                }
            }
        }
    }
}

@Composable
fun TimerControls(
    timerState: TimerState,
    onStart: () -> Unit,
    onPause: () -> Unit,
    onStop: () -> Unit,
    onReset: () -> Unit,
    onSessionComplete: () -> Unit
) {
    Column(
        horizontalAlignment = Alignment.CenterHorizontally,
        modifier = Modifier
            .fillMaxWidth()
            .padding(vertical = 16.dp)
    ) {
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceEvenly
        ) {
            // Settings button
            IconButton(
                onClick = {
                    // Would open settings dialog in a real app
                }
            ) {
                Icon(
                    Icons.Default.Chapter,
                    contentDescription = "Settings",
                    tint = MaterialTheme.colorScheme.onBackground
                )
            }

            // Start/Pause/Stop buttons
            when (timerState) {
                is TimerState.Running -> {
                    Button(
                        onClick = onPause,
                        colors = ButtonDefaults.buttonColors(
                            containerColor = MaterialTheme.colorScheme.secondaryContainer,
                            contentColor = MaterialTheme.colorScheme.onSecondaryContainer
                        ),
                        modifier = Modifier
                            .height(56.dp)
                            .weight(1f)
                    ) {
                        Icon(Icons.Default.Pause, "Pause")
                    }
                    Spacer(modifier = Modifier.width(8.dp))
                    Button(
                        onClick = onStop,
                        colors = ButtonDefaults.buttonColors(
                            containerColor = MaterialTheme.colorScheme.errorContainer,
                            contentColor = MaterialTheme.colorScheme.onErrorContainer
                        ),
                        modifier = Modifier
                            .height(56.dp)
                            .weight(1f)
                    ) {
                        Icon(Icons.Default.Stop, "Stop")
                    }
                }
                is TimerState.Paused -> {
                    Button(
                        onClick = onStart,
                        colors = ButtonDefaults.buttonColors(
                            containerColor = MaterialTheme.colorScheme.primaryContainer,
                            contentColor = MaterialTheme.colorScheme.onPrimaryContainer
                        ),
                        modifier = Modifier
                            .height(56.dp)
                            .weight(1f)
                    ) {
                        Icon(Icons.Default.PlayArrow, "Resume")
                    }
                    Spacer(modifier = Modifier.width(8.dp))
                    Button(
                        onClick = onStop,
                        colors = ButtonDefaults.buttonColors(
                            containerColor = MaterialTheme.colorScheme.errorContainer,
                            contentColor = MaterialTheme.colorScheme.onErrorContainer
                        ),
                        modifier = Modifier
                            .height(56.dp)
                            .weight(1f)
                    ) {
                        Icon(Icons.Default.Stop, "Stop")
                    }
                }
                is TimerState.Stopped -> {
                    Button(
                        onClick = onStart,
                        colors = ButtonDefaults.buttonColors(
                            containerColor = MaterialTheme.colorScheme.primaryContainer,
                            contentColor = MaterialTheme.colorScheme.onPrimaryContainer
                        ),
                        modifier = Modifier
                            .height(56.dp)
                            .weight(1f)
                    ) {
                        Icon(Icons.Default.PlayArrow, "Start")
                    }
                    Spacer(modifier = Modifier.width(8.dp))
                    Button(
                        onClick = onReset,
                        colors = ButtonDefaults.buttonColors(
                            containerColor = MaterialTheme.colorScheme.tertiaryContainer,
                            contentColor = MaterialTheme.colorScheme.onTertiaryContainer
                        ),
                        modifier = Modifier
                            .height(56.dp)
                            .weight(1f)
                    ) {
                        Icon(Icons.Default.Restore, "Reset")
                    }
                }
            }
        }

        // Artistic focus button (visible during work sessions)
        if (timerState is TimerState.Running && (timerState as TimerState.Running).isWorkSession) {
            TextButton(
                onClick = {
                    val prompt = artisticPrompts.random()
                    snackbarHostState.showMessage("Artistic Focus: $prompt")
                },
                modifier = Modifier.padding(top = 8.dp)
            ) {
                Row(
                    verticalAlignment = Alignment.CenterVertically
                ) {
                    Icon(Icons.Default.Palette, contentDescription = "Artistic Focus", modifier = Modifier.size(ButtonDefaults.IconSize))
                    Spacer(modifier = Modifier.width(4.dp))
                    Text("Artistic Focus", fontSize = 12.sp)
                }
            }
        }
    }
}

@Composable
fun ArtisticPromptDisplay(
    isWorkSession: Boolean,
    onTimeUpdated: (Duration, Duration) -> Unit
) {
    Column(
        horizontalAlignment = Alignment.CenterHorizontally,
        modifier = Modifier.padding(top = 32.dp)
    ) {
        Text(
            text = if (isWorkSession) "WORK SESSION COMPLETED!" else "REST SESSION COMPLETED!",
            color = if (isWorkSession) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.secondary,
            fontSize = 20.sp,
            fontWeight = FontWeight.Bold,
            textAlign = TextAlign.Center,
            modifier = Modifier.fillMaxWidth()
        )

        Spacer(modifier = Modifier.height(16.dp))

        // Artistic prompt display
        val prompt = artisticPrompts.random()
        Text(
            text = prompt,
            color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.7f),
            fontSize = 16.sp,
            fontWeight = FontWeight.Medium,
            textAlign = TextAlign.Center,
            modifier = Modifier.fillMaxWidth()
        )

        Spacer(modifier = Modifier.height(32.dp))

        // Session time customization
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceEvenly
        ) {
            Column(
                horizontalAlignment = Alignment.CenterHorizontally
            ) {
                Text("Work:", fontSize = 12.sp, fontWeight = FontWeight.Medium)
                Spacer(modifier = Modifier.height(4.dp))
                Text(
                    text = "${workDuration.inWholeMinutes}m",
                    fontSize = 16.sp,
                    fontWeight = FontWeight.Bold
                )
            }

            Column(
                horizontalAlignment = Alignment.CenterHorizontally
            ) {
                Text("Rest:", fontSize = 12.sp, fontWeight = FontWeight.Medium)
                Spacer(modifier = Modifier.height(4.dp))
                Text(
                    text = "${restDuration.inWholeMinutes}m",
                    fontSize = 16.sp,
                    fontWeight = FontWeight.Bold
                )
            }
        }

        Spacer(modifier = Modifier.height(16.dp))

        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceEvenly
        ) {
            // Work duration adjustment
            IconButton(
                onClick = { onTimeUpdated(workDuration + 1.minutes,