package de.waypointaudio.ui

import android.content.ActivityNotFoundException
import android.content.ClipData
import android.content.ClipboardManager
import android.content.Context
import android.content.Intent
import android.net.Uri
import android.os.ParcelFileDescriptor
import android.widget.Toast
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.*
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.key
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.semantics.contentDescription
import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import de.waypointaudio.R
import de.waypointaudio.license.DeviceIdProvider
import de.waypointaudio.license.LicenseStatusProvider
import de.waypointaudio.util.AppVersion
import java.io.ByteArrayOutputStream
import java.io.File
import java.io.FileInputStream
import java.io.IOException
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext

// Info-Dialog: Zeigt App-Name, Lizenz-/Pro-Bereich mit Lizenzstatus, Versions-/Entwicklerinfos.
//
// v2.5.28 - Profi Lizenztext:
//  - Profi-Sektion: Abo-Wording vollständig entfernt. Stattdessen korrekte
//    Formulierung einer einjährigen Lizenz mit aktiver Erneuerungsoption.
//  - Keine automatische Verlängerung / keine Abo-Vertragswirkung mehr suggeriert.
//  - Features-Text neu strukturiert: kompakte Bullet-Liste statt Fließtext.
//  - Neue Strings: about_pro_tagline2, about_pro_renewal_note, about_pro_features_list.
//  - Alle technischen Lizenzimport-/Prüf-Mechanismen aus v2.5.27 unverändert.
//
// v2.5.27 - Profi Abo Mailfix:
//  - Empfängeradresse geändert von m3lmayer@protonmail.com auf marcel.mayer@nesohub.org.
//  - Mail-Intent robuster: ACTION_SENDTO mit vollständiger mailto-URI (Empfänger, Subject,
//    Body vollständig URL-encoded via java.net.URLEncoder direkt in Uri.parse("mailto:...")).
//    Empfänger ist damit zuverlässig gesetzt, unabhängig von E-Mail-App-Verhalten.
//  - Alle technischen Lizenzimport-/Prüf-Mechanismen aus v2.5.26 unverändert.
//
// v2.5.26 - License-Page-Cleanup:
//  - Preis (555 €) und PayPal-Button aus der About-Seite entfernt.
//  - Neuer E-Mail-Button "Profi-Lizenz per E-Mail anfragen" mit vorbefüllter
//    E-Mail (ACTION_SENDTO, mailto:), inkl. Geräte-ID automatisch eingefügt.
//  - Fallback-Toast wenn keine E-Mail-App verfügbar ist.
//  - Pro-Sektion verschlankt: Tagline + Features-Text, kompaktere Struktur.
//  - LicenseStatusProvider: humanLicenseType() erkennt jetzt auch "pro"/"profi"
//    als Anzeigename "Profi" (nur Anzeige, kein Formatänderung).
//  - Alle technischen Lizenzimport-/Prüf-Mechanismen aus v2.5.25 unverändert.
//
// v2.5.25 - License-Import-Thread-Fix:
//  - Alle blockierenden I/O-Operationen (contentResolver.openInputStream,
//    openFileDescriptor, FileInputStream, ByteArrayOutputStream.copyTo,
//    LicenseStatusProvider.import inkl. JSON/Signaturvalidierung) laufen jetzt
//    auf Dispatchers.IO, nicht mehr auf dem Main-Thread.
//  - ActivityResult-Callback startet eine Coroutine via rememberCoroutineScope().
//    withContext(Dispatchers.IO) { readLicenseBytes(...) + LicenseStatusProvider.import() }
//    Danach werden UI-State/Toast/reloadTrigger wieder auf dem Main-Thread gesetzt.
//  - isImporting-Flag verhindert Doppelauslösung des Import-Buttons.
//  - exportLauncher ebenfalls auf Dispatchers.IO verschoben.
//  - Textimport: LicenseStatusProvider.import() jetzt ebenfalls auf Dispatchers.IO.
//  - Alle v2.5.24-Fallbacks (drei Lesestrategien, Diagnose-Dialog, Textimport,
//    OpenDocument */*,  importNonce) unverändert beibehalten.
//
// v2.5.24 - Lizenzimport-Fallbacks:
//  1. readLicenseBytes() mit drei Lesestrategien:
//     a) openInputStream(uri) -> copyTo(ByteArrayOutputStream)
//     b) openFileDescriptor(uri, "r") -> FileInputStream(fd)
//     c) uri.scheme=="file" -> File(uri.path).inputStream()
//  2. OpenDocument() mit nur "*/" + "*" (d.h. */*) - keine MIME-Liste, verhindert Galerie-Modus.
//  3. importNonce: unveraendert aus v2.5.23.
//  4. Textimport-Fallback: AlertDialog mit JSON-Textfeld + Zwischenablage-Button.
//  5. Diagnose-Dialog statt generischem Toast bei Totalausfall aller Lesestrategien.
// v2.5.23 - Regression-Fix OpenDocument.
// v2.5.21 - Re-Import-Bugfix + Geraete-ID.
// v2.5.20 - Lizenzaktionen.
@Composable
fun AboutDialog(onDismiss: () -> Unit) {
    val context = LocalContext.current
    val versionInfo = remember(context) { AppVersion.get(context) }
    val scope = rememberCoroutineScope()

    // reloadTrigger: Inkrementieren erzwingt Recomposition der Lizenzstatus-Card.
    var reloadTrigger by remember { mutableIntStateOf(0) }

    // importNonce: Inkrementieren erzeugt neuen Launcher-Slot für Reimport derselben Datei.
    var importNonce by remember { mutableIntStateOf(0) }

    // v2.5.25 — Import läuft: verhindert Doppelauslösung während I/O auf IO-Dispatcher.
    var isImporting by remember { mutableStateOf(false) }

    // Zustände für Fehlerdiagnose-Dialog
    var showDiagDialog by remember { mutableStateOf(false) }
    var diagMessage by remember { mutableStateOf("") }

    // Zustand für Textimport-Dialog
    var showTextImport by remember { mutableStateOf(false) }

    LaunchedEffect(reloadTrigger) {
        LicenseStatusProvider.ensureLoaded(context)
    }

    val showBgReliability = remember { mutableStateOf(false) }
    if (showBgReliability.value) {
        BackgroundReliabilityManualDialog(onClose = { showBgReliability.value = false })
    }

    var showRemoveConfirm by remember { mutableStateOf(false) }

    // v2.5.24 — Diagnose-Dialog: zeigt technische Fehlerdetails, wenn alle Lesestrategien scheitern.
    if (showDiagDialog) {
        AlertDialog(
            onDismissRequest = { showDiagDialog = false },
            title = { Text(stringResource(R.string.about_license_import_err_diag_title)) },
            text = {
                Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
                    Text(
                        text = stringResource(R.string.about_license_import_err_diag_intro),
                        style = MaterialTheme.typography.bodyMedium
                    )
                    Text(
                        text = diagMessage,
                        style = MaterialTheme.typography.bodySmall,
                        color = MaterialTheme.colorScheme.error
                    )
                    Text(
                        text = stringResource(R.string.about_license_import_err_diag_hint),
                        style = MaterialTheme.typography.bodySmall,
                        color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f)
                    )
                }
            },
            confirmButton = {
                TextButton(onClick = { showDiagDialog = false }) {
                    Text(stringResource(R.string.about_close))
                }
            }
        )
    }

    // v2.5.24 — Textimport-Dialog: Nutzer fügt JSON-Inhalt der Lizenzdatei ein.
    if (showTextImport) {
        LicenseTextImportDialog(
            context = context,
            onDismiss = { showTextImport = false },
            onImported = {
                reloadTrigger++
                showTextImport = false
            }
        )
    }

    // v2.5.25 — Import-Launcher mit Dispatchers.IO-Fix.
    //
    // v2.5.24 — Import-Launcher: OpenDocument() mit nur "*/*" (maximale Kompatibilität).
    //
    // Begründung für nur "*/*":
    //  - Mehrere MIME-Typen (json, text/*, octet-stream, */*) können auf einigen
    //    MIUI-Versionen dazu führen, dass der Picker in einen Galerie/Medien-Modus
    //    wechselt. Nur "*/*" erzwingt immer den echten Datei-Browser.
    //  - OpenDocument() bleibt (nicht GetContent): echter SAF-Datei-Browser, zeigt
    //    alle Dateien inkl. .gps2audio-license.
    //
    // v2.5.25 — I/O auf Dispatchers.IO:
    //  - readLicenseBytes() (openInputStream/openFileDescriptor/File-Lesen) läuft
    //    jetzt vollständig auf Dispatchers.IO.
    //  - LicenseStatusProvider.import() (inkl. JSON-Parsing + Signaturprüfung)
    //    ebenfalls auf Dispatchers.IO.
    //  - UI-State (diagMessage, showDiagDialog, Toast, reloadTrigger, isImporting)
    //    wird danach auf dem Main-Thread gesetzt.
    val importLauncher = key(importNonce) {
        rememberLauncherForActivityResult(
            contract = ActivityResultContracts.OpenDocument()
        ) { uri: Uri? ->
            // Immer erhöhen: nächster Import (auch gleiche Datei) bekommt frischen Launcher.
            importNonce++

            if (uri == null) {
                // Nutzer hat Picker abgebrochen.
                return@rememberLauncherForActivityResult
            }

            // v2.5.25 — Alle blockierenden Operationen auf Dispatchers.IO verschieben.
            isImporting = true
            scope.launch {
                // --- Dispatchers.IO: readLicenseBytes + LicenseStatusProvider.import ---
                val (bytes, errMsg) = withContext(Dispatchers.IO) {
                    readLicenseBytes(context, uri)
                }

                if (bytes == null) {
                    // Alle Strategien gescheitert → Diagnose-Dialog anzeigen (Main-Thread)
                    diagMessage = errMsg ?: context.getString(R.string.about_license_import_err_open)
                    showDiagDialog = true
                    isImporting = false
                    return@launch
                }

                if (bytes.isEmpty()) {
                    Toast.makeText(
                        context,
                        context.getString(R.string.about_license_import_err_empty),
                        Toast.LENGTH_LONG
                    ).show()
                    isImporting = false
                    return@launch
                }

                // LicenseStatusProvider.import: JSON-Parsing + Signaturvalidierung auf IO
                val result = withContext(Dispatchers.IO) {
                    LicenseStatusProvider.import(context, bytes)
                }

                // Zurück auf Main-Thread: UI-State setzen
                val msg = if (result.success) {
                    context.getString(R.string.about_license_import_success, result.message)
                } else {
                    context.getString(R.string.about_license_import_fail_invalid, result.message)
                }
                Toast.makeText(context, msg, Toast.LENGTH_LONG).show()
                reloadTrigger++
                isImporting = false
            }
        }
    }

    // v2.5.25 — Export ebenfalls auf Dispatchers.IO (openOutputStream ist blocking).
    val exportLauncher = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.CreateDocument("application/json")
    ) { uri: Uri? ->
        if (uri == null) return@rememberLauncherForActivityResult
        scope.launch {
            val raw = withContext(Dispatchers.IO) {
                LicenseStatusProvider.exportRawJson(context)
            }
            if (raw == null) {
                Toast.makeText(
                    context,
                    context.getString(R.string.about_license_export_nothing),
                    Toast.LENGTH_LONG
                ).show()
                return@launch
            }
            val ok = withContext(Dispatchers.IO) {
                try {
                    context.contentResolver.openOutputStream(uri)?.use {
                        it.write(raw.toByteArray(Charsets.UTF_8))
                        true
                    } ?: false
                } catch (_: Throwable) {
                    false
                }
            }
            val msg = if (ok) {
                context.getString(R.string.about_license_export_success)
            } else {
                context.getString(R.string.about_license_export_fail)
            }
            Toast.makeText(context, msg, Toast.LENGTH_LONG).show()
        }
    }

    if (showRemoveConfirm) {
        AlertDialog(
            onDismissRequest = { showRemoveConfirm = false },
            title = { Text(stringResource(R.string.about_license_action_remove_confirm_title)) },
            text = { Text(stringResource(R.string.about_license_action_remove_confirm_text)) },
            confirmButton = {
                TextButton(onClick = {
                    val ok = LicenseStatusProvider.remove(context)
                    val msg = if (ok) {
                        context.getString(R.string.about_license_action_remove_done)
                    } else {
                        context.getString(R.string.about_license_action_remove_fail)
                    }
                    Toast.makeText(context, msg, Toast.LENGTH_LONG).show()
                    showRemoveConfirm = false
                    reloadTrigger++
                    importNonce++
                }) { Text(stringResource(R.string.about_license_action_remove_confirm_ok)) }
            },
            dismissButton = {
                TextButton(onClick = { showRemoveConfirm = false }) {
                    Text(stringResource(R.string.about_license_action_remove_confirm_cancel))
                }
            }
        )
    }

    AlertDialog(
        onDismissRequest = onDismiss,
        title = {
            Text(
                text = stringResource(R.string.about_title),
                style = MaterialTheme.typography.headlineSmall
            )
        },
        text = {
            Column(
                modifier = Modifier
                    .verticalScroll(rememberScrollState())
                    .padding(vertical = 4.dp),
                verticalArrangement = Arrangement.spacedBy(12.dp)
            ) {
                Text(
                    text = stringResource(R.string.about_app_name),
                    style = MaterialTheme.typography.titleMedium,
                    fontWeight = FontWeight.Bold
                )
                Text(
                    text = stringResource(R.string.about_description),
                    style = MaterialTheme.typography.bodyMedium
                )

                // v2.5.28 — Profi-Sektion: Abo-Wording entfernt, einjährige Lizenz formuliert.
                // Keine automatische Verlängerung. Features als kompakte Bullet-Liste.
                // Geräte-ID wird automatisch in den E-Mail-Body eingefügt.
                val proRequestCd = stringResource(R.string.about_pro_request_open_cd)
                val proEmailRecipient = stringResource(R.string.about_pro_email_recipient)
                val proEmailSubject = stringResource(R.string.about_pro_email_subject)
                val proEmailBodyTemplate = stringResource(R.string.about_pro_email_body_template)
                val proEmailNoApp = stringResource(R.string.about_pro_email_no_app)
                val proDeviceId = remember(context) { DeviceIdProvider.getDeviceIdHash(context) }
                Card(
                    shape = RoundedCornerShape(16.dp),
                    colors = CardDefaults.cardColors(
                        containerColor = MaterialTheme.colorScheme.primaryContainer
                    ),
                    elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
                ) {
                    Column(
                        modifier = Modifier.padding(14.dp),
                        verticalArrangement = Arrangement.spacedBy(8.dp)
                    ) {
                        Text(
                            text = stringResource(R.string.about_pro_section_label),
                            style = MaterialTheme.typography.labelLarge,
                            color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.75f)
                        )
                        Text(
                            text = stringResource(R.string.about_pro_title),
                            style = MaterialTheme.typography.titleSmall,
                            fontWeight = FontWeight.SemiBold,
                            color = MaterialTheme.colorScheme.onPrimaryContainer
                        )
                        // v2.5.28 — Einjährige Lizenz (kein Abo-Wording)
                        Text(
                            text = stringResource(R.string.about_pro_tagline),
                            style = MaterialTheme.typography.bodyMedium,
                            color = MaterialTheme.colorScheme.onPrimaryContainer
                        )
                        Text(
                            text = stringResource(R.string.about_pro_tagline2),
                            style = MaterialTheme.typography.bodyMedium,
                            color = MaterialTheme.colorScheme.onPrimaryContainer
                        )
                        Text(
                            text = stringResource(R.string.about_pro_renewal_note),
                            style = MaterialTheme.typography.bodySmall,
                            color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.85f)
                        )
                        HorizontalDivider(
                            modifier = Modifier.padding(vertical = 2.dp),
                            color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.2f)
                        )
                        // v2.5.28 — Profi-Features als kompakte Bullet-Liste
                        Text(
                            text = stringResource(R.string.about_pro_features_label),
                            style = MaterialTheme.typography.labelMedium,
                            fontWeight = FontWeight.SemiBold,
                            color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.85f)
                        )
                        Text(
                            text = stringResource(R.string.about_pro_features_list),
                            style = MaterialTheme.typography.bodySmall,
                            color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.85f)
                        )
                        HorizontalDivider(
                            modifier = Modifier.padding(vertical = 2.dp),
                            color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.2f)
                        )
                        Text(
                            text = stringResource(R.string.about_pro_required_intro),
                            style = MaterialTheme.typography.labelMedium,
                            fontWeight = FontWeight.SemiBold,
                            color = MaterialTheme.colorScheme.onPrimaryContainer
                        )
                        Text(
                            text = stringResource(R.string.about_pro_required_line1),
                            style = MaterialTheme.typography.bodySmall,
                            color = MaterialTheme.colorScheme.onPrimaryContainer
                        )
                        Text(
                            text = stringResource(R.string.about_pro_required_line2),
                            style = MaterialTheme.typography.bodySmall,
                            color = MaterialTheme.colorScheme.onPrimaryContainer
                        )
                        Text(
                            text = stringResource(R.string.about_pro_required_line3),
                            style = MaterialTheme.typography.bodySmall,
                            color = MaterialTheme.colorScheme.onPrimaryContainer
                        )
                        Text(
                            text = stringResource(R.string.about_pro_required_line4),
                            style = MaterialTheme.typography.bodySmall,
                            color = MaterialTheme.colorScheme.onPrimaryContainer
                        )
                        Text(
                            text = stringResource(R.string.about_pro_private_note),
                            style = MaterialTheme.typography.bodySmall,
                            color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.8f)
                        )
                        Text(
                            text = stringResource(R.string.about_pro_manual_note),
                            style = MaterialTheme.typography.bodySmall,
                            color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.8f)
                        )
                        // v2.5.27 — Mail-Intent-Fix: vollständige mailto-URI mit Empfänger,
                        // Subject und Body direkt URL-encoded. Empfänger wird dadurch
                        // zuverlässig in jede E-Mail-App übertragen (kein extras-Verlust).
                        // ACTION_SENDTO + mailto: ist der korrekte Weg für direkte Mail-Apps.
                        Button(
                            onClick = {
                                val body = proEmailBodyTemplate.format(proDeviceId)
                                // URL-Encoding für Subject und Body (RFC 2368 / mailto-URI).
                                // java.net.URLEncoder.encode() kodiert Leerzeichen als '+',
                                // mailto erwartet jedoch '%20' — daher Replace.
                                val encodedSubject = java.net.URLEncoder.encode(proEmailSubject, "UTF-8")
                                    .replace("+", "%20")
                                val encodedBody = java.net.URLEncoder.encode(body, "UTF-8")
                                    .replace("+", "%20")
                                // Vollständige mailto-URI: Empfänger fest in URI kodiert,
                                // nicht nur als Extra → zuverlässig in allen Mail-Apps.
                                val mailtoUriString = "mailto:$proEmailRecipient?subject=$encodedSubject&body=$encodedBody"
                                val mailtoUri = Uri.parse(mailtoUriString)
                                val intent = Intent(Intent.ACTION_SENDTO, mailtoUri)
                                val launched = try {
                                    context.startActivity(intent)
                                    true
                                } catch (_: ActivityNotFoundException) {
                                    false
                                }
                                if (!launched) {
                                    // Fallback: Chooser (z. B. falls kein direkter Handler)
                                    val fallback = Intent(Intent.ACTION_SENDTO, mailtoUri)
                                    val chooser = Intent.createChooser(fallback, null)
                                    val launched2 = try {
                                        context.startActivity(chooser)
                                        true
                                    } catch (_: ActivityNotFoundException) {
                                        false
                                    }
                                    if (!launched2) {
                                        Toast.makeText(context, proEmailNoApp, Toast.LENGTH_LONG).show()
                                    }
                                }
                            },
                            colors = ButtonDefaults.buttonColors(
                                containerColor = MaterialTheme.colorScheme.primary,
                                contentColor = MaterialTheme.colorScheme.onPrimary
                            ),
                            modifier = Modifier
                                .fillMaxWidth()
                                .semantics { contentDescription = proRequestCd }
                        ) {
                            Text(text = stringResource(R.string.about_pro_request_button))
                        }
                        Text(
                            text = stringResource(R.string.about_pro_contact_hint),
                            style = MaterialTheme.typography.bodySmall,
                            color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.8f)
                        )
                    }
                }

                // Lizenzstatus-Card mit reloadTrigger-gesteuerter Recomposition.
                val licenseStatus = remember(reloadTrigger) { LicenseStatusProvider.status }
                Card(
                    shape = RoundedCornerShape(12.dp),
                    colors = CardDefaults.cardColors(
                        containerColor = MaterialTheme.colorScheme.surfaceVariant
                    ),
                    elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
                ) {
                    Column(
                        modifier = Modifier.padding(12.dp),
                        verticalArrangement = Arrangement.spacedBy(6.dp)
                    ) {
                        Text(
                            text = stringResource(R.string.about_license_status_label),
                            style = MaterialTheme.typography.titleSmall,
                            fontWeight = FontWeight.SemiBold
                        )
                        AboutInlineRow(
                            label = stringResource(R.string.about_license_status_state_label),
                            value = licenseStatus.stateText
                        )
                        licenseStatus.licenseTypeLabel?.let {
                            AboutInlineRow(
                                label = stringResource(R.string.about_license_type_label),
                                value = it
                            )
                        }
                        AboutInlineRow(
                            label = stringResource(R.string.about_license_status_holder_label),
                            value = licenseStatus.holderText
                        )
                        AboutInlineRow(
                            label = stringResource(R.string.about_license_status_validity_label),
                            value = licenseStatus.validityText
                        )
                        AboutInlineRow(
                            label = stringResource(R.string.about_license_status_features_label),
                            value = licenseStatus.featuresText
                        )
                        licenseStatus.bindingText?.let {
                            AboutInlineRow(
                                label = stringResource(R.string.about_license_binding_label),
                                value = it
                            )
                        }
                        licenseStatus.licenseId?.let {
                            AboutInlineRow(
                                label = stringResource(R.string.about_license_id_label),
                                value = it
                            )
                        }
                        if (licenseStatus.permissions.isNotEmpty()) {
                            Text(
                                text = stringResource(R.string.about_license_permissions_label) + ":",
                                style = MaterialTheme.typography.bodyMedium,
                                fontWeight = FontWeight.SemiBold
                            )
                            for ((key, value) in licenseStatus.permissions) {
                                val label = LicenseStatusProvider.humanPermissionLabel(key)
                                val mark = if (value) "✓" else "—"
                                Text(
                                    text = "  $mark $label",
                                    style = MaterialTheme.typography.bodySmall
                                )
                            }
                        }
                        licenseStatus.errorMessage?.let {
                            Text(
                                text = it,
                                style = MaterialTheme.typography.bodySmall,
                                color = MaterialTheme.colorScheme.error
                            )
                        }
                        Text(
                            text = stringResource(R.string.about_license_status_hint),
                            style = MaterialTheme.typography.bodySmall,
                            color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f)
                        )

                        // Aktionen
                        Text(
                            text = stringResource(R.string.about_license_actions_label),
                            style = MaterialTheme.typography.labelLarge,
                            color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f)
                        )

                        // v2.5.25 — Import: OpenDocument() */* + Dispatchers.IO-Fix.
                        // isImporting verhindert Doppelauslösung während laufender I/O.
                        OutlinedButton(
                            onClick = {
                                if (!isImporting) {
                                    try {
                                        importLauncher.launch(arrayOf("*/*"))
                                    } catch (_: ActivityNotFoundException) {
                                        Toast.makeText(
                                            context,
                                            context.getString(R.string.about_license_import_err_no_app),
                                            Toast.LENGTH_LONG
                                        ).show()
                                    }
                                }
                            },
                            enabled = !isImporting,
                            modifier = Modifier.fillMaxWidth()
                        ) {
                            if (isImporting) {
                                Text(stringResource(R.string.about_license_action_import) + "…")
                            } else {
                                Text(stringResource(R.string.about_license_action_import))
                            }
                        }

                        // v2.5.24 — Fallback: Lizenztext manuell einfügen (für MIUI/OEM-Probleme)
                        OutlinedButton(
                            onClick = { showTextImport = true },
                            modifier = Modifier.fillMaxWidth()
                        ) {
                            Text(stringResource(R.string.about_license_action_paste))
                        }

                        val hasStored = remember(reloadTrigger) {
                            LicenseStatusProvider.hasStoredLicense(context)
                        }
                        if (hasStored) {
                            OutlinedButton(
                                onClick = {
                                    try {
                                        exportLauncher.launch(
                                            context.getString(R.string.about_license_export_filename_default)
                                        )
                                    } catch (_: ActivityNotFoundException) {
                                        Toast.makeText(
                                            context,
                                            context.getString(R.string.about_license_export_fail),
                                            Toast.LENGTH_LONG
                                        ).show()
                                    }
                                },
                                modifier = Modifier.fillMaxWidth()
                            ) {
                                Text(stringResource(R.string.about_license_action_export))
                            }
                            OutlinedButton(
                                onClick = { showRemoveConfirm = true },
                                colors = ButtonDefaults.outlinedButtonColors(
                                    contentColor = MaterialTheme.colorScheme.error
                                ),
                                modifier = Modifier.fillMaxWidth()
                            ) {
                                Text(stringResource(R.string.about_license_action_remove))
                            }
                        }

                        HorizontalDivider(modifier = Modifier.padding(vertical = 4.dp))

                        // v2.5.21 — Geräte-ID-Sektion (unverändert)
                        val deviceIdHash = remember(context) { DeviceIdProvider.getDeviceIdHash(context) }
                        val deviceIdShort = remember(deviceIdHash) {
                            if (deviceIdHash.length > 24)
                                "${deviceIdHash.take(16)}…${deviceIdHash.takeLast(8)}"
                            else deviceIdHash
                        }
                        Text(
                            text = stringResource(R.string.about_device_id_label),
                            style = MaterialTheme.typography.titleSmall,
                            fontWeight = FontWeight.SemiBold
                        )
                        Text(
                            text = stringResource(R.string.about_device_id_hint),
                            style = MaterialTheme.typography.bodySmall,
                            color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f)
                        )
                        AboutInlineRow(
                            label = stringResource(R.string.about_device_id_field_label),
                            value = deviceIdShort
                        )
                        OutlinedButton(
                            onClick = {
                                val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE)
                                    as? ClipboardManager
                                if (clipboard != null) {
                                    val clip = ClipData.newPlainText(
                                        context.getString(R.string.about_device_id_copy_label),
                                        deviceIdHash
                                    )
                                    clipboard.setPrimaryClip(clip)
                                    Toast.makeText(
                                        context,
                                        context.getString(R.string.about_device_id_copied),
                                        Toast.LENGTH_SHORT
                                    ).show()
                                }
                            },
                            modifier = Modifier.fillMaxWidth()
                        ) {
                            Text(stringResource(R.string.about_device_id_copy_button))
                        }
                    }
                }

                AboutRow(
                    label = stringResource(R.string.about_version_label),
                    value = versionInfo.display
                )

                AboutRow(
                    label = stringResource(R.string.about_developer_label),
                    value = stringResource(R.string.about_developer)
                )

                AboutRow(
                    label = stringResource(R.string.about_email_label),
                    value = stringResource(R.string.about_email)
                )

                HorizontalDivider()

                Text(
                    text = stringResource(R.string.about_terms_label),
                    style = MaterialTheme.typography.labelLarge,
                    color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
                )
                Text(
                    text = stringResource(R.string.about_terms_text),
                    style = MaterialTheme.typography.bodySmall
                )

                HorizontalDivider()

                Text(
                    text = stringResource(R.string.about_license_label),
                    style = MaterialTheme.typography.labelLarge,
                    color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
                )
                Text(
                    text = stringResource(R.string.about_license_name),
                    style = MaterialTheme.typography.bodyMedium,
                    fontWeight = FontWeight.SemiBold
                )
                Text(
                    text = stringResource(R.string.about_license_summary),
                    style = MaterialTheme.typography.bodySmall
                )
                Text(
                    text = stringResource(R.string.about_license_url),
                    style = MaterialTheme.typography.bodySmall,
                    color = MaterialTheme.colorScheme.primary
                )

                Text(
                    text = stringResource(R.string.about_license_commons_clause_label),
                    style = MaterialTheme.typography.labelLarge,
                    color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
                )
                Text(
                    text = stringResource(R.string.about_license_commons_clause_name),
                    style = MaterialTheme.typography.bodyMedium,
                    fontWeight = FontWeight.SemiBold
                )
                Text(
                    text = stringResource(R.string.about_license_commons_clause_summary),
                    style = MaterialTheme.typography.bodySmall
                )

                Text(
                    text = stringResource(R.string.about_third_party_label),
                    style = MaterialTheme.typography.labelLarge,
                    color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
                )
                Text(
                    text = stringResource(R.string.about_third_party_text),
                    style = MaterialTheme.typography.bodySmall
                )

                Text(
                    text = stringResource(R.string.about_license_disclaimer),
                    style = MaterialTheme.typography.bodySmall,
                    color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
                )

                Card(
                    shape = RoundedCornerShape(12.dp),
                    colors = CardDefaults.cardColors(
                        containerColor = MaterialTheme.colorScheme.surfaceVariant
                    ),
                    elevation = CardDefaults.cardElevation(defaultElevation = 0.dp)
                ) {
                    Column(
                        modifier = Modifier.padding(12.dp),
                        verticalArrangement = Arrangement.spacedBy(6.dp)
                    ) {
                        Text(
                            text = stringResource(R.string.bg_reliability_settings_entry),
                            style = MaterialTheme.typography.titleSmall,
                            fontWeight = FontWeight.SemiBold
                        )
                        Text(
                            text = stringResource(R.string.bg_reliability_settings_entry_subtitle),
                            style = MaterialTheme.typography.bodySmall
                        )
                        TextButton(onClick = { showBgReliability.value = true }) {
                            Text(stringResource(R.string.bg_reliability_title))
                        }
                    }
                }

                Text(
                    text = stringResource(R.string.about_copyright),
                    style = MaterialTheme.typography.bodySmall,
                    color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
                )
            }
        },
        confirmButton = {
            TextButton(onClick = onDismiss) {
                Text(stringResource(R.string.about_close))
            }
        }
    )
}

/**
 * v2.5.25 — readLicenseBytes() läuft vollständig auf Dispatchers.IO (Aufrufer-Pflicht).
 *
 * v2.5.24 — Robuste Lizenzdatei-Lesefunktion mit drei sequenziellen Strategien.
 *
 * Strategien (in dieser Reihenfolge):
 *  a) contentResolver.openInputStream(uri) → copyTo(ByteArrayOutputStream)
 *     Standard-Weg. Scheitert auf MIUI/Xiaomi, wenn der URI nach Rückgabe aus dem
 *     Picker keine gültige temporäre Leseberechtigung mehr hat.
 *  b) contentResolver.openFileDescriptor(uri, "r") → FileInputStream(fd)
 *     Alternativer Weg über ParcelFileDescriptor. Gibt auf manchen OEM-Systemen
 *     einen gültigen FD auch wenn openInputStream() null zurückgibt.
 *  c) uri.scheme == "file" → File(uri.path!!).inputStream()
 *     Fallback für datei-basierte URIs (file://-Schema). Relevant für Geräte, die
 *     echte Dateipfade statt Content-URIs liefern.
 *
 * WICHTIG: Diese Funktion MUSS auf einem IO-Thread aufgerufen werden
 * (z.B. withContext(Dispatchers.IO) { readLicenseBytes(...) }).
 * NetworkOnMainThreadException und StrictMode-Verstöße werden so verhindert.
 *
 * Rückgabe: Pair<ByteArray?, String?>
 *  - Wenn Bytes gelesen: Pair(bytes, null)
 *  - Wenn alle Strategien scheitern: Pair(null, diagnoseMeldung)
 */
private fun readLicenseBytes(context: Context, uri: Uri): Pair<ByteArray?, String?> {
    val errors = mutableListOf<String>()

    // Strategie a: openInputStream
    try {
        val stream = context.contentResolver.openInputStream(uri)
        if (stream != null) {
            val out = ByteArrayOutputStream()
            stream.use { it.copyTo(out) }
            val bytes = out.toByteArray()
            if (bytes.isNotEmpty()) return Pair(bytes, null)
            // Leeres Ergebnis ist kein Fehler der Strategie — wird vom Aufrufer geprüft.
            return Pair(bytes, null)
        } else {
            errors.add("InputStream: null")
        }
    } catch (e: SecurityException) {
        errors.add("InputStream: SecurityException (${e.message?.take(60) ?: "?"})")
    } catch (e: IOException) {
        errors.add("InputStream: IOException (${e.message?.take(60) ?: "?"})")
    } catch (e: Throwable) {
        errors.add("InputStream: ${e.javaClass.simpleName} (${e.message?.take(60) ?: "?"})")
    }

    // Strategie b: openFileDescriptor
    try {
        val pfd: ParcelFileDescriptor? = context.contentResolver.openFileDescriptor(uri, "r")
        if (pfd != null) {
            pfd.use { descriptor ->
                val out = ByteArrayOutputStream()
                FileInputStream(descriptor.fileDescriptor).use { it.copyTo(out) }
                val bytes = out.toByteArray()
                return Pair(bytes, null)
            }
        } else {
            errors.add("FileDescriptor: null")
        }
    } catch (e: SecurityException) {
        errors.add("FileDescriptor: SecurityException (${e.message?.take(60) ?: "?"})")
    } catch (e: IOException) {
        errors.add("FileDescriptor: IOException (${e.message?.take(60) ?: "?"})")
    } catch (e: Throwable) {
        errors.add("FileDescriptor: ${e.javaClass.simpleName} (${e.message?.take(60) ?: "?"})")
    }

    // Strategie c: file:-Schema
    if (uri.scheme?.equals("file", ignoreCase = true) == true) {
        try {
            val path = uri.path
            if (path != null) {
                val file = File(path)
                if (file.exists() && file.canRead()) {
                    val out = ByteArrayOutputStream()
                    file.inputStream().use { it.copyTo(out) }
                    return Pair(out.toByteArray(), null)
                } else {
                    errors.add("File: nicht lesbar (existiert=${file.exists()})")
                }
            } else {
                errors.add("File: path ist null")
            }
        } catch (e: Throwable) {
            errors.add("File: ${e.javaClass.simpleName} (${e.message?.take(60) ?: "?"})")
        }
    } else {
        errors.add("File: kein file:-Schema (scheme=${uri.scheme})")
    }

    // Alle Strategien gescheitert
    val diag = errors.joinToString("; ")
    return Pair(null, diag)
}

/**
 * v2.5.25 — LicenseStatusProvider.import() läuft auf Dispatchers.IO (Aufrufer-Pflicht).
 *
 * v2.5.24 — Dialog zum manuellen Einfügen des Lizenztexts (JSON).
 *
 * Zweck: Fallback für Geräte/Dateimanager, die keine sauberen URIs liefern.
 * Der Nutzer kann den Inhalt der .gps2audio-license-Datei (JSON-Text) direkt
 * einfügen — entweder per Tippen oder per "Aus Zwischenablage".
 *
 * Wichtig:
 * - Der eingefügte Text wird über LicenseStatusProvider.import() importiert.
 * - Bestehende gültige Lizenz wird NICHT überschrieben, wenn der Text ungültig ist.
 * - Der Dialog zeigt klar an, dass das eine Notlösung ist.
 */
@Composable
private fun LicenseTextImportDialog(
    context: Context,
    onDismiss: () -> Unit,
    onImported: () -> Unit
) {
    val scope = rememberCoroutineScope()
    var text by remember { mutableStateOf("") }
    var errorMsg by remember { mutableStateOf<String?>(null) }
    var isImporting by remember { mutableStateOf(false) }

    AlertDialog(
        onDismissRequest = onDismiss,
        title = { Text(stringResource(R.string.about_license_paste_title)) },
        text = {
            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
                Text(
                    text = stringResource(R.string.about_license_paste_hint),
                    style = MaterialTheme.typography.bodySmall,
                    color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.75f)
                )
                OutlinedTextField(
                    value = text,
                    onValueChange = {
                        text = it
                        errorMsg = null
                    },
                    modifier = Modifier
                        .fillMaxWidth()
                        .heightIn(min = 120.dp, max = 200.dp),
                    label = { Text(stringResource(R.string.about_license_paste_field_label)) },
                    placeholder = { Text("{ \"license_id\": \"...\", ... }") },
                    maxLines = 12
                )
                // "Aus Zwischenablage" Button
                TextButton(
                    onClick = {
                        val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE)
                            as? ClipboardManager
                        val clip = clipboard?.primaryClip
                        if (clip != null && clip.itemCount > 0) {
                            val pasted = clip.getItemAt(0).coerceToText(context).toString()
                            text = pasted
                            errorMsg = null
                        } else {
                            errorMsg = context.getString(R.string.about_license_paste_clipboard_empty)
                        }
                    },
                    modifier = Modifier.fillMaxWidth()
                ) {
                    Text(stringResource(R.string.about_license_paste_from_clipboard))
                }
                errorMsg?.let {
                    Text(
                        text = it,
                        style = MaterialTheme.typography.bodySmall,
                        color = MaterialTheme.colorScheme.error
                    )
                }
            }
        },
        confirmButton = {
            Button(
                onClick = {
                    val trimmed = text.trim()
                    if (trimmed.isEmpty()) {
                        errorMsg = context.getString(R.string.about_license_paste_empty_error)
                        return@Button
                    }
                    // v2.5.25 — JSON-Parsing + Signaturvalidierung auf Dispatchers.IO
                    isImporting = true
                    errorMsg = null
                    val bytes = trimmed.toByteArray(Charsets.UTF_8)
                    scope.launch {
                        val result = withContext(Dispatchers.IO) {
                            LicenseStatusProvider.import(context, bytes)
                        }
                        isImporting = false
                        if (result.success) {
                            Toast.makeText(
                                context,
                                context.getString(R.string.about_license_import_success, result.message),
                                Toast.LENGTH_LONG
                            ).show()
                            onImported()
                        } else {
                            errorMsg = context.getString(
                                R.string.about_license_import_fail_invalid,
                                result.message
                            )
                        }
                    }
                },
                enabled = text.isNotBlank() && !isImporting
            ) {
                Text(stringResource(R.string.about_license_paste_import_button))
            }
        },
        dismissButton = {
            TextButton(onClick = onDismiss) {
                Text(stringResource(R.string.cancel))
            }
        }
    )
}

@Composable
private fun AboutRow(label: String, value: String) {
    Column(verticalArrangement = Arrangement.spacedBy(2.dp)) {
        Text(
            text = label,
            style = MaterialTheme.typography.labelLarge,
            color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
        )
        Text(
            text = value,
            style = MaterialTheme.typography.bodyMedium
        )
    }
}

@Composable
private fun AboutInlineRow(
    label: String,
    value: String,
    color: androidx.compose.ui.graphics.Color = MaterialTheme.colorScheme.onSurface
) {
    Row(
        modifier = Modifier.fillMaxWidth(),
        horizontalArrangement = Arrangement.spacedBy(8.dp)
    ) {
        Text(
            text = "$label:",
            style = MaterialTheme.typography.bodyMedium,
            fontWeight = FontWeight.SemiBold,
            color = color
        )
        Text(
            text = value,
            style = MaterialTheme.typography.bodyMedium,
            color = color
        )
    }
}