A!leys Galerie

import android.Manifest
import android.content.Context
import android.content.pm.PackageManager
import android.media.AudioAttributes
import android.media.AudioManager
import android.media.SoundPool
import android.os.Build
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.LinearOutSlowInEasing
import androidx.compose.animation.core.tween
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.CircleShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.FlashOff
import androidx.compose.material.icons.filled.FlashOn
import androidx.compose.material.icons.filled.History
import androidx.compose.material.icons.filled.QrCode
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.graphics.vector.ImageVector
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.unit.dp
import androidx.compose.ui.viewinterop.AndroidView
import androidx.core.content.ContextCompat
import com.google.zxing.BarcodeFormat
import com.google.zxing.MultiFormatReader
import com.google.zxing.Result
import com.google.zxing.common.H orientation
import com.google.zxing.qrcode.QRCodeReader
import java.util.*

@Composable
fun QRScannerApp() {
    val context = LocalContext.current
    val permissionLauncher = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.RequestPermission()
    ) { isGranted ->
        if (isGranted) {
            // Permission granted, start scanning
        } else {
            Toast.makeText(context, "Camera permission required", Toast.LENGTH_LONG).show()
        }
    }

    // Check and request permission
    LaunchedEffect(Unit) {
        when {
            ContextCompat.checkSelfPermission(
                context,
                Manifest.permission.CAMERA
            ) == PackageManager.PERMISSION_GRANTED -> {
                // Permission already granted
            }
            Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU -> {
                permissionLauncher.launch(Manifest.permission.CAMERA)
            }
            else -> {
                permissionLauncher.launch(Manifest.permission.CAMERA)
            }
        }
    }

    val soundPool = remember { SoundPool(1, AudioAttributes.EFFECT_TYPE, 0) }
    val scanSuccessSound = remember { soundPool.load(context, R.raw.scan_success, 1) }

    var qrResult by remember { mutableStateOf("") }
    var scanMode by remember { mutableStateOf(ScanMode.BACK) }
    var isFlashOn by remember { mutableStateOf(false) }
    var historyItems by remember { mutableStateOf(emptyList<String>()) }
    val scanRotator = remember { Animatable(0f) }

    LaunchedEffect(qrResult) {
        if (qrResult.isNotEmpty()) {
            // Play sound effect
            soundPool.setOnLoadCompleteListener(soundPool) { soundID, _ ->
                if (soundID == scanSuccessSound) {
                    soundPool.play(soundID, 1f, 1f, 0, 0, 1f)
                }
            }

            // Add to history
            historyItems = (qrResult + historyItems).takeLast(20).reversed().toMutableList()

            // Rotate animation
            scanRotator.animateTo(
                targetValue = 360f,
                animationSpec = tween(500, easing = LinearOutSlowInEasing)
            )
        }
    }

    Scaffold(
        topBar = {
            TopAppBar(
                title = { Text("QR Lens Pro") },
                actions = {
                    IconButton(onClick = { isFlashOn = !isFlashOn }) {
                        Icon(
                            imageVector = if (isFlashOn) Icons.Default.FlashOff else Icons.Default.FlashOn,
                            contentDescription = "Toggle flash"
                        )
                    }
                }
            )
        },
        content = { padding ->
            Column(
                modifier = Modifier
                    .fillMaxSize()
                    .padding(padding)
            ) {
                // Scanner view
                Box(
                    modifier = Modifier
                        .weight(1f)
                        .fillMaxWidth(),
                    contentAlignment = Alignment.Center
                ) {
                    QRScannerView(
                        modifier = Modifier.size(300.dp),
                        scanMode = scanMode,
                        flashOn = isFlashOn,
                        onScanResult = { result -> qrResult = result },
                        scanRotation = scanRotator.value
                    )

                    if (qrResult.isNotEmpty()) {
                        Box(
                            modifier = Modifier
                                .align(Alignment.BottomCenter)
                                .background(Color.Black.copy(alpha = 0.7f))
                                .padding(16.dp)
                                .clip(CircleShape)
                        ) {
                            Text(
                                text = qrResult,
                                color = Color.White,
                                style = MaterialTheme.typography.bodyLarge
                            )
                        }
                    }
                }

                // History button
                Button(
                    onClick = { scanMode = ScanMode.HISTORY },
                    modifier = Modifier
                        .fillMaxWidth()
                        .padding(16.dp)
                ) {
                    Icon(Icons.Default.History, contentDescription = null)
                    Spacer(Modifier.size(8.dp))
                    Text("View History")
                }

                // History view
                if (scanMode == ScanMode.HISTORY) {
                    LazyColumn(
                        modifier = Modifier
                            .fillMaxWidth()
                            .weight(1f)
                            .padding(16.dp)
                    ) {
                        items(historyItems) { item ->
                            ListItem(
                                headlineContent = { Text(item) },
                                modifier = Modifier
                                    .fillMaxWidth()
                                    .clickable { qrResult = item }
                            )
                        }
                    }

                    Button(
                        onClick = { scanMode = ScanMode.BACK },
                        modifier = Modifier
                            .fillMaxWidth()
                            .padding(16.dp)
                    ) {
                        Text("Back to Scanner")
                    }
                }
            }
        }
    )
}

enum class ScanMode {
    BACK, HISTORY
}

@Composable
fun QRScannerView(
    modifier: Modifier,
    scanMode: ScanMode,
    flashOn: Boolean,
    onScanResult: (String) -> Unit,
    scanRotation: Float
) {
    val context = LocalContext.current
    var scannerView: ScannerView? = null

    AndroidView(
        modifier = modifier.rotate(scanRotation),
        factory = { ctx ->
            ScannerView(ctx).apply {
                scannerView = this
                setupScanner(
                    onScanResult = { result -> onScanResult(result) },
                    flashOn = flashOn
                )
            }
        },
        update = { view, _ ->
            if (scanMode == ScanMode.BACK) {
                view.startScanner()
            } else {
                view.stopScanner()
            }
        }
    )
}

class ScannerView(context: Context) : AndroidView<com.google.zxing.client.android.CaptureActivity.ScannerView>(context) {
    private var scanner: com.google.zxing.client.android.CaptureActivity.Scanner? = null

    fun setupScanner(onScanResult: (String) -> Unit, flashOn: Boolean) {
        val captureActivity = CaptureActivity(context)
        captureActivity.setupScanner(this, onScanResult, flashOn)
    }

    fun startScanner() {
        scanner?.startScanner()
    }

    fun stopScanner() {
        scanner?.stopScanner()
    }
}

class CaptureActivity(context: Context) {
    private val context = context.applicationContext
    private var cameraManager: com.google.zxing.client.android.CameraManager? = null
    private var beepManager: BeepManager? = null
    private var resultHandler: ResultHandler? = null
    private var lastResult: Result? = null
    private var scanner: Scanner? = null

    fun setupScanner(
        scannerView: ScannerView,
        onScanResult: (String) -> Unit,
        flashOn: Boolean
    ) {
        cameraManager = CameraManager(context)
        beepManager = BeepManager(context)
        resultHandler = ResultHandler(context, onScanResult)

        scanner = Scanner(
            context,
            scannerView,
            cameraManager,
            resultHandler,
            beepManager
        ).apply {
            this.flashOn = flashOn
            startScanner()
        }
    }

    fun startScanner() {
        scanner?.startScanner()
    }

    fun stopScanner() {
        scanner?.stopScanner()
    }
}

class Scanner(
    context: Context,
    scannerView: ScannerView,
    cameraManager: CameraManager,
    resultHandler: ResultHandler,
    beepManager: BeepManager
) {
    private val context = context.applicationContext
    private var cameraManager = cameraManager
    private var beepManager = beepManager
    private var resultHandler = resultHandler
    private var scannerView = scannerView
    private var lastResult: Result? = null
    private var decodingInProgress = false
    private var pendingDecode: Result? = null
    private val decodeFormatter = DecodeFormatter(context)

    var flashOn: Boolean = false
        set(value) {
            field = value
            cameraManager?.setTorch(value)
        }

    fun startScanner() {
        val camera = cameraManager?.openDriver(scannerView.surfaceHolder)
        if (camera != null) {
            cameraManager?.startPreview()
            resultHandler?.handleDecode(camera, scannerView)
        }
    }

    fun stopScanner() {
        cameraManager?.closeDriver()
        lastResult = null
        scanning = false
        pendingDecode = null
    }

    private val scanning = AtomicBoolean(false)
    private val state = AtomicReference<State>(State.RESULT_HANDLING)
    private val factory = BarcodeFormat.EAN_8
    private val reader = MultiFormatReader()

    private enum class State {
        PREVIEW,
        DECODING,
        RESULT_HANDLING
    }

    private val handler = Handler()
    private val decodeRun = Runnable {
        decodingInProgress = true
        if (pendingDecode != null) {
            lastResult = pendingDecode
            pendingDecode = null
        } else {
            lastResult = null
        }
        decodingInProgress = false
    }

    private val pendingDecodeCallback = Runnable {
        handler.post(decodeRun)
    }

    private var remainder: ByteArray? = null
    private val multiFormatReader = MultiFormatReader()

    private fun resetState() {
        remainder = null
        cameraManager?.requestPreviewFrame(multiFormatReader, scannerView)
        decodingInProgress = false
        pendingDecode = null
        state.set(State.DECODING)
        handler.post(pendingDecodeCallback)
    }
}

class DecodeFormatter(context: Context) {
    private val context = context.applicationContext
    private val activity = context as Activity
    private val formatManager = FormatManager(activity)
    private val surface = activity.windowManager.defaultDisplay
    private val width = surface.width
    private val height = surface.height

    fun formatResult(result: Result): String {
        // Add your creative formatting here
        return when (result.text) {
            is Uri -> formatUri(result.text as Uri)
            is Decimal -> formatDecimal(result.text as Decimal)
            else -> result.text
        }
    }

    private fun formatUri(uri: Uri): String {
        return when (uri.scheme) {
            "http", "https" -> "Open: ${uri.host}"
            "tel" -> "Call: ${uri.path}"
            "sms" -> "SMS: ${uri.path}"
            else -> "URI: ${uri.toString()}"
        }
    }

    private fun formatDecimal(decimal: Decimal): String {
        return "Number: ${decimal.value()}"
    }
}

class CameraManager(context: Context) {
    private val context = context.applicationContext
    private var camera: Camera? = null
    private var parameters: Camera.Parameters? = null
    private var previewCallback: Camera.PreviewCallback? = null
    private var previewSize: Size? = null
    private var torchOn = false

    fun openDriver(surfaceHolder: SurfaceHolder): Camera {
        camera = Camera.open()
        parameters = camera?.parameters
        setDesiredCameraParameters()
        camera?.setDisplayOrientation(90)
        camera?.setPreviewDisplay(surfaceHolder)
        return camera!!
    }

    fun startPreview() {
        camera?.startPreview()
    }

    fun closeDriver() {
        if (camera != null) {
            camera?.stopPreview()
            camera?.release()
            camera = null
        }
    }

    fun setTorch(flashOn: Boolean) {
        if (torchOn != flashOn) {
            torchOn = flashOn
            camera?.parameters?.flashMode = if (flashOn) Camera.Parameters.FLASH_MODE_TORCH else Camera.Parameters.FLASH_MODE_OFF
            camera?.parameters = parameters
        }
    }

    fun requestPreviewFrame(reader: Result, scannerView: ScannerView) {
        camera?.setOneShotPreviewCallback {
            bytes -> decode(bytes, reader, scannerView)
        }
    }

    private fun decode(data: ByteArray, reader: Result, scannerView: ScannerView) {
        // Implementation would go here
    }

    private fun setDesiredCameraParameters() {
        parameters?.setPreviewSize(1280, 720)
    }
}

class ResultHandler(context: Context, private val onScanResult: (String) -> Unit) {
    private val context = context.applicationContext
    private var activity: Activity? = null
    private var surface: Surface? = null

    init {
        activity = context as Activity
        surface = activity?.windowManager?.defaultDisplay
    }

    fun handleDecode(camera: Camera, scannerView: ScannerView) {
        camera.setOneShotPreviewCallback {
            bytes -> decode(bytes, scannerView)
        }
    }

    private fun decode(data: ByteArray, scannerView: ScannerView) {
        val result = Result(data, null)
        val format = DecodeFormatter(context)
        val formattedResult = format.formatResult(result)
        onScanResult(formattedResult)
    }
}

class BeepManager(context: Context) {
    private val context = context.applicationContext
    private val soundPool = SoundPool(1, AudioAttributes.EFFECT_TYPE, 0)
    private val beepId = soundPool.load(context, R.raw.beep, 1)

    fun playBeep() {
        soundPool.play(beepId, 1f, 1f, 0, 0, 1f)
    }
}

@Preview(showBackground = true)
@Composable
fun QRScannerAppPreview() {
    QRScannerApp()
}