A!leys Galerie

```kotlin
import android.Manifest
import android.content.Context
import android.content.pm.PackageManager
import android.graphics.Bitmap
import android.graphics.Canvas
import android.os.Bundle
import android.util.Log
import android.view.View
import android.view.ViewGroup
import android.widget.Toast
import androidx.activity.ComponentActivity
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
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.aspectRatio
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.grid.GridCells
import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
import androidx.compose.foundation.lazy.grid.items
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.Refresh
import androidx.compose.material.icons.filled.Undo
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ElevatedCard
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.material3.MaterialTheme
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.mutableStateListOf
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.graphics.Color
import androidx.compose.ui.graphics.ColorFilter
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.imageResource
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.core.content.ContextCompat
import com.google.zxing.BarcodeFormat
import com.google.zxing.BinaryBitmap
import com.google.zxing.ChecksumException
import com.google.zxing.DecodeHintType
import com.google.zxing.MultiFormatReader
import com.google.zxing.NotFoundException
import com.google.zxing Result
import com.google.zxing.common.HybridBinarizer
import com.google.zxing.qrcode.QRCodeReader
import java.io.ByteArrayOutputStream
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale
import kotlin.random.Random

data class QRScanResult(
    val content: String,
    val format: String,
    val timestamp: String,
    val qrBitmap: Bitmap
)

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

@Composable
fun AileyScanApp() {
    val context = LocalContext.current
    var scanResults by remember { mutableStateOf<List<QRScanResult>>(emptyList()) }
    var currentScan by remember { mutableStateOf<QRScanResult?>(null) }
    var isScanning by remember { mutableStateOf(false) }
    var showMemoryGame by remember { mutableStateOf(false) }
    val memoryPairs = remember { mutableStateListOf<MemoryCardState>() }
    val permissionLauncher = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.RequestPermission()
    ) { isGranted ->
        if (isGranted) {
            isScanning = true
        } else {
            Toast.makeText(context, "Camera permission is required", Toast.LENGTH_LONG).show()
        }
    }

    LaunchedEffect(Unit) {
        if (ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA)
            != PackageManager.PERMISSION_GRANTED
        ) {
            permissionLauncher.launch(Manifest.permission.CAMERA)
        } else {
            isScanning = true
        }
    }

    if (isScanning) {
        QRScannerScreen(
            onScanSuccess = { result ->
                currentScan = result
                addScanToHistory(result, scanResults)
            },
            onScanError = { error ->
                Toast.makeText(context, error, Toast.LENGTH_SHORT).show()
            },
            onBack = { isScanning = false }
        )
    } else {
        MainScreen(
            scanResults = scanResults,
            onScanClick = { isScanning = true },
            onMemoryClick = { showMemoryGame = true },
            onHistoryClear = { scanResults = emptyList() }
        )

        if (showMemoryGame && currentScan != null) {
            MemoryGameScreen(
                onBack = { showMemoryGame = false },
                qrContent = currentScan!!.content.take(10)
            )
        }
    }
}

@Composable
fun MainScreen(
    scanResults: List<QRScanResult>,
    onScanClick: () -> Unit,
    onMemoryClick: () -> Unit,
    onHistoryClear: () -> Unit
) {
    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp),
        verticalArrangement = Arrangement.Top,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Text(
            text = "AileyScan",
            style = MaterialTheme.typography.headlineMedium,
            modifier = Modifier.padding(bottom = 32.dp)
        )

        ElevatedCard(
            modifier = Modifier
                .fillMaxWidth()
                .aspectRatio(1f)
                .clip(RoundedCornerShape(16.dp))
                .clickable { onScanClick() },
            elevation = CardDefaults.cardElevation(4.dp)
        ) {
            Box(
                contentAlignment = Alignment.Center,
                modifier = Modifier
                    .fillMaxSize()
                    .background(MaterialTheme.colorScheme.surfaceVariant)
            ) {
                Icon(
                    imageVector = Icons.Default.Add,
                    contentDescription = "Scan QR Code",
                    modifier = Modifier.size(64.dp),
                    tint = MaterialTheme.colorScheme.primary
                )
                Text(
                    text = "Tap to Scan",
                    style = MaterialTheme.typography.bodyLarge,
                    modifier = Modifier.align(Alignment.BottomCenter)
                )
            }
        }

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

        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.Center,
            verticalAlignment = Alignment.CenterVertically
        ) {
            Button(
                onClick = { onScanClick() },
                modifier = Modifier.padding(end = 8.dp)
            ) {
                Icon(Icons.Default.Add, contentDescription = "Scan")
                Text("Scan QR", modifier = Modifier.padding(start = 8.dp))
            }

            Button(
                onClick = onMemoryClick,
                modifier = Modifier.padding(start = 8.dp)
            ) {
                Text("Memory Game")
            }
        }

        if (scanResults.isNotEmpty()) {
            Spacer(modifier = Modifier.height(16.dp))
            Text(
                text = "Scan History (${scanResults.size})",
                style = MaterialTheme.typography.titleMedium,
                modifier = Modifier.align(Alignment.Start)
            )

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

            LinearProgressIndicator(
                progress = { scanResults.size.toFloat() / 10 },
                modifier = Modifier.fillMaxWidth(),
                color = MaterialTheme.colorScheme.primary
            )

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

            TextButton(
                onClick = onHistoryClear,
                modifier = Modifier.align(Alignment.End)
            ) {
                Icon(Icons.Default.Undo, contentDescription = "Clear History")
                Text("Clear All")
            }

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

            LazyVerticalGrid(
                columns = GridCells.Fixed(2),
                modifier = Modifier.fillMaxWidth()
            ) {
                items(scanResults) { result ->
                    ScanHistoryItem(
                        result = result,
                        modifier = Modifier.padding(4.dp)
                    )
                }
            }
        }
    }
}

@Composable
fun ScanHistoryItem(result: QRScanResult, modifier: Modifier = Modifier) {
    Card(
        modifier = modifier.fillMaxWidth(),
        elevation = CardDefaults.cardElevation(2.dp)
    ) {
        Column(
            modifier = Modifier.padding(12.dp)
        ) {
            Image(
                bitmap = result.qrBitmap,
                contentDescription = null,
                modifier = Modifier
                    .size(80.dp)
                    .clip(CircleShape),
                colorFilter = ColorFilter.tint(Color.Gray)
            )

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

            Text(
                text = result.content.take(30) + if (result.content.length > 30) "..." else "",
                style = MaterialTheme.typography.bodyMedium,
                maxLines = 2
            )

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

            Text(
                text = "${result.format} • ${result.timestamp}",
                style = MaterialTheme.typography.bodySmall,
                color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
            )
        }
    }
}

@Composable
fun QRScannerScreen(
    onScanSuccess: (QRScanResult) -> Unit,
    onScanError: (String) -> Unit,
    onBack: () -> Unit
) {
    val context = LocalContext.current
    var cameraPreviewVisible by remember { mutableStateOf(false) }
    var scanInProgress by remember { mutableStateOf(false) }
    var resultText by remember { mutableStateOf("") }
    var scanProgress by remember { mutableStateOf(0f) }

    LaunchedEffect(Unit) {
        cameraPreviewVisible = true
    }

    Box(
        modifier = Modifier
            .fillMaxSize()
            .background(MaterialTheme.colorScheme.background)
    ) {
        if (cameraPreviewVisible) {
            AndroidView(
                factory = { ctx ->
                    val cameraManager = ctx.getSystemService(Context.CAMERA_SERVICE) as CameraManager
                    val cameraId = cameraManager.cameraIdList[0]
                    val previewBuilder = Preview.Builder()
                    val preview = previewBuilder.build()
                    preview.setSurfaceProvider(PreviewView.SurfaceProvider { previewView ->
                        val displayMetrics = ctx.resources.displayMetrics
                        val size = android.util.Size(displayMetrics.widthPixels, displayMetrics.heightPixels)
                        preview.setTargetResolution(size)
                    })

                    val cameraSelector = CameraSelector.Builder()
                        .requireLensFacing(CameraSelector.LENS_FACING_BACK)
                        .build()

                    val cameraProviderFuture = ProcessCameraProvider.getInstance(ctx)
                    cameraProviderFuture.addListener({
                        val cameraProvider = cameraProviderFuture.get()
                        val camera = cameraProvider.bindToLifecycle(
                            this,
                            cameraSelector,
                            preview
                        )
                    }, ContextCompat.getMainExecutor(ctx))

                    PreviewView(ctx).apply {
                        this.cameraProviderFuture = cameraProviderFuture
                        this.preview = preview
                        this.camera = camera
                    }
                },
                update = { view ->
                    view.cameraProviderFuture = ProcessCameraProvider.getInstance(context)
                    view.preview = Preview.Builder().build()
                    view.camera = view.cameraProviderFuture.get().bindToLifecycle(
                        this,
                        CameraSelector.Builder()
                            .requireLensFacing(CameraSelector.LENS_FACING_BACK)
                            .build(),
                        view.preview
                    )
                },
                modifier = Modifier.fillMaxSize()
            )
        }

        Box(
            modifier = Modifier
                .fillMaxSize()
                .background(Color.Black.copy(alpha = 0.5f))
        ) {
            Column(
                modifier = Modifier
                    .align(Alignment.Center)
                    .fillMaxSize(),
                verticalArrangement = Arrangement.Center,
                horizontalAlignment = Alignment.CenterHorizontally
            ) {
                Text(
                    text = "Scan a QR Code",
                    style = MaterialTheme.typography.headlineSmall,
                    color = Color.White
                )

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

                CircularProgressIndicator(
                    progress = scanProgress,
                    modifier = Modifier.size(64.dp),
                    color = MaterialTheme.colorScheme.primary,
                    trackColor = MaterialTheme.colorScheme.surfaceVariant
                )

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

                Text(
                    text = resultText,
                    style = MaterialTheme.typography.bodyMedium,
                    color = Color.White
                )

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

                Button(
                    onClick = { onBack() },
                    colors = ButtonDefaults.buttonColors(containerColor = MaterialTheme.colorScheme.surfaceVariant)
                ) {
                    Icon(Icons.Default.Undo, contentDescription = "Back")
                    Text("Cancel", modifier = Modifier.padding(start = 8.dp))
                )
            }
        }
    }
}

fun addScanToHistory(result: QRScanResult, currentHistory: List<QRScanResult>): List<QRScanResult> {
    val updatedHistory = (currentHistory + result).distinctBy { it.content }
    if (updatedHistory.size > 10) {
        return updatedHistory.takeLast(10)
    }
    return updatedHistory
}

fun generateQRBitmap(content: String): Bitmap {
    val width = 512
    val height = 512
    val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
    val canvas = Canvas(bitmap)
    canvas.drawColor(Color.WHITE)

    try {
        val writer = QRCodeWriter()
        val bitMatrix = writer.encode(content, BarcodeFormat.QR_CODE, width, height)
        val binaryBitmap = BinaryBitmap(HybridBinarizer(bitMatrix))
        val reader = QRCodeReader()

        val result: Result = reader.decode(binaryBitmap)
        // We'll just use the content for the visual representation
        val paint = android.graphics.Paint().apply {
            color = Color.BLACK
            strokeWidth = 16f
        }
        canvas.drawCircle(width / 2f, height / 2f, width / 3f, paint)
        canvas.drawCircle(width / 2f, height / 2f, width / 4f, paint)
        canvas.drawCircle(width / 2f, height / 2f, width / 5f, paint)
    } catch (e: Exception) {
        Log.e("QRGenerator", "Error generating QR bitmap", e)
    }

    return bitmap
}

data class MemoryCardState(
    val id: Int,
    val content: String,
    val isFlipped: Boolean,
    val isMatched: Boolean
)

@Composable
fun MemoryGameScreen(onBack: () -> Unit, qrContent: String) {
    val context = LocalContext.current
    var cards by remember { mutableStateOf<List<MemoryCardState>>(emptyList()) }
    var flippedCards by remember { mutableStateOf<List<MemoryCardState>>(emptyList()) }
    var gameWon by remember { mutableStateOf(false) }
    var attempts by remember { mutableStateOf(0) }
    val pairContent = remember { generatePairContent(qrContent) }

    LaunchedEffect(pairContent) {
        cards = createMemoryCards(pairContent)
    }

    Box(
        modifier = Modifier
            .fillMaxSize()
            .background(MaterialTheme.colorScheme.background)
    ) {
        if (gameWon) {
            Box(
                contentAlignment = Alignment.Center,
                modifier = Modifier.fillMaxSize()
            ) {
                Column(
                    horizontalAlignment = Alignment.CenterHorizontally,
                    modifier = Modifier.padding(16.dp)
                ) {
                    Icon(
                        imageVector = Icons.Default.Check,
                        contentDescription = "Win",
                        modifier = Modifier.size(64.dp),
                        tint = MaterialTheme.colorScheme.primary
                    )
                    Text(
                        text = "Memory Game Won!",
                        style = MaterialTheme.typography.headlineSmall
                    )
                    Spacer(modifier = Modifier.height(8.dp))
                    Text(
                        text = "Attempts: $attempts",
                        style = MaterialTheme.typography.bodyMedium
                    )
                    Spacer(modifier = Modifier.height(24.dp))
                    Button(
                        onClick = { onBack() },
                        modifier = Modifier.padding(horizontal = 32.dp)
                    ) {
                        Text("Back to Scanner")
                    }
                }
            }
        } else {
            Column(
                modifier = Modifier
                    .fillMaxSize()
                    .padding(16.dp),
                horizontalAlignment = Alignment.CenterHorizontally
            ) {
                Text(
                    text = "Memory Game",
                    style = MaterialTheme.typography.headlineMedium,
                    modifier = Modifier.padding(bottom = 16.dp)
                )

                Text(
                    text = "Attempts: $attempts",
                    style = MaterialTheme.typography.bodyMedium,
                    modifier = Modifier.padding(bottom = 16.dp)
                )

                Text(
                    text = "Scan this QR to play:",
                    style = MaterialTheme.typography.bodyMedium,
                    modifier = Modifier.padding(bottom = 8.dp)
                )

                Box(
                    modifier = Modifier
                        .size(120.dp)
                        .clip(RoundedCornerShape(16.dp))
                        .background(MaterialTheme.colorScheme.surfaceVariant)
                        .padding(8.dp)
                ) {
                    Text(
                        text = qrContent,
                        style = MaterialTheme.typography.bodyLarge,
                        color = MaterialTheme.colorScheme.onSurface,
                        modifier = Modifier.align(Alignment.Center)
                    )
                }

                Spacer(modifier = Modifier