A!leys Galerie

import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Delete
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import java.text.DecimalFormat
import kotlin.math.pow

@Composable
fun CalculatorApp() {
    var currentInput by remember { mutableStateOf("") }
    var history by remember { mutableStateOf(listOf<CalculatorEntry>()) }
    var memory by remember { mutableStateOf(0.0) }
    var theme by remember { mutableStateOf(Theme.Light) }

    // Theme colors
    val backgroundColor = when (theme) {
        Theme.Light -> MaterialTheme.colorScheme.surface
        Theme.Dark -> MaterialTheme.colorScheme.surfaceVariant
    }

    val buttonTextColor = when (theme) {
        Theme.Light -> MaterialTheme.colorScheme.onSurface
        Theme.Dark -> MaterialTheme.colorScheme.onSurfaceVariant
    }

    val primaryButtonColor = when (theme) {
        Theme.Light -> MaterialTheme.colorScheme.primary
        Theme.Dark -> MaterialTheme.colorScheme.primaryContainer
    }

    val secondaryButtonColor = when (theme) {
        Theme.Light -> primaryButtonColor.copy(alpha = 0.7f)
        Theme.Dark -> primaryButtonColor.copy(alpha = 0.5f)
    }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .background(backgroundColor)
            .padding(16.dp),
        verticalArrangement = Arrangement.SpaceBetween
    ) {
        // History Section
        Box(modifier = Modifier.weight(1f)) {
            LazyColumn(
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(8.dp),
                reverseLayout = true
            ) {
                items(history) { entry ->
                    CalculatorHistoryItem(
                        entry = entry,
                        onClear = { history = history - entry },
                        onThemeChange = { theme = it },
                        currentTheme = theme
                    )
                }
            }
            if (history.isEmpty()) {
                Text(
                    text = "No history yet 📊",
                    modifier = Modifier
                        .align(Alignment.CenterHorizontally)
                        .padding(16.dp),
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )
            }
        }

        // Calculator Display
        TextField(
            value = currentInput,
            onValueChange = { newValue ->
                if (newValue.length <= 20) {
                    currentInput = newValue
                }
            },
            modifier = Modifier
                .fillMaxWidth()
                .height(64.dp)
                .padding(8.dp)
                .clip(RoundedCornerShape(8.dp))
                .background(MaterialTheme.colorScheme.outlineVariant),
            keyboardOptions = KeyboardOptions.Default.copy(
                keyboardType = KeyboardType.NumberPassword
            ),
            singleLine = true,
            textStyle = MaterialTextStyle(
                headlineMedium,
                color = buttonTextColor
            ),
            readOnly = true
        )

        // Calculator Buttons
        Column(
            modifier = Modifier
                .fillMaxWidth()
                .padding(8.dp)
        ) {
            Row(
                modifier = Modifier.fillMaxWidth(),
                horizontalArrangement = Arrangement.SpaceBetween
            ) {
                CalculatorButton(
                    text = "C",
                    onClick = { currentInput = "" },
                    color = if (theme == Theme.Light) Color.Red else Color.Red.copy(alpha = 0.7f)
                )
                CalculatorButton(
                    text = "⌫",
                    onClick = { currentInput = currentInput.dropLast(1) },
                    icon = Icons.Default.Delete,
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "M+",
                    onClick = {
                        memory += currentInput.toDoubleOrNull() ?: 0.0
                    },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "M-",
                    onClick = {
                        memory -= currentInput.toDoubleOrNull() ?: 0.0
                    },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "MC",
                    onClick = { memory = 0.0 },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "MR",
                    onClick = { currentInput = memory.toString() },
                    color = secondaryButtonColor
                )
            }

            Row(
                modifier = Modifier.fillMaxWidth(),
                horizontalArrangement = Arrangement.SpaceBetween
            ) {
                CalculatorButton(
                    text = "7",
                    onClick = { currentInput += "7" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "8",
                    onClick = { currentInput += "8" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "9",
                    onClick = { currentInput += "9" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "÷",
                    onClick = { currentInput += "/" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "🔺",
                    onClick = { currentInput += "^" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "√",
                    onClick = { currentInput += "√" },
                    color = secondaryButtonColor
                )
            }

            Row(
                modifier = Modifier.fillMaxWidth(),
                horizontalArrangement = Arrangement.SpaceBetween
            ) {
                CalculatorButton(
                    text = "4",
                    onClick = { currentInput += "4" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "5",
                    onClick = { currentInput += "5" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "6",
                    onClick = { currentInput += "6" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "×",
                    onClick = { currentInput += "*" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "sin",
                    onClick = { currentInput += "sin(" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "cos",
                    onClick = { currentInput += "cos(" },
                    color = secondaryButtonColor
                )
            }

            Row(
                modifier = Modifier.fillMaxWidth(),
                horizontalArrangement = Arrangement.SpaceBetween
            ) {
                CalculatorButton(
                    text = "1",
                    onClick = { currentInput += "1" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "2",
                    onClick = { currentInput += "2" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "3",
                    onClick = { currentInput += "3" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "-",
                    onClick = { currentInput += "-" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "tan",
                    onClick = { currentInput += "tan(" },
                    color = secondaryButtonColor
                )
            }

            Row(
                modifier = Modifier.fillMaxWidth(),
                horizontalArrangement = Arrangement.SpaceBetween
            ) {
                CalculatorButton(
                    text = "0",
                    onClick = { currentInput += "0" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = ".",
                    onClick = { currentInput += "." },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "=",
                    onClick = {
                        val result = try {
                            evaluateExpression(currentInput)
                        } catch (e: Exception) {
                            "Error"
                        }
                        if (result != "Error") {
                            history = listOf(
                                CalculatorEntry(
                                    expression = currentInput,
                                    result = result,
                                    emoji = getRandomEmoji()
                                )
                            ) + history
                        }
                        currentInput = result
                    },
                    color = primaryButtonColor
                )
                CalculatorButton(
                    text = "+",
                    onClick = { currentInput += "+" },
                    color = secondaryButtonColor
                )
                CalculatorButton(
                    text = "🔄",
                    onClick = { theme = if (theme == Theme.Light) Theme.Dark else Theme.Light },
                    color = primaryButtonColor
                )
            }
        }
    }
}

@Composable
fun CalculatorButton(
    text: String,
    onClick: () -> Unit,
    color: Color,
    icon: androidx.compose.ui.graphics.vector.ImageVector? = null
) {
    Button(
        onClick = onClick,
        modifier = Modifier
            .size(56.dp)
            .weight(1f)
            .padding(4.dp),
        colors = ButtonDefaults.buttonColors(
            containerColor = color,
            contentColor = MaterialTheme.colorScheme.onPrimaryContainer
        ),
        shape = RoundedCornerShape(24.dp)
    ) {
        if (icon != null) {
            Icon(icon, contentDescription = null, modifier = Modifier.size(24.dp))
        } else {
            Text(
                text = text,
                fontSize = 18.sp,
                fontWeight = FontWeight.Bold,
                modifier = Modifier.padding(4.dp)
            )
        }
    }
}

@Composable
fun CalculatorHistoryItem(
    entry: CalculatorEntry,
    onClear: () -> Unit,
    onThemeChange: (Theme) -> Unit,
    currentTheme: Theme
) {
    Row(
        modifier = Modifier
            .fillMaxWidth()
            .padding(vertical = 4.dp),
        verticalAlignment = Alignment.CenterVertically
    ) {
        Text(
            text = "${entry.expression} =",
            fontSize = 14.sp,
            color = MaterialTheme.colorScheme.onSurfaceVariant
        )
        Text(
            text = entry.result,
            fontSize = 14.sp,
            fontWeight = FontWeight.Bold,
            color = MaterialTheme.colorScheme.onSurface
        )
        Text(
            text = " ${entry.emoji}",
            fontSize = 16.sp,
            fontWeight = FontWeight.Bold,
            color = MaterialTheme.colorScheme.primary
        )
        IconButton(
            onClick = onClear,
            modifier = Modifier.weight(1f),
            colors = IconButtonDefaults.iconButtonColors(
                containerColor = if (currentTheme == Theme.Light) Color.LightGray else Color.DarkGray
            )
        ) {
            Icon(Icons.Default.Delete, contentDescription = "Clear")
        }
        IconButton(
            onClick = { onThemeChange(if (currentTheme == Theme.Light) Theme.Dark else Theme.Light) },
            modifier = Modifier,
            colors = IconButtonDefaults.iconButtonColors(
                containerColor = if (currentTheme == Theme.Light) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.primaryContainer
            )
        ) {
            Icon(
                imageVector = if (currentTheme == Theme.Light) Icons.Default.DarkMode else Icons.Default.LightMode,
                contentDescription = "Toggle theme"
            )
        }
    }
}

private fun evaluateExpression(expression: String): String {
    return try {
        val cleaned = expression.replace("√", "sqrt(")
            .replace(")", ")")
            .replace("^", " ** ")
            .replace("🔺", "**")
            .replace("sin", "math.sin")
            .replace("cos", "math.cos")
            .replace("tan", "math.tan")
        val result = eval(cleaned)
        DecimalFormat("#.####").format(result)
    } catch (e: Exception) {
        "Error"
    }
}

private fun eval(expr: String): Double {
    return object {
        private var pos = 0
        private val len = expr.length

        fun parse(): Double {
            return parseExpression()
        }

        private fun parseExpression(): Double {
            var result = parseTerm()
            while (pos < len) {
                when (expr[pos]) {
                    '+' -> {
                        pos++
                        result += parseTerm()
                    }
                    '-' -> {
                        pos++
                        result -= parseTerm()
                    }
                    else -> break
                }
            }
            return result
        }

        private fun parseTerm(): Double {
            var result = parseFactor()
            while (pos < len) {
                when (expr[pos]) {
                    '*' -> {
                        pos++
                        result *= parseFactor()
                    }
                    '/' -> {
                        pos++
                        val divisor = parseFactor()
                        if (divisor == 0.0) throw ArithmeticException("Division by zero")
                        result /= divisor
                    }
                    else -> break
                }
            }
            return result
        }

        private fun parseFactor(): Double {
            return when {
                expr.startsWith("sqrt(", pos) -> {
                    pos += 5
                    val result = parseExpression()
                    pos++ // skip ')'
                    Math.sqrt(result)
                }
                expr.startsWith("math.sin(", pos) -> {
                    pos += 9
                    val result = parseExpression()
                    pos++ // skip ')'
                    Math.sin(Math.toRadians(result))
                }
                expr.startsWith("math.cos(", pos) -> {
                    pos += 9
                    val result = parseExpression()
                    pos++ // skip ')'
                    Math.cos(Math.toRadians(result))
                }
                expr.startsWith("math.tan(", pos) -> {
                    pos += 9
                    val result = parseExpression()
                    pos++ // skip ')'
                    Math.tan(Math.toRadians(result))
                }
                expr[pos] == '-' -> {
                    pos++
                    -parseFactor()
                }
                expr[pos] == '(' -> {
                    pos++
                    val result = parseExpression()
                    pos++ // skip ')'
                    result
                }
                else -> parseNumber()
            }
        }

        private fun parseNumber(): Double {
            var num = 0.0
            var decimal = 1.0
            var afterDecimal = false

            while (pos < len && (expr[pos].isDigit() || expr[pos] == '.')) {
                if (expr[pos] == '.') {
                    afterDecimal = true
                    pos++
                    continue
                }
                val digit = expr[pos] - '0'
                if (afterDecimal) {
                    decimal /= 10.0
                    num += digit * decimal
                } else {
                    num = num * 10.0 + digit
                }
                pos++
            }
            return num
        }
    }.parse()
}

private fun getRandomEmoji(): String {
    val emojis = listOf("🌟", "✨", "🎉", "🎊", "🤩", "🤯", "😃", "😄", "😎", "😍", "😘", "😗", "😙", "😚", "😜", "😝", "😛", "😝", "😜", "😘", "🤩", "🎉", "🔥")
    return emojis.random()
}

data class CalculatorEntry(
    val expression: String,
    val result: String,
    val emoji: String
)

enum class Theme { Light, Dark }

@Preview(showBackground = true)
@Composable
fun CalculatorAppPreview() {
    MaterialTheme {
        CalculatorApp()
    }
}

using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using UnityEngine.Audio;

[RequireComponent(typeof(AudioSource))]
public class CelestialMusicMenu : MonoBehaviour
{
    [Header("Menu Settings")]
    [SerializeField] private float _starRotationSpeed = 1.5f;
    [SerializeField] private float _starScalePulseSpeed = 0.5f;
    [SerializeField] private float _starScalePulseAmount = 0.2f;
    [SerializeField] private AnimationCurve _musicIntensityCurve = AnimationCurve.EaseInOut(0, 0, 1, 1);
    [SerializeField] private float _menuTransitionTime = 0.8f;

    [Header("References")]
    [SerializeField] private Button _menuButtonPrefab;
    [SerializeField] private Transform _menuContainer;
    [SerializeField] private Image _backgroundImage;
    [SerializeField] private AudioClip _baseMusicClip;
    [SerializeField] private AudioClip _buttonHoverClip;
    [SerializeField] private AudioClip _buttonClickClip;
    [SerializeField] private ParticleSystem _starParticles;
    [SerializeField] private ParticleSystem _nebulas;

    private AudioSource _audioSource;
    private Button[] _menuButtons;
    private int _currentMenuIndex = 0;
    private bool _isTransitioning = false;
    private Color _originalBackgroundColor;
    private float _originalMusicVolume;

    private void Awake()
    {
        _audioSource = GetComponent<AudioSource>();
        _originalBackgroundColor = _backgroundImage.color;
        _originalMusicVolume = _audioSource.volume;

        // Initialize menu buttons
        _menuButtons = new Button[3];
        for (int i = 0; i < _menuButtons.Length; i++)
        {
            _menuButtons[i] = Instantiate(_menuButtonPrefab, _menuContainer);
            _menuButtons[i].GetComponentInChildren<Text>().text = $"Menu Item {i + 1}";
            _menuButtons[i].onClick.AddListener(() => OnMenuButtonClicked(i));
            _menuButtons[i].transform.localScale = Vector3.one * 0.8f;
            _menuButtons[i].transform.localPosition = new Vector3(0, -100 + (i * 100), 0);
            LeanTween.move(_menuButtons[i].gameObject, Vector3.zero, 0.5f).setEase(LeanTweenType.easeOutBounce);
        }

        // Start with the first menu button selected
        SelectMenuButton(_currentMenuIndex);

        // Start star particles and nebula effects
        _starParticles.Play();
        _nebulas.Play();

        // Fade in music
        LeanTween.value(_audioSource.gameObject, _originalMusicVolume, 0.5f, _t => _audioSource.volume = _t).setEase(LeanTweenType.easeOutQuad);
    }

    private void OnMenuButtonClicked(int index)
    {
        if (_isTransitioning) return;

        _isTransitioning = true;
        _audioSource.PlayOneShot(_buttonClickClip, 0.5f);

        // Deselect current button
        DeselectMenuButton(_currentMenuIndex);

        // Select new button
        SelectMenuButton(index);
        _currentMenuIndex = index;

        // Transition animation
        StartCoroutine(MenuTransition(index));

        // Adjust music intensity based on selected menu item
        AdjustMusicIntensity(index);
    }

    private IEnumerator MenuTransition(int targetIndex)
    {
        float elapsedTime = 0f;
        float lerpValue = 0f;

        while (elapsedTime < _menuTransitionTime)
        {
            elapsedTime += Time.deltaTime;
            lerpValue = Mathf.Clamp01(elapsedTime / _menuTransitionTime);

            // Pulse the selected button
            LeanTween.scale(_menuButtons[targetIndex].gameObject, Vector3.one * (1 + _starScalePulseAmount * 0.5f), 0.2f).setEase(LeanTweenType.easeInOutQuad);

            // Rotate all stars slightly
            _starParticles.transform.rotation = Quaternion.Euler(
                Mathf.Sin(Time.time * _starRotationSpeed) * 10f,
                Mathf.Cos(Time.time * _starRotationSpeed * 0.7f) * 15f,
                0
            );

            // Nebula glow effect
            var nebulaMain = _nebulas.main;
            nebulaMain.startColor = Color.Lerp(
                Color.blue,
                new Color(0.2f, 0.3f, 0.8f),
                Mathf.Sin(Time.time * 0.3f) * 0.5f + 0.5f
            );

            yield return null;
        }

        // Final button scale pulse
        LeanTween.scale(_menuButtons[targetIndex].gameObject, Vector3.one, 0.3f).setEase(LeanTweenType.easeOutBack);

        // Reset nebula color
        var finalNebulaColor = Color.Lerp(
            Color.blue,
            new Color(0.2f, 0.3f, 0.8f),
            Mathf.Sin(Time.time * 0.3f) * 0.5f + 0.5f
        );
        _nebulas.main.startColor = finalNebulaColor;

        _isTransitioning = false;
    }

    private void SelectMenuButton(int index)
    {
        _menuButtons[index].GetComponent<Image>().color = new Color(0.2f, 0.8f, 1f, 1f);
        _menuButtons[index].GetComponent<RectTransform>().localScale = Vector3.one * 1.2f;
    }

    private void DeselectMenuButton(int index)
    {
        _menuButtons[index].GetComponent<Image>().color = new Color(1f, 1f, 1f, 1f);
        _menuButtons[index].GetComponent<RectTransform>().localScale = Vector3.one;
    }

    private void AdjustMusicIntensity(int index)
    {
        // Get the music intensity based on the menu item index
        float intensity = _musicIntensityCurve.Evaluate((float)index / _menuButtons.Length);

        // Adjust pitch based on intensity
        _audioSource.pitch = 1f + (intensity * 0.2f - 0.1f);

        // Adjust reverb based on intensity
        if (_audioSource.outputAudioFilter != null)
        {
            _audioSource.outputAudioFilter.reverbMix = intensity * 0.5f;
        }
    }

    private void Update()
    {
        // Continuous star pulsing effect
        foreach (var particle in _starParticles.GetParticles(particleArray => particleArray))
        {
            particle.size = Mathf.PingPong(Time.time * _starScalePulseSpeed, _starScalePulseAmount) + 0.1f;
        }

        // Button hover effects
        if (Input.GetAxis("Mouse X") != 0 || Input.GetAxis("Mouse Y") != 0)
        {
            if (Input.GetKeyDown(KeyCode.Mouse0))
            {
                Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
                if (Physics.Raycast(ray, out RaycastHit hit))
                {
                    // Check if we hit a button
                    var button = hit.collider.GetComponent<Button>();
                    if (button != null)
                    {
                        _audioSource.PlayOneShot(_buttonHoverClip, 0.3f);
                    }
                }
            }
        }
    }

    // Visualizer effect that reacts to music
    private void OnAudioFilterRead(float[] data, int channels)
    {
        // This is a placeholder for a more sophisticated audio reactive effect
        // In a real implementation, you would analyze the audio data
        // and adjust visual elements accordingly
        var color = _backgroundImage.color;
        color.a = Mathf.Clamp01(Mathf.Abs(data[0] * 2)) * 0.1f;
        _backgroundImage.color = color;
    }

    public void SetBackgroundColor(Color color)
    {
        _originalBackgroundColor = color;
        _backgroundImage.color = color;
    }

    public void SetMenuItemText(int index, string text)
    {
        if (index >= 0 && index < _menuButtons.Length)
        {
            _menuButtons[index].GetComponentInChildren<Text>().text = text;
        }
    }
}

import android.media.AudioAttributes
import android.media.MediaPlayer
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
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.aspectRatio
import androidx.compose.foundation.layout.fillMaxSize
importdaki.compose.foundation.layout.fillMaxWidth
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.MoreVert
import androidx.compose.material.icons.filled.Pause
import androidx.compose.material.icons.filled.PlayArrow
import androidx.compose.material.icons.filled.SkipNext
import androidx.compose.material.icons.filled.SkipPrevious
import androidx.compose.material3.Card
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.Slider
import androidx.compose.material3.Surface
import androidx.compose.material3.Switch
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.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.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import kotlinx.coroutines.delay
import java.io.IOException

enum class TimerState {
    IDLE, WORK, SHORT_BREAK, LONG_BREAK, PAUSED
}

data class SessionConfig(
    val workMinutes: Int = 25,
    val shortBreakMinutes: Int = 5,
    val longBreakMinutes: Int = 15,
    val cyclesBeforeLongBreak: Int = 4,
    val useSoundscapes: Boolean = true
)

class ZenTimer : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MaterialTheme {
                Surface(modifier = Modifier.fillMaxSize()) {
                    ZenTimerApp()
                }
            }
        }
    }
}

@Composable
fun ZenTimerApp() {
    val context = LocalContext.current
    var sessionConfig by remember { mutableStateOf(SessionConfig()) }
    var timerState by remember { mutableStateOf(TimerState.IDLE) }
    var timeLeft by remember { mutableStateOf(sessionConfig.workMinutes) }
    var currentSession by remember { mutableStateOf(0) }
    var isPlaying by remember { mutableStateOf(false) }
    var mediaPlayer by remember { mutableStateOf<MediaPlayer?>(null) }
    var progress by remember { mutableStateOf(0f) }

    LaunchedEffect(timerState) {
        if (timerState != TimerState.PAUSED && timerState != TimerState.IDLE) {
            val totalTime = when (timerState) {
                TimerState.WORK -> sessionConfig.workMinutes * 60L
                TimerState.SHORT_BREAK -> sessionConfig.shortBreakMinutes * 60L
                TimerState.LONG_BREAK -> sessionConfig.longBreakMinutes * 60L
                else -> 0L
            }

            val startTime = System.currentTimeMillis()
            var remainingTime = totalTime

            while (remainingTime > 0 && timerState == when (timerState) {
                    TimerState.WORK -> TimerState.WORK
                    TimerState.SHORT_BREAK -> TimerState.SHORT_BREAK
                    TimerState.LONG_BREAK -> TimerState.LONG_BREAK
                    else -> false
                }) {
                delay(1000)
                remainingTime = (System.currentTimeMillis() - startTime) / 1000
                val timeLeftSeconds = (totalTime - remainingTime).toInt()
                timeLeft = timeLeftSeconds / 60
                progress = 1f - (timeLeftSeconds.toFloat() / totalTime.toFloat())

                if (remainingTime <= 1) {
                    when (timerState) {
                        TimerState.WORK -> {
                            currentSession++
                            if (currentSession < sessionConfig.cyclesBeforeLongBreak) {
                                timerState = TimerState.SHORT_BREAK
                                timeLeft = sessionConfig.shortBreakMinutes
                            } else {
                                timerState = TimerState.LONG_BREAK
                                timeLeft = sessionConfig.longBreakMinutes
                                currentSession = 0
                            }
                        }
                        TimerState.SHORT_BREAK, TimerState.LONG_BREAK -> {
                            timerState = TimerState.WORK
                            timeLeft = sessionConfig.workMinutes
                        }
                        else -> {}
                    }
                    break
                }
            }

            if (timerState == TimerState.PAUSED) {
                isPlaying = false
            }
        }
    }

    LaunchedEffect(isPlaying) {
        if (isPlaying && sessionConfig.useSoundscapes) {
            mediaPlayer?.let { player ->
                if (player.isPlaying) {
                    player.pause()
                }
                player.release()
            }

            val soundName = when (timerState) {
                TimerState.WORK -> "focus_ambience"
                TimerState.SHORT_BREAK -> "calm_ambience"
                TimerState.LONG_BREAK -> "deep_relaxation"
                else -> "silence"
            }

            try {
                mediaPlayer = MediaPlayer.create(
                    context,
                    resources.getIdentifier(soundName, "raw", context.packageName),
                    AudioAttributes.Builder()
                        .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
                        .setUsage(AudioAttributes.USAGE_MEDIA)
                        .build()
                )
                mediaPlayer?.isLooping = true
                mediaPlayer?.start()
            } catch (e: IOException) {
                e.printStackTrace()
            }
        } else {
            mediaPlayer?.pause()
        }
    }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp),
        verticalArrangement = Arrangement.Top,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Text(
            text = "ZenTimer",
            style = MaterialTheme.typography.headlineMedium,
            fontWeight = FontWeight.Bold,
            color = MaterialTheme.colorScheme.primary
        )

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

        // Visual representation of the session flow
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceEvenly
        ) {
            val segmentColor = when (timerState) {
                TimerState.WORK -> MaterialTheme.colorScheme.secondary
                TimerState.SHORT_BREAK -> MaterialTheme.colorScheme.tertiary
                TimerState.LONG_BREAK -> MaterialTheme.colorScheme.primaryContainer
                else -> MaterialTheme.colorScheme.surfaceVariant
            }

            val otherColor = MaterialTheme.colorScheme.surfaceVariant

            Box(
                modifier = Modifier
                    .weight(1f)
                    .aspectRatio(1f)
                    .clip(CircleShape)
                    .background(Brush.verticalGradient(listOf(otherColor, segmentColor)))
            )

            Spacer(modifier = Modifier.width(8.dp))

            Box(
                modifier = Modifier
                    .weight(1f)
                    .aspectRatio(1f)
                    .clip(CircleShape)
                    .background(
                        Brush.verticalGradient(
                            listOf(
                                if (timerState == TimerState.WORK) segmentColor else otherColor,
                                if (timerState == TimerState.WORK) otherColor else segmentColor
                            )
                        )
                    )
            )

            Spacer(modifier = Modifier.width(8.dp))

            Box(
                modifier = Modifier
                    .weight(1f)
                    .aspectRatio(1f)
                    .clip(CircleShape)
                    .background(
                        Brush.verticalGradient(
                            listOf(
                                if (timerState == TimerState.WORK) segmentColor else otherColor,
                                if (timerState == TimerState.WORK) otherColor else segmentColor
                            )
                        )
                    )
            )
        }

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

        // Main timer display
        Card(
            modifier = Modifier
                .fillMaxWidth()
                .aspectRatio(0.8f),
            shape = RoundedCornerShape(16.dp)
        ) {
            Column(
                modifier = Modifier.fillMaxSize(),
                verticalArrangement = Arrangement.Center,
                horizontalAlignment = Alignment.CenterHorizontally
            ) {
                Text(
                    text = when (timerState) {
                        TimerState.WORK -> "Focus Session"
                        TimerState.SHORT_BREAK -> "Short Break"
                        TimerState.LONG_BREAK -> "Long Break"
                        else -> "Paused"
                    },
                    style = MaterialTheme.typography.bodyLarge,
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )

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

                Text(
                    text = "${timeLeft} min ${(timeLeft * 60) % 60} sec",
                    style = MaterialTheme.typography.displayMedium,
                    fontWeight = FontWeight.Bold,
                    color = MaterialTheme.colorScheme.onSurface
                )

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

                // Animated progress indicator
                Canvas(modifier = Modifier.size(200.dp)) {
                    val strokeWidth = 8f
                    val radius = (size.minDimension - strokeWidth) / 2
                    val center = Offset(size.width / 2, size.height / 2)

                    // Background circle
                    drawCircle(
                        color = MaterialTheme.colorScheme.surfaceVariant,
                        radius = radius,
                        center = center,
                        style = Stroke(strokeWidth)
                    )

                    // Progress circle
                    drawCircle(
                        color = when (timerState) {
                            TimerState.WORK -> MaterialTheme.colorScheme.secondary
                            TimerState.SHORT_BREAK -> MaterialTheme.colorScheme.tertiary
                            TimerState.LONG_BREAK -> MaterialTheme.colorScheme.primaryContainer
                            else -> MaterialTheme.colorScheme.primary
                        },
                        radius = radius,
                        center = center,
                        style = Stroke(strokeWidth),
                        startAngle = 270f,
                        sweep = 360 * progress
                    )

                    // Center indicator
                    drawCircle(
                        color = MaterialTheme.colorScheme.onSurface,
                        radius = strokeWidth * 0.8f,
                        center = center
                    )
                }
            }
        }

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

        // Controls row
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceBetween,
            verticalAlignment = Alignment.CenterVertically
        ) {
            Row(verticalAlignment = Alignment.CenterVertically) {
                IconButton(onClick = {
                    if (timerState != TimerState.IDLE) {
                        timerState = TimerState.PAUSED
                        isPlaying = false
                    }
                }) {
                    Icon(
                        imageVector = Icons.Default.Pause,
                        contentDescription = "Pause",
                        tint = if (timerState == TimerState.PAUSED) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.outline
                    )
                }

                Spacer(modifier = Modifier.width(8.dp))

                IconButton(onClick = {
                    if (timerState == TimerState.IDLE) {
                        timerState = TimerState.WORK
                        isPlaying = true
                    } else if (timerState == TimerState.PAUSED) {
                        isPlaying = true
                    }
                }) {
                    Icon(
                        imageVector = Icons.Default.PlayArrow,
                        contentDescription = "Play",
                        tint = if (timerState != TimerState.PAUSED) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.outline
                    )
                }

                Spacer(modifier = Modifier.width(8.dp))

                IconButton(onClick = {
                    if (timerState != TimerState.IDLE) {
                        timerState = TimerState.IDLE
                        isPlaying = false
                        timeLeft = sessionConfig.workMinutes
                        currentSession = 0
                        mediaPlayer?.pause()
                    }
                }) {
                    Icon(
                        imageVector = Icons.Default.SkipNext,
                        contentDescription = "Reset",
                        tint = if (timerState == TimerState.IDLE) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.outline
                    )
                }
            }

            Switch(
                checked = isPlaying,
                onCheckedChange = { isPlaying = it },
                enabled = timerState != TimerState.IDLE
            )
        }

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

        // Soundscapes toggle
        Row(
            verticalAlignment = Alignment.CenterVertically,
            horizontalArrangement = Arrangement.SpaceBetween
        ) {
            Text(
                text = "Soundscapes",
                style = MaterialTheme.typography.bodyMedium,
                color = MaterialTheme.colorScheme.onSurface
            )

            Switch(
                checked = sessionConfig.useSoundscapes,
                onCheckedChange = { sessionConfig = sessionConfig.copy(useSoundscapes = it) }
            )
        }

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

        // Session configuration
        Text(
            text = "Customize Your Session",
            style = MaterialTheme.typography.titleMedium,
            fontWeight = FontWeight.Bold,
            color = MaterialTheme.colorScheme.primary
        )

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

        Column(modifier = Modifier.fillMaxWidth()) {
            SessionSlider(
                value = sessionConfig.workMinutes.toFloat(),
                onValueChange = { sessionConfig = sessionConfig.copy(workMinutes = it.toInt()) },
                label = "Work (minutes)"
            )

            SessionSlider(
                value = sessionConfig.shortBreakMinutes.toFloat(),
                onValueChange = { sessionConfig = sessionConfig.copy(shortBreakMinutes = it.toInt()) },
                label = "Short Break (minutes)"
            )

            SessionSlider(
                value = sessionConfig.longBreakMinutes.toFloat(),
                onValueChange = { sessionConfig = sessionConfig.copy(longBreakMinutes = it.toInt()) },
                label = "Long Break (minutes)"
            )

            SessionSlider(
                value = sessionConfig.cyclesBeforeLongBreak.toFloat(),
                onValueChange = { sessionConfig = sessionConfig.copy(cyclesBeforeLongBreak = it.toInt()) },
                label = "Cycles before Long Break"
            )
        }

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

        // Reset all button
        TextButton(
            onClick = {
                sessionConfig = SessionConfig()
                timerState = TimerState.IDLE
                isPlaying = false
                timeLeft = sessionConfig.workMinutes
                currentSession = 0
                mediaPlayer?.pause()
            },
            modifier = Modifier.fillMaxWidth()
        ) {
            Text(
                text = "Reset to Defaults",
                color = MaterialTheme.colorScheme.error
            )
        }
    }
}

@Composable
fun SessionSlider(
    value: Float,
    onValueChange: (Float) -> Unit,
    label: String,
    modifier: Modifier = Modifier
) {
    Column(modifier = modifier.padding(vertical = 4.dp)) {
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceBetween
        ) {
            Text(
                text = label,
                style = MaterialTheme.typography.bodySmall,
                color = MaterialTheme.colorScheme.onSurface
            )
            Text(
                text = "${value.toInt()} min",
                style = MaterialTheme.typography.bodySmall,
                color = MaterialTheme.colorScheme.onSurface
            )
        }

        Slider(
            value = value,
            onValueChange = onValueChange,
            valueRange = 1f..60f,
            modifier = Modifier.fillMaxWidth(),
            colors = SliderDefaults.colors(
                thumbColor = MaterialTheme.colorScheme.primary,
                activeTrackColor = MaterialTheme.colorScheme.primary
            )
        )
    }
}

@Preview(showBackground = true)
@Composable
fun ZenTimerPreview() {
    MaterialTheme {
        ZenTimerApp()
    }
}