import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'dart:math' as math;

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter_colorpicker/flutter_colorpicker.dart';
import 'package:image/image.dart' as img;
import 'package:image_picker/image_picker.dart';
import 'package:path_provider/path_provider.dart';

void main() {
  runApp(const KorkenMosaicApp());
}

class KorkenMosaicApp extends StatelessWidget {
  const KorkenMosaicApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Korken Mosaic',
      theme: ThemeData(colorSchemeSeed: Colors.teal, useMaterial3: true),
      home: const MosaicHomePage(),
    );
  }
}

enum StylePreset { realistisch, ausgewogen, kuenstlerisch }

enum CatalogViewMode { list, grid }

enum ColorExtractionMode { dominant, average }

enum HomeSection { mosaic, catalog }

class MosaicHomePage extends StatefulWidget {
  const MosaicHomePage({super.key});

  @override
  State<MosaicHomePage> createState() => _MosaicHomePageState();
}

class _MosaicHomePageState extends State<MosaicHomePage>
    with WidgetsBindingObserver {
  final ImagePicker _picker = ImagePicker();
  // Capture review state lives in a dedicated full-screen route.
  final TextEditingController _gridWidthCtrl =
      TextEditingController(text: '40');
  final TextEditingController _gridHeightCtrl =
      TextEditingController(text: '30');
  final TextEditingController _capSizeCtrl = TextEditingController(text: '12');

  Uint8List? _sourceImageBytes;
  MosaicResult? _result;
  bool _useCapSize = false;
  bool _isGenerating = false;
  Timer? _debounceTimer;
  int _generationToken = 0;
  bool _isCatalogLoaded = false;
  HomeSection _activeSection = HomeSection.mosaic;
  CatalogViewMode _catalogViewMode = CatalogViewMode.grid;
  ColorExtractionMode _colorExtractionMode = ColorExtractionMode.dominant;
  bool _isCaptureFlowInProgress = false;
  bool _isRecoveringCapture = false;

  double _fidelityStructure = 0.5;
  double _ditheringStrength = 0.35;
  double _edgeEmphasis = 0.4;
  double _colorVariation = 0.3;
  StylePreset _selectedPreset = StylePreset.ausgewogen;

  List<CapCatalogEntry> _catalog = [];

  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addObserver(this);
    _gridWidthCtrl.addListener(_scheduleRegenerate);
    _gridHeightCtrl.addListener(_scheduleRegenerate);
    _capSizeCtrl.addListener(_scheduleRegenerate);
    _loadCatalog();
    WidgetsBinding.instance.addPostFrameCallback((_) {
      _recoverCaptureOnResumeOrStart();
    });
  }

  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    if (state == AppLifecycleState.resumed) {
      _recoverCaptureOnResumeOrStart();
    }
  }

  @override
  void dispose() {
    WidgetsBinding.instance.removeObserver(this);
    _debounceTimer?.cancel();
    _gridWidthCtrl.dispose();
    _gridHeightCtrl.dispose();
    _capSizeCtrl.dispose();
    // No extra capture controllers to dispose.
    super.dispose();
  }

  Future<File> _catalogFile() async {
    final docs = await getApplicationDocumentsDirectory();
    return File('${docs.path}/cap_catalog.json');
  }

  Future<String> _saveThumbnail(Uint8List bytes, String id) async {
    final docs = await getApplicationDocumentsDirectory();
    final dir = Directory('${docs.path}/cap_thumbs');
    await dir.create(recursive: true);
    final file = File('${dir.path}/$id.png');
    await file.writeAsBytes(bytes, flush: true);
    return file.path;
  }

  Future<void> _loadCatalog() async {
    final defaults = [
      CapCatalogEntry.newEntry(name: 'White', color: const Color(0xFFF2F2F2)),
      CapCatalogEntry.newEntry(name: 'Black', color: const Color(0xFF222222)),
      CapCatalogEntry.newEntry(name: 'Red', color: const Color(0xFFD84343)),
      CapCatalogEntry.newEntry(name: 'Blue', color: const Color(0xFF3F6FD8)),
      CapCatalogEntry.newEntry(name: 'Green', color: const Color(0xFF4FAE63)),
    ];

    try {
      final file = await _catalogFile();
      if (await file.exists()) {
        final jsonRaw = jsonDecode(await file.readAsString()) as List<dynamic>;
        _catalog = jsonRaw
            .map((e) => CapCatalogEntry.fromJson(e as Map<String, dynamic>))
            .toList();
      }
      if (_catalog.isEmpty) {
        _catalog = defaults;
        await _persistCatalog();
      }
    } catch (_) {
      _catalog = defaults;
    }

    if (!mounted) return;
    setState(() => _isCatalogLoaded = true);
  }

  Future<void> _persistCatalog() async {
    final file = await _catalogFile();
    final jsonData = jsonEncode(_catalog.map((e) => e.toJson()).toList());
    await file.writeAsString(jsonData, flush: true);
  }

  Future<void> _pickImage() async {
    final XFile? picked = await _picker.pickImage(source: ImageSource.gallery);
    if (picked == null) return;
    final bytes = await picked.readAsBytes();
    setState(() {
      _sourceImageBytes = bytes;
      _result = null;
    });
  }

  Future<File> _pendingCaptureFile() async {
    final docs = await getApplicationDocumentsDirectory();
    return File('${docs.path}/pending_cap_capture.jpg');
  }

  Future<void> _setPendingCapture(Uint8List? bytes) async {
    final file = await _pendingCaptureFile();
    if (bytes == null) {
      if (await file.exists()) {
        await file.delete();
      }
      return;
    }
    await file.writeAsBytes(bytes, flush: true);
  }

  Future<Uint8List?> _readPendingCapture() async {
    final file = await _pendingCaptureFile();
    if (!await file.exists()) return null;
    return file.readAsBytes();
  }

  Future<void> _recoverCaptureOnResumeOrStart() async {
    if (_isRecoveringCapture || _isCaptureFlowInProgress || !mounted) return;
    _isRecoveringCapture = true;
    try {
      Uint8List? recovered;
      try {
        final lost = await _picker.retrieveLostData();
        if (!lost.isEmpty) {
          final file = lost.file ??
              (lost.files?.isNotEmpty == true ? lost.files!.first : null);
          if (file != null) {
            recovered = await file.readAsBytes();
            await _setPendingCapture(recovered);
          }
        }
      } catch (e, st) {
        debugPrint('[cap-photo] retrieveLostData failed: $e\n$st');
      }
      recovered ??= await _readPendingCapture();
      if (recovered == null || !mounted) return;
      await _openCaptureReviewFlow(recovered, recoveredFromPending: true);
    } finally {
      _isRecoveringCapture = false;
    }
  }

  Future<void> _captureCapPhoto() async {
    if (_isCaptureFlowInProgress) return;

    setState(() => _isCaptureFlowInProgress = true);
    try {
      final XFile? captured = await _picker.pickImage(
        source: ImageSource.camera,
        preferredCameraDevice: CameraDevice.rear,
        imageQuality: 95,
        maxWidth: 1800,
      );
      if (captured == null) {
        debugPrint('[cap-photo] Capture cancelled by user.');
        await _setPendingCapture(null);
        return;
      }

      Uint8List bytes;
      try {
        bytes = await captured.readAsBytes();
      } catch (e, st) {
        debugPrint('[cap-photo] Failed to read captured bytes: $e\n$st');
        final fallbackImage = img.Image(width: 1, height: 1)
          ..setPixelRgb(0, 0, 255, 152, 0);
        bytes = Uint8List.fromList(img.encodePng(fallbackImage, level: 1));
      }

      await _setPendingCapture(bytes);
      await _openCaptureReviewFlow(bytes);
    } finally {
      if (mounted) {
        setState(() => _isCaptureFlowInProgress = false);
      } else {
        _isCaptureFlowInProgress = false;
      }
    }
  }

  Future<void> _openCaptureReviewFlow(
    Uint8List bytes, {
    bool recoveredFromPending = false,
  }) async {
    Map<String, dynamic> detected;
    String? detectionWarning;
    try {
      detected = await compute(_extractCapFromPhotoIsolate, bytes);
    } catch (e, st) {
      debugPrint('[cap-photo] Detection isolate failed: $e\n$st');
      detectionWarning =
          '⚠️ Farberkennung ist fehlgeschlagen. Fallback-Farbe wird verwendet; bitte prüfen/korrigieren.';
      final decoded = img.decodeImage(bytes);
      final imageW = (decoded?.width ?? 1).toDouble();
      final imageH = (decoded?.height ?? 1).toDouble();
      final fallbackColor = Colors.orange.toARGB32();
      detected = {
        'dominantColor': fallbackColor,
        'averageColor': fallbackColor,
        'usedFallback': true,
        'circleX': imageW / 2,
        'circleY': imageH / 2,
        'circleR': math.min(imageW, imageH) * 0.28,
        'imageW': imageW,
        'imageH': imageH,
        'previewPng': bytes,
      };
    }

    if (!mounted) return;

    final reviewResult =
        await Navigator.of(context).push<_CapPhotoReviewResult>(
      MaterialPageRoute(
        fullscreenDialog: true,
        builder: (_) => _CapPhotoReviewPage(
          imageBytes: bytes,
          detected: detected,
          initialMode: _colorExtractionMode,
          initialName: 'Fotografierter Deckel',
          initialWarning: detectionWarning,
        ),
      ),
    );

    if (reviewResult == null) {
      await _setPendingCapture(null);
      return;
    }

    _colorExtractionMode = reviewResult.mode;
    final entry = CapCatalogEntry.newEntry(
      name: reviewResult.name,
      color: reviewResult.color,
    );
    entry.imagePath = await _saveThumbnail(reviewResult.previewBytes, entry.id);
    _catalog.add(entry);
    await _persistCatalog();
    await _setPendingCapture(null);

    if (!mounted) return;
    setState(() {});
    _scheduleRegenerate();
  }

  // Circle clamping helper is used by the dedicated review route.

  void _scheduleRegenerate() {
    if (_sourceImageBytes == null || _result == null) return;
    _debounceTimer?.cancel();
    _debounceTimer = Timer(const Duration(milliseconds: 250), _generate);
  }

  void _applyPreset(StylePreset preset) {
    setState(() {
      _selectedPreset = preset;
      switch (preset) {
        case StylePreset.realistisch:
          _fidelityStructure = 0.2;
          _ditheringStrength = 0.15;
          _edgeEmphasis = 0.25;
          _colorVariation = 0.1;
          break;
        case StylePreset.ausgewogen:
          _fidelityStructure = 0.5;
          _ditheringStrength = 0.35;
          _edgeEmphasis = 0.4;
          _colorVariation = 0.3;
          break;
        case StylePreset.kuenstlerisch:
          _fidelityStructure = 0.82;
          _ditheringStrength = 0.75;
          _edgeEmphasis = 0.75;
          _colorVariation = 0.78;
          break;
      }
    });
    _scheduleRegenerate();
  }

  void _onStyleChanged() {
    if (_selectedPreset != StylePreset.ausgewogen) {
      setState(() => _selectedPreset = StylePreset.ausgewogen);
    }
    _scheduleRegenerate();
  }

  Future<void> _addCapDialog() async {
    Color selected = Colors.orange;
    final nameCtrl = TextEditingController();
    final hexCtrl = TextEditingController(text: _colorToHex(selected));
    String? imagePath;

    await showDialog<void>(
      context: context,
      builder: (ctx) {
        return StatefulBuilder(
          builder: (ctx, setDialogState) {
            return AlertDialog(
              title: const Text('Deckel manuell hinzufügen'),
              content: SingleChildScrollView(
                child: Column(
                  mainAxisSize: MainAxisSize.min,
                  children: [
                    TextField(
                        controller: nameCtrl,
                        decoration: const InputDecoration(labelText: 'Name')),
                    const SizedBox(height: 8),
                    TextField(
                      controller: hexCtrl,
                      decoration:
                          const InputDecoration(labelText: 'Hex (#RRGGBB)'),
                      onChanged: (value) {
                        final parsed = _parseHex(value);
                        if (parsed != null) {
                          setDialogState(() => selected = parsed);
                        }
                      },
                    ),
                    const SizedBox(height: 8),
                    OutlinedButton.icon(
                      onPressed: () async {
                        final picked = await _picker.pickImage(
                            source: ImageSource.gallery,
                            maxWidth: 1200,
                            imageQuality: 90);
                        if (picked == null) return;
                        imagePath = picked.path;
                        setDialogState(() {});
                      },
                      icon: const Icon(Icons.image_outlined),
                      label: Text(imagePath == null
                          ? 'Optionales Foto wählen'
                          : 'Foto gewählt ✅'),
                    ),
                    const SizedBox(height: 12),
                    ColorPicker(
                      pickerColor: selected,
                      onColorChanged: (c) {
                        selected = c;
                        hexCtrl.text = _colorToHex(c);
                        setDialogState(() {});
                      },
                    ),
                  ],
                ),
              ),
              actions: [
                TextButton(
                    onPressed: () => Navigator.pop(ctx),
                    child: const Text('Cancel')),
                FilledButton(
                  onPressed: () async {
                    final name = nameCtrl.text.trim();
                    if (name.isEmpty) return;
                    final entry = CapCatalogEntry.newEntry(
                        name: name,
                        color: _parseHex(hexCtrl.text) ?? selected,
                        imagePath: imagePath);
                    _catalog.add(entry);
                    await _persistCatalog();
                    if (!mounted) return;
                    setState(() {});
                    if (!ctx.mounted) return;
                    Navigator.pop(ctx);
                    _scheduleRegenerate();
                  },
                  child: const Text('Add'),
                ),
              ],
            );
          },
        );
      },
    );
  }

  Future<void> _editEntry(CapCatalogEntry entry) async {
    Color selected = entry.color;
    final nameCtrl = TextEditingController(text: entry.name);
    final hexCtrl = TextEditingController(text: _colorToHex(entry.color));
    String? imagePath = entry.imagePath;

    await showDialog<void>(
      context: context,
      builder: (ctx) {
        return StatefulBuilder(builder: (ctx, setDialogState) {
          return AlertDialog(
            title: const Text('Deckel bearbeiten'),
            content: SingleChildScrollView(
              child: Column(
                mainAxisSize: MainAxisSize.min,
                crossAxisAlignment: CrossAxisAlignment.stretch,
                children: [
                  if (imagePath != null && File(imagePath!).existsSync())
                    ClipRRect(
                      borderRadius: BorderRadius.circular(12),
                      child: Image.file(
                        File(imagePath!),
                        height: 160,
                        fit: BoxFit.cover,
                      ),
                    )
                  else
                    Container(
                      height: 160,
                      alignment: Alignment.center,
                      decoration: BoxDecoration(
                        color:
                            Theme.of(ctx).colorScheme.surfaceContainerHighest,
                        borderRadius: BorderRadius.circular(12),
                      ),
                      child: const Icon(Icons.photo_outlined, size: 40),
                    ),
                  const SizedBox(height: 8),
                  Row(
                    children: [
                      OutlinedButton.icon(
                        onPressed: () async {
                          final picked = await _picker.pickImage(
                            source: ImageSource.gallery,
                            maxWidth: 1200,
                            imageQuality: 90,
                          );
                          if (picked == null) return;
                          imagePath = picked.path;
                          setDialogState(() {});
                        },
                        icon: const Icon(Icons.image_outlined),
                        label: const Text('Foto ändern'),
                      ),
                      const SizedBox(width: 8),
                      if (imagePath != null)
                        TextButton(
                          onPressed: () {
                            imagePath = null;
                            setDialogState(() {});
                          },
                          child: const Text('Foto entfernen'),
                        ),
                    ],
                  ),
                  const SizedBox(height: 8),
                  TextField(
                      controller: nameCtrl,
                      decoration: const InputDecoration(labelText: 'Name')),
                  const SizedBox(height: 8),
                  TextField(
                    controller: hexCtrl,
                    decoration:
                        const InputDecoration(labelText: 'Hex (#RRGGBB)'),
                    onChanged: (value) {
                      final parsed = _parseHex(value);
                      if (parsed != null) {
                        selected = parsed;
                        setDialogState(() {});
                      }
                    },
                  ),
                  const SizedBox(height: 8),
                  Row(
                    children: [
                      CircleAvatar(radius: 14, backgroundColor: selected),
                      const SizedBox(width: 8),
                      Text(_colorToHex(selected)),
                    ],
                  ),
                  const SizedBox(height: 12),
                  ColorPicker(
                    pickerColor: selected,
                    onColorChanged: (c) {
                      selected = c;
                      hexCtrl.text = _colorToHex(c);
                      setDialogState(() {});
                    },
                  ),
                ],
              ),
            ),
            actions: [
              TextButton(
                  onPressed: () => Navigator.pop(ctx),
                  child: const Text('Abbrechen')),
              FilledButton(
                onPressed: () async {
                  entry.name = nameCtrl.text.trim().isEmpty
                      ? entry.name
                      : nameCtrl.text.trim();
                  entry.colorValue =
                      (_parseHex(hexCtrl.text) ?? selected).toARGB32();
                  entry.imagePath = imagePath;
                  await _persistCatalog();
                  if (!mounted) return;
                  setState(() {});
                  if (!ctx.mounted) return;
                  Navigator.pop(ctx);
                  _scheduleRegenerate();
                },
                child: const Text('Speichern'),
              ),
            ],
          );
        });
      },
    );
  }

  Future<void> _deleteEntry(CapCatalogEntry entry) async {
    if (_catalog.length <= 1) return;
    _catalog.removeWhere((e) => e.id == entry.id);
    if (entry.imagePath != null) {
      final f = File(entry.imagePath!);
      if (await f.exists()) {
        await f.delete();
      }
    }
    await _persistCatalog();
    if (!mounted) return;
    setState(() {});
    _scheduleRegenerate();
  }

  Future<void> _generate() async {
    if (_sourceImageBytes == null || _catalog.isEmpty) return;

    final int gridW = math.max(1, int.tryParse(_gridWidthCtrl.text) ?? 40);
    final int gridH = math.max(1, int.tryParse(_gridHeightCtrl.text) ?? 30);
    final int capSize = math.max(1, int.tryParse(_capSizeCtrl.text) ?? 12);

    final token = ++_generationToken;
    setState(() => _isGenerating = true);

    final payload = <String, dynamic>{
      'source': _sourceImageBytes!,
      'useCapSize': _useCapSize,
      'gridW': gridW,
      'gridH': gridH,
      'capSize': capSize,
      'fidelityStructure': _fidelityStructure,
      'ditheringStrength': _ditheringStrength,
      'edgeEmphasis': _edgeEmphasis,
      'colorVariation': _colorVariation,
      'palette': _catalog
          .map((p) => <String, dynamic>{'name': p.name, 'value': p.colorValue})
          .toList(growable: false),
    };

    final out = await compute(_generateMosaicIsolate, payload);
    if (!mounted || token != _generationToken) return;

    final palette = (out['palette'] as List)
        .map((e) => CapColor(
            name: e['name'] as String, color: Color(e['value'] as int)))
        .toList(growable: false);

    final countsList = (out['counts'] as List).cast<int>();
    final counts = <CapColor, int>{};
    for (int i = 0; i < palette.length; i++) {
      counts[palette[i]] = countsList[i];
    }

    final sortedCounts = counts.entries.toList()
      ..sort((a, b) => b.value.compareTo(a.value));

    setState(() {
      _result = MosaicResult(
        width: out['width'] as int,
        height: out['height'] as int,
        assignments: (out['assignments'] as List).cast<int>(),
        palette: palette,
        counts: counts,
        sortedCounts: sortedCounts,
        previewPng: out['previewPng'] as Uint8List,
      );
      _isGenerating = false;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(_activeSection == HomeSection.mosaic
            ? 'Bottle-Cap Mosaic Prototype'
            : 'Cap Catalog'),
      ),
      floatingActionButton: _activeSection == HomeSection.mosaic
          ? FloatingActionButton.extended(
              onPressed: _isGenerating ? null : _generate,
              icon: _isGenerating
                  ? const SizedBox(
                      width: 18,
                      height: 18,
                      child: CircularProgressIndicator(strokeWidth: 2))
                  : const Icon(Icons.auto_fix_high),
              label: Text(_isGenerating ? 'Generating…' : 'Generate Mosaic'),
            )
          : null,
      body: !_isCatalogLoaded
          ? const Center(child: CircularProgressIndicator())
          : _activeSection == HomeSection.mosaic
              ? _buildMosaicScreen()
              : _buildCatalogScreen(),
      bottomNavigationBar: NavigationBar(
        selectedIndex: _activeSection.index,
        onDestinationSelected: (index) {
          setState(() => _activeSection = HomeSection.values[index]);
        },
        destinations: const [
          NavigationDestination(
            icon: Icon(Icons.auto_awesome_outlined),
            selectedIcon: Icon(Icons.auto_awesome),
            label: 'Mosaic',
          ),
          NavigationDestination(
            icon: Icon(Icons.inventory_2_outlined),
            selectedIcon: Icon(Icons.inventory_2),
            label: 'Catalog',
          ),
        ],
      ),
    );
  }

  Widget _buildMosaicScreen() {
    return Padding(
      padding: const EdgeInsets.all(12),
      child: ListView(
        children: [
          Wrap(
            runSpacing: 8,
            spacing: 8,
            crossAxisAlignment: WrapCrossAlignment.center,
            children: [
              FilledButton.icon(
                onPressed: _pickImage,
                icon: const Icon(Icons.image_outlined),
                label: const Text('Import target image'),
              ),
              if (_sourceImageBytes != null) const Text('Image loaded ✅'),
            ],
          ),
          const SizedBox(height: 12),
          SegmentedButton<bool>(
            segments: const [
              ButtonSegment(value: false, label: Text('Grid W x H')),
              ButtonSegment(value: true, label: Text('Cap size (px)')),
            ],
            selected: {_useCapSize},
            onSelectionChanged: (s) {
              setState(() => _useCapSize = s.first);
              _scheduleRegenerate();
            },
          ),
          const SizedBox(height: 8),
          if (!_useCapSize)
            Row(
              children: [
                Expanded(
                  child: TextField(
                      controller: _gridWidthCtrl,
                      keyboardType: TextInputType.number,
                      decoration:
                          const InputDecoration(labelText: 'Grid Width')),
                ),
                const SizedBox(width: 8),
                Expanded(
                  child: TextField(
                      controller: _gridHeightCtrl,
                      keyboardType: TextInputType.number,
                      decoration:
                          const InputDecoration(labelText: 'Grid Height')),
                ),
              ],
            )
          else
            TextField(
              controller: _capSizeCtrl,
              keyboardType: TextInputType.number,
              decoration: const InputDecoration(
                  labelText: 'Approx cap size in source image (pixels)'),
            ),
          const SizedBox(height: 16),
          const Text('Style Preset',
              style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold)),
          const SizedBox(height: 8),
          SegmentedButton<StylePreset>(
            segments: const [
              ButtonSegment(
                  value: StylePreset.realistisch, label: Text('Realistisch')),
              ButtonSegment(
                  value: StylePreset.ausgewogen, label: Text('Ausgewogen')),
              ButtonSegment(
                  value: StylePreset.kuenstlerisch,
                  label: Text('Künstlerisch')),
            ],
            selected: {_selectedPreset},
            onSelectionChanged: (s) => _applyPreset(s.first),
          ),
          const SizedBox(height: 8),
          Card(
            child: Padding(
              padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 8),
              child: Column(
                children: [
                  _SliderRow(
                      label: 'Fidelity ↔ Structure',
                      leftLabel: 'Fidelity',
                      rightLabel: 'Structure',
                      value: _fidelityStructure,
                      onChanged: (v) {
                        setState(() => _fidelityStructure = v);
                        _onStyleChanged();
                      }),
                  _SliderRow(
                      label: 'Dithering strength',
                      leftLabel: 'Off',
                      rightLabel: 'Strong',
                      value: _ditheringStrength,
                      onChanged: (v) {
                        setState(() => _ditheringStrength = v);
                        _onStyleChanged();
                      }),
                  _SliderRow(
                      label: 'Edge emphasis',
                      leftLabel: 'Soft',
                      rightLabel: 'Crisp',
                      value: _edgeEmphasis,
                      onChanged: (v) {
                        setState(() => _edgeEmphasis = v);
                        _onStyleChanged();
                      }),
                  _SliderRow(
                      label: 'Color tolerance / variation',
                      leftLabel: 'Strict',
                      rightLabel: 'Varied',
                      value: _colorVariation,
                      onChanged: (v) {
                        setState(() => _colorVariation = v);
                        _onStyleChanged();
                      }),
                ],
              ),
            ),
          ),
          const SizedBox(height: 16),
          if (_result != null) ...[
            Text('Preview (${_result!.width} x ${_result!.height})',
                style:
                    const TextStyle(fontSize: 18, fontWeight: FontWeight.bold)),
            const SizedBox(height: 8),
            RepaintBoundary(
              child: AspectRatio(
                aspectRatio: _result!.width / _result!.height,
                child: Image.memory(_result!.previewPng,
                    fit: BoxFit.fill,
                    filterQuality: FilterQuality.none,
                    gaplessPlayback: true),
              ),
            ),
            const SizedBox(height: 16),
            const Text('Bill of Materials',
                style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold)),
            ..._result!.sortedCounts.map(
              (e) => ListTile(
                dense: true,
                leading: CircleAvatar(backgroundColor: e.key.color),
                title: Text(e.key.name),
                trailing: Text('${e.value} caps'),
              ),
            ),
          ],
        ],
      ),
    );
  }

  Widget _buildCatalogScreen() {
    return Padding(
      padding: const EdgeInsets.all(12),
      child: ListView(
        children: [
          Row(
            children: [
              IconButton(
                onPressed: () =>
                    setState(() => _catalogViewMode = CatalogViewMode.list),
                icon: Icon(Icons.view_list,
                    color: _catalogViewMode == CatalogViewMode.list
                        ? Theme.of(context).colorScheme.primary
                        : null),
                tooltip: 'Listenansicht',
              ),
              IconButton(
                onPressed: () =>
                    setState(() => _catalogViewMode = CatalogViewMode.grid),
                icon: Icon(Icons.grid_view,
                    color: _catalogViewMode == CatalogViewMode.grid
                        ? Theme.of(context).colorScheme.primary
                        : null),
                tooltip: 'Rasteransicht',
              ),
              const Spacer(),
              OutlinedButton.icon(
                  onPressed: _isCaptureFlowInProgress ? null : _captureCapPhoto,
                  icon: _isCaptureFlowInProgress
                      ? const SizedBox(
                          width: 16,
                          height: 16,
                          child: CircularProgressIndicator(strokeWidth: 2),
                        )
                      : const Icon(Icons.photo_camera_outlined),
                  label: Text(_isCaptureFlowInProgress ? 'Läuft…' : 'Foto')),
              const SizedBox(width: 8),
              IconButton(
                  onPressed: _addCapDialog,
                  icon: const Icon(Icons.add_circle_outline),
                  tooltip: 'Manuell hinzufügen'),
            ],
          ),
          const SizedBox(height: 8),
          _buildCatalogView(),
        ],
      ),
    );
  }

  Widget _buildCatalogView() {
    if (_catalog.isEmpty) return const Text('Noch keine Deckel im Katalog');

    if (_catalogViewMode == CatalogViewMode.list) {
      return Column(
        children: _catalog
            .map(
              (entry) => Card(
                child: ListTile(
                  onTap: () => _editEntry(entry),
                  leading: SizedBox(
                    width: 88,
                    child: Row(
                      children: [
                        _CapThumb(entry: entry),
                        const SizedBox(width: 8),
                        _ColorSwatch(color: entry.color),
                      ],
                    ),
                  ),
                  title: Text(entry.name),
                  subtitle: Text(_colorToHex(entry.color)),
                  trailing: IconButton(
                    onPressed:
                        _catalog.length <= 1 ? null : () => _deleteEntry(entry),
                    icon: const Icon(Icons.delete_outline),
                  ),
                ),
              ),
            )
            .toList(),
      );
    }

    return GridView.builder(
      shrinkWrap: true,
      physics: const NeverScrollableScrollPhysics(),
      itemCount: _catalog.length,
      gridDelegate: const SliverGridDelegateWithFixedCrossAxisCount(
        crossAxisCount: 2,
        childAspectRatio: 1.2,
        mainAxisSpacing: 8,
        crossAxisSpacing: 8,
      ),
      itemBuilder: (context, index) {
        final entry = _catalog[index];
        return Card(
          clipBehavior: Clip.antiAlias,
          child: InkWell(
            onTap: () => _editEntry(entry),
            child: Padding(
              padding: const EdgeInsets.all(8),
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Row(
                    children: [
                      Expanded(child: _CapThumb(entry: entry, large: true)),
                      const SizedBox(width: 8),
                      _ColorSwatch(color: entry.color, large: true),
                    ],
                  ),
                  const SizedBox(height: 6),
                  Text(entry.name,
                      maxLines: 1,
                      overflow: TextOverflow.ellipsis,
                      style: const TextStyle(fontWeight: FontWeight.w600)),
                  Row(
                    children: [
                      Text(_colorToHex(entry.color),
                          style: Theme.of(context).textTheme.bodySmall),
                      const Spacer(),
                      IconButton(
                        visualDensity: VisualDensity.compact,
                        onPressed: _catalog.length <= 1
                            ? null
                            : () => _deleteEntry(entry),
                        icon: const Icon(Icons.delete_outline),
                      ),
                    ],
                  ),
                ],
              ),
            ),
          ),
        );
      },
    );
  }

  Color? _parseHex(String raw) {
    final hex = raw.trim().replaceFirst('#', '');
    if (hex.length != 6) return null;
    final value = int.tryParse(hex, radix: 16);
    if (value == null) return null;
    return Color(0xFF000000 | value);
  }

  String _colorToHex(Color color) {
    return '#${color.toARGB32().toRadixString(16).substring(2).toUpperCase()}';
  }
}

class _CapPhotoReviewResult {
  final String name;
  final Color color;
  final ColorExtractionMode mode;
  final Uint8List previewBytes;

  const _CapPhotoReviewResult({
    required this.name,
    required this.color,
    required this.mode,
    required this.previewBytes,
  });
}

class _CapPhotoReviewPage extends StatefulWidget {
  final Uint8List imageBytes;
  final Map<String, dynamic> detected;
  final ColorExtractionMode initialMode;
  final String initialName;
  final String? initialWarning;

  const _CapPhotoReviewPage({
    required this.imageBytes,
    required this.detected,
    required this.initialMode,
    required this.initialName,
    this.initialWarning,
  });

  @override
  State<_CapPhotoReviewPage> createState() => _CapPhotoReviewPageState();
}

class _CapPhotoReviewPageState extends State<_CapPhotoReviewPage> {
  late final TextEditingController _nameCtrl;
  late final TextEditingController _hexCtrl;

  late Color _dominantColor;
  late Color _averageColor;
  late Uint8List _previewBytes;
  late bool _usedFallback;
  late double _imageW;
  late double _imageH;
  late double _circleX;
  late double _circleY;
  late double _circleR;
  late ColorExtractionMode _mode;
  late Color _selected;
  String? _warning;

  Timer? _liveDebounce;
  int _recalcToken = 0;

  @override
  void initState() {
    super.initState();
    final detected = widget.detected;
    _dominantColor = Color(detected['dominantColor'] as int);
    _averageColor = Color(detected['averageColor'] as int);
    _previewBytes = detected['previewPng'] as Uint8List;
    _usedFallback = detected['usedFallback'] as bool? ?? false;
    _imageW = (detected['imageW'] as num).toDouble();
    _imageH = (detected['imageH'] as num).toDouble();
    _circleX = (detected['circleX'] as num).toDouble() / _imageW;
    _circleY = (detected['circleY'] as num).toDouble() / _imageH;
    _circleR =
        (detected['circleR'] as num).toDouble() / math.min(_imageW, _imageH);

    final clamped = _clampCircleNormalized(
      imageW: _imageW,
      imageH: _imageH,
      circleX: _circleX,
      circleY: _circleY,
      circleR: _circleR,
    );
    _circleX = clamped.x;
    _circleY = clamped.y;
    _circleR = clamped.r;

    _mode = widget.initialMode;
    _selected =
        _mode == ColorExtractionMode.dominant ? _dominantColor : _averageColor;
    _nameCtrl = TextEditingController(text: widget.initialName);
    _hexCtrl = TextEditingController(text: _colorToHexStatic(_selected));
    _warning = widget.initialWarning;
  }

  @override
  void dispose() {
    _liveDebounce?.cancel();
    _nameCtrl.dispose();
    _hexCtrl.dispose();
    super.dispose();
  }

  void _setAndClampCircle({double? x, double? y, double? r}) {
    if (x != null) _circleX = x;
    if (y != null) _circleY = y;
    if (r != null) _circleR = r;
    final clamped = _clampCircleNormalized(
      imageW: _imageW,
      imageH: _imageH,
      circleX: _circleX,
      circleY: _circleY,
      circleR: _circleR,
    );
    _circleX = clamped.x;
    _circleY = clamped.y;
    _circleR = clamped.r;
  }

  void _scheduleLiveRecalculate() {
    _liveDebounce?.cancel();
    _liveDebounce = Timer(const Duration(milliseconds: 180), () {
      _recalculate(updateUiBefore: false);
    });
  }

  Future<void> _recalculate({bool updateUiBefore = true}) async {
    final localToken = ++_recalcToken;
    if (updateUiBefore && mounted) setState(() {});
    try {
      final adjusted = await compute(
        _extractCapFromAdjustedCircleIsolate,
        <String, dynamic>{
          'sourceBytes': widget.imageBytes,
          'circleX': _circleX,
          'circleY': _circleY,
          'circleR': _circleR,
        },
      );
      if (localToken != _recalcToken) return;
      _dominantColor = Color(adjusted['dominantColor'] as int);
      _averageColor = Color(adjusted['averageColor'] as int);
      _previewBytes = adjusted['previewPng'] as Uint8List;
      _selected = _mode == ColorExtractionMode.dominant
          ? _dominantColor
          : _averageColor;
      _hexCtrl.text = _colorToHexStatic(_selected);
    } catch (e, st) {
      debugPrint('[cap-photo] Recalculate failed: $e\n$st');
      if (localToken != _recalcToken) return;
      _warning =
          '⚠️ Aktualisierung fehlgeschlagen. Bitte Farbe manuell prüfen.';
      const fallback = Colors.orange;
      _dominantColor = fallback;
      _averageColor = fallback;
      _selected = fallback;
      _hexCtrl.text = _colorToHexStatic(_selected);
    }
    if (mounted) setState(() {});
  }

  Color? _parseHex(String raw) {
    final hex = raw.trim().replaceFirst('#', '');
    if (hex.length != 6) return null;
    final value = int.tryParse(hex, radix: 16);
    if (value == null) return null;
    return Color(0xFF000000 | value);
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Deckel prüfen')),
      body: SafeArea(
        child: ListView(
          padding: const EdgeInsets.all(12),
          children: [
            _CircleAdjustOverlay(
              imageBytes: widget.imageBytes,
              imageWidth: _imageW,
              imageHeight: _imageH,
              circleX: _circleX,
              circleY: _circleY,
              circleR: _circleR,
              onCircleChanged: (x, y, r) {
                setState(() {
                  _setAndClampCircle(x: x, y: y, r: r);
                });
                _scheduleLiveRecalculate();
              },
            ),
            const SizedBox(height: 8),
            Text(
              _usedFallback
                  ? 'Kreiserkennung per Fallback. Kreis direkt im Foto verschieben/zoomen.'
                  : 'Kreis erkannt. Direkt im Foto ziehen oder mit Pinch/Slider anpassen.',
              style: Theme.of(context).textTheme.bodySmall,
            ),
            if (_warning != null) ...[
              const SizedBox(height: 6),
              Text(
                _warning!,
                style: Theme.of(context).textTheme.bodySmall?.copyWith(
                      color: Theme.of(context).colorScheme.error,
                      fontWeight: FontWeight.w600,
                    ),
              ),
            ],
            const SizedBox(height: 8),
            SegmentedButton<ColorExtractionMode>(
              segments: const [
                ButtonSegment(
                  value: ColorExtractionMode.dominant,
                  label: Text('Dominant (robust)'),
                ),
                ButtonSegment(
                  value: ColorExtractionMode.average,
                  label: Text('Gewichteter Mittelwert'),
                ),
              ],
              selected: {_mode},
              onSelectionChanged: (selection) {
                _mode = selection.first;
                _selected = _mode == ColorExtractionMode.dominant
                    ? _dominantColor
                    : _averageColor;
                _hexCtrl.text = _colorToHexStatic(_selected);
                setState(() {});
              },
            ),
            Slider(
              value: _circleR,
              min: 0.08,
              max: 0.49,
              label: 'Radius',
              onChanged: (v) {
                setState(() => _setAndClampCircle(r: v));
                _scheduleLiveRecalculate();
              },
            ),
            const SizedBox(height: 8),
            Row(
              children: [
                Container(
                  width: 36,
                  height: 36,
                  decoration: BoxDecoration(
                    color: _selected,
                    border: Border.all(color: Colors.black26),
                    borderRadius: BorderRadius.circular(8),
                  ),
                ),
                const SizedBox(width: 10),
                Expanded(
                  child: Text(
                    'Erkannte Farbe: ${_colorToHexStatic(_selected)}',
                    style: const TextStyle(fontWeight: FontWeight.w600),
                  ),
                ),
              ],
            ),
            const SizedBox(height: 10),
            TextField(
              controller: _nameCtrl,
              decoration: const InputDecoration(labelText: 'Name'),
            ),
            const SizedBox(height: 8),
            TextField(
              controller: _hexCtrl,
              decoration: const InputDecoration(labelText: 'Hex (#RRGGBB)'),
              onChanged: (value) {
                final parsed = _parseHex(value);
                if (parsed == null) return;
                setState(() => _selected = parsed);
              },
            ),
          ],
        ),
      ),
      bottomNavigationBar: SafeArea(
        minimum: const EdgeInsets.fromLTRB(12, 8, 12, 12),
        child: Row(
          children: [
            Expanded(
              child: OutlinedButton(
                onPressed: () => Navigator.pop(context),
                child: const Text('Abbrechen'),
              ),
            ),
            const SizedBox(width: 8),
            Expanded(
              child: FilledButton(
                onPressed: () {
                  final name = _nameCtrl.text.trim();
                  if (name.isEmpty) return;
                  final parsed = _parseHex(_hexCtrl.text);
                  Navigator.pop(
                    context,
                    _CapPhotoReviewResult(
                      name: name,
                      color: parsed ?? _selected,
                      mode: _mode,
                      previewBytes: _previewBytes,
                    ),
                  );
                },
                child: const Text('Zum Katalog hinzufügen'),
              ),
            ),
          ],
        ),
      ),
    );
  }
}

String _colorToHexStatic(Color color) {
  return '#${color.toARGB32().toRadixString(16).substring(2).toUpperCase()}';
}

class _CapThumb extends StatelessWidget {
  final CapCatalogEntry entry;
  final bool large;

  const _CapThumb({required this.entry, this.large = false});

  @override
  Widget build(BuildContext context) {
    final size = large ? 84.0 : 42.0;
    final radius = BorderRadius.circular(large ? 12 : 8);

    if (entry.imagePath != null && File(entry.imagePath!).existsSync()) {
      return ClipRRect(
        borderRadius: radius,
        child: Image.file(File(entry.imagePath!),
            width: size, height: size, fit: BoxFit.cover),
      );
    }

    return Container(
      width: size,
      height: size,
      decoration: BoxDecoration(
          color: Theme.of(context).colorScheme.surfaceContainerHighest,
          borderRadius: radius,
          border: Border.all(color: Colors.black12)),
      child: const Icon(Icons.photo_outlined),
    );
  }
}

class _ColorSwatch extends StatelessWidget {
  final Color color;
  final bool large;

  const _ColorSwatch({required this.color, this.large = false});

  @override
  Widget build(BuildContext context) {
    final size = large ? 58.0 : 26.0;
    return Container(
      width: size,
      height: size,
      decoration: BoxDecoration(
        color: color,
        borderRadius: BorderRadius.circular(large ? 12 : 999),
        border: Border.all(color: Colors.black26),
      ),
    );
  }
}

class _SliderRow extends StatelessWidget {
  final String label;
  final String leftLabel;
  final String rightLabel;
  final double value;
  final ValueChanged<double> onChanged;

  const _SliderRow({
    required this.label,
    required this.leftLabel,
    required this.rightLabel,
    required this.value,
    required this.onChanged,
  });

  @override
  Widget build(BuildContext context) {
    return Column(
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
        Text(label, style: const TextStyle(fontWeight: FontWeight.w600)),
        Slider(value: value, onChanged: onChanged),
        Padding(
          padding: const EdgeInsets.only(bottom: 8),
          child: Row(
            children: [
              Text(leftLabel, style: Theme.of(context).textTheme.bodySmall),
              const Spacer(),
              Text(rightLabel, style: Theme.of(context).textTheme.bodySmall),
            ],
          ),
        ),
      ],
    );
  }
}

class _NormalizedCircle {
  final double x;
  final double y;
  final double r;

  const _NormalizedCircle({required this.x, required this.y, required this.r});
}

class _CircleAdjustOverlay extends StatefulWidget {
  final Uint8List imageBytes;
  final double imageWidth;
  final double imageHeight;
  final double circleX;
  final double circleY;
  final double circleR;
  final void Function(double x, double y, double r) onCircleChanged;

  const _CircleAdjustOverlay({
    required this.imageBytes,
    required this.imageWidth,
    required this.imageHeight,
    required this.circleX,
    required this.circleY,
    required this.circleR,
    required this.onCircleChanged,
  });

  @override
  State<_CircleAdjustOverlay> createState() => _CircleAdjustOverlayState();
}

class _CircleAdjustOverlayState extends State<_CircleAdjustOverlay> {
  double? _baseRadius;

  @override
  Widget build(BuildContext context) {
    return LayoutBuilder(builder: (context, constraints) {
      final maxW = math.min(320.0, constraints.maxWidth);
      final shownH = maxW * widget.imageHeight / widget.imageWidth;

      return Center(
        child: ClipRRect(
          borderRadius: BorderRadius.circular(12),
          child: SizedBox(
            width: maxW,
            height: shownH,
            child: GestureDetector(
              behavior: HitTestBehavior.opaque,
              onScaleStart: (_) => _baseRadius = widget.circleR,
              onScaleUpdate: (details) {
                final local = details.localFocalPoint;
                final x = (local.dx / maxW).clamp(0.0, 1.0);
                final y = (local.dy / shownH).clamp(0.0, 1.0);
                final scale = details.scale;
                final r =
                    ((_baseRadius ?? widget.circleR) * scale).clamp(0.06, 0.49);
                widget.onCircleChanged(x, y, r);
              },
              onScaleEnd: (_) => _baseRadius = null,
              child: Stack(
                fit: StackFit.expand,
                children: [
                  Image.memory(widget.imageBytes, fit: BoxFit.cover),
                  CustomPaint(
                    painter: _CircleOverlayPainter(
                      x: widget.circleX,
                      y: widget.circleY,
                      r: widget.circleR,
                    ),
                  ),
                ],
              ),
            ),
          ),
        ),
      );
    });
  }
}

class _CircleOverlayPainter extends CustomPainter {
  final double x;
  final double y;
  final double r;

  const _CircleOverlayPainter(
      {required this.x, required this.y, required this.r});

  @override
  void paint(Canvas canvas, Size size) {
    final center = Offset(x * size.width, y * size.height);
    final radius = r * math.min(size.width, size.height);

    final overlayPaint = Paint()..color = Colors.black.withValues(alpha: 0.35);
    final overlayPath = Path()..addRect(Offset.zero & size);
    overlayPath.addOval(Rect.fromCircle(center: center, radius: radius));
    overlayPath.fillType = PathFillType.evenOdd;
    canvas.drawPath(overlayPath, overlayPaint);

    final ringPaint = Paint()
      ..style = PaintingStyle.stroke
      ..strokeWidth = 2.5
      ..color = Colors.white;
    canvas.drawCircle(center, radius, ringPaint);

    final ringPaint2 = Paint()
      ..style = PaintingStyle.stroke
      ..strokeWidth = 1.2
      ..color = const Color(0xFF2196F3);
    canvas.drawCircle(center, radius - 3, ringPaint2);

    final cross = Paint()
      ..style = PaintingStyle.stroke
      ..strokeWidth = 1
      ..color = Colors.white70;
    canvas.drawLine(Offset(center.dx - 10, center.dy),
        Offset(center.dx + 10, center.dy), cross);
    canvas.drawLine(Offset(center.dx, center.dy - 10),
        Offset(center.dx, center.dy + 10), cross);
  }

  @override
  bool shouldRepaint(covariant _CircleOverlayPainter oldDelegate) {
    return oldDelegate.x != x || oldDelegate.y != y || oldDelegate.r != r;
  }
}

class CapCatalogEntry {
  final String id;
  String name;
  int colorValue;
  String? imagePath;

  CapCatalogEntry(
      {required this.id,
      required this.name,
      required this.colorValue,
      this.imagePath});

  factory CapCatalogEntry.newEntry(
      {required String name, required Color color, String? imagePath}) {
    return CapCatalogEntry(
      id: DateTime.now().microsecondsSinceEpoch.toString(),
      name: name,
      colorValue: color.toARGB32(),
      imagePath: imagePath,
    );
  }

  Color get color => Color(colorValue);

  Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'colorValue': colorValue,
        'imagePath': imagePath,
      };

  factory CapCatalogEntry.fromJson(Map<String, dynamic> json) =>
      CapCatalogEntry(
        id: json['id'] as String,
        name: json['name'] as String,
        colorValue: json['colorValue'] as int,
        imagePath: json['imagePath'] as String?,
      );
}

class CapColor {
  final String name;
  final Color color;

  const CapColor({required this.name, required this.color});
}

class MosaicResult {
  final int width;
  final int height;
  final List<int> assignments;
  final List<CapColor> palette;
  final Map<CapColor, int> counts;
  final List<MapEntry<CapColor, int>> sortedCounts;
  final Uint8List previewPng;

  MosaicResult({
    required this.width,
    required this.height,
    required this.assignments,
    required this.palette,
    required this.counts,
    required this.sortedCounts,
    required this.previewPng,
  });
}

Map<String, dynamic> _generateMosaicIsolate(Map<String, dynamic> request) {
  final source = request['source'] as Uint8List;
  final useCapSize = request['useCapSize'] as bool;
  final defaultGridW = request['gridW'] as int;
  final defaultGridH = request['gridH'] as int;
  final capSize = request['capSize'] as int;
  final fidelityStructure = (request['fidelityStructure'] as num).toDouble();
  final ditheringStrength = (request['ditheringStrength'] as num).toDouble();
  final edgeEmphasis = (request['edgeEmphasis'] as num).toDouble();
  final colorVariation = (request['colorVariation'] as num).toDouble();
  final paletteRaw = (request['palette'] as List).cast<Map>();

  final decoded = img.decodeImage(source);
  if (decoded == null) {
    return <String, dynamic>{
      'width': 1,
      'height': 1,
      'assignments': <int>[0],
      'counts': <int>[1],
      'palette': paletteRaw,
      'previewPng':
          Uint8List.fromList(img.encodePng(img.Image(width: 1, height: 1))),
    };
  }

  final gridW = useCapSize
      ? math.max(1, (decoded.width / capSize).round())
      : defaultGridW;
  final gridH = useCapSize
      ? math.max(1, (decoded.height / capSize).round())
      : defaultGridH;

  final interpolation = fidelityStructure < 0.4
      ? img.Interpolation.average
      : img.Interpolation.linear;
  final scaled = img.copyResize(decoded,
      width: gridW, height: gridH, interpolation: interpolation);

  final pixelCount = gridW * gridH;
  final workingR = List<double>.filled(pixelCount, 0);
  final workingG = List<double>.filled(pixelCount, 0);
  final workingB = List<double>.filled(pixelCount, 0);
  final luminance = List<double>.filled(pixelCount, 0);

  for (int y = 0; y < gridH; y++) {
    for (int x = 0; x < gridW; x++) {
      final idx = y * gridW + x;
      final pix = scaled.getPixel(x, y);
      final r = pix.r.toDouble();
      final g = pix.g.toDouble();
      final b = pix.b.toDouble();
      workingR[idx] = r;
      workingG[idx] = g;
      workingB[idx] = b;
      luminance[idx] = 0.2126 * r + 0.7152 * g + 0.0722 * b;
    }
  }

  final edgeStrength = List<double>.filled(pixelCount, 0);
  for (int y = 0; y < gridH; y++) {
    final ym = y > 0 ? y - 1 : y;
    final yp = y + 1 < gridH ? y + 1 : y;
    for (int x = 0; x < gridW; x++) {
      final xm = x > 0 ? x - 1 : x;
      final xp = x + 1 < gridW ? x + 1 : x;
      final left = luminance[y * gridW + xm];
      final right = luminance[y * gridW + xp];
      final up = luminance[ym * gridW + x];
      final down = luminance[yp * gridW + x];
      final gx = right - left;
      final gy = down - up;
      edgeStrength[y * gridW + x] =
          (math.sqrt(gx * gx + gy * gy) / 255.0).clamp(0.0, 1.0);
    }
  }

  if (fidelityStructure > 0.001) {
    final blurredR = List<double>.filled(pixelCount, 0);
    final blurredG = List<double>.filled(pixelCount, 0);
    final blurredB = List<double>.filled(pixelCount, 0);
    for (int y = 0; y < gridH; y++) {
      for (int x = 0; x < gridW; x++) {
        double sr = 0, sg = 0, sb = 0;
        int c = 0;
        for (int ny = math.max(0, y - 1);
            ny <= math.min(gridH - 1, y + 1);
            ny++) {
          for (int nx = math.max(0, x - 1);
              nx <= math.min(gridW - 1, x + 1);
              nx++) {
            final ni = ny * gridW + nx;
            sr += workingR[ni];
            sg += workingG[ni];
            sb += workingB[ni];
            c++;
          }
        }
        final idx = y * gridW + x;
        blurredR[idx] = sr / c;
        blurredG[idx] = sg / c;
        blurredB[idx] = sb / c;
      }
    }

    for (int i = 0; i < pixelCount; i++) {
      final smoothBlend = fidelityStructure * (1.0 - edgeStrength[i] * 0.75);
      workingR[i] = _mix(workingR[i], blurredR[i], smoothBlend);
      workingG[i] = _mix(workingG[i], blurredG[i], smoothBlend);
      workingB[i] = _mix(workingB[i], blurredB[i], smoothBlend);
    }
  }

  final paletteValues = paletteRaw.map((e) => e['value'] as int).toList();
  final paletteLab = paletteValues.map(_argbToLab).toList(growable: false);

  final assignments = List<int>.filled(pixelCount, 0);
  final counts = List<int>.filled(paletteValues.length, 0);

  final errorR = List<double>.filled(pixelCount, 0);
  final errorG = List<double>.filled(pixelCount, 0);
  final errorB = List<double>.filled(pixelCount, 0);
  final labCache = <int, List<double>>{};

  for (int y = 0; y < gridH; y++) {
    for (int x = 0; x < gridW; x++) {
      final idx = y * gridW + x;

      final srcR = (workingR[idx] + errorR[idx]).clamp(0.0, 255.0);
      final srcG = (workingG[idx] + errorG[idx]).clamp(0.0, 255.0);
      final srcB = (workingB[idx] + errorB[idx]).clamp(0.0, 255.0);

      final rgb = ((srcR.round() & 0xFF) << 16) |
          ((srcG.round() & 0xFF) << 8) |
          (srcB.round() & 0xFF);
      final srcLab = labCache.putIfAbsent(rgb, () => _rgbToLab(rgb));

      int bestIdx = 0;
      double bestDistance = double.infinity;
      final candidates = <_Candidate>[];
      final localVar =
          colorVariation * (1.0 - edgeStrength[idx]).clamp(0.0, 1.0);
      final tolerance = 2.0 + localVar * 22.0;

      for (int i = 0; i < paletteLab.length; i++) {
        final lDiff = (srcLab[0] - paletteLab[i][0]).abs();
        final d = _deltaE76(srcLab, paletteLab[i]) +
            (edgeEmphasis * edgeStrength[idx] * lDiff * 0.35);
        if (d < bestDistance) {
          bestDistance = d;
          bestIdx = i;
        }
      }

      for (int i = 0; i < paletteLab.length; i++) {
        final lDiff = (srcLab[0] - paletteLab[i][0]).abs();
        final d = _deltaE76(srcLab, paletteLab[i]) +
            (edgeEmphasis * edgeStrength[idx] * lDiff * 0.35);
        if (d <= bestDistance + tolerance) {
          candidates.add(_Candidate(index: i, distance: d));
        }
      }

      int chosen = bestIdx;
      if (localVar > 0.001 && candidates.length > 1) {
        candidates.sort((a, b) => a.distance.compareTo(b.distance));
        final usable = math.min(candidates.length, 4);
        final h = ((x + 1) * 73856093) ^ ((y + 1) * 19349663);
        final pick = h.abs() % usable;
        chosen = candidates[pick].index;
      }

      assignments[idx] = chosen;
      counts[chosen]++;

      if (ditheringStrength > 0.001) {
        final argb = paletteValues[chosen];
        final qr = ((argb >> 16) & 0xFF).toDouble();
        final qg = ((argb >> 8) & 0xFF).toDouble();
        final qb = (argb & 0xFF).toDouble();

        final er = (srcR - qr) * ditheringStrength;
        final eg = (srcG - qg) * ditheringStrength;
        final eb = (srcB - qb) * ditheringStrength;

        if (x + 1 < gridW) {
          final n = idx + 1;
          errorR[n] += er * (7 / 16);
          errorG[n] += eg * (7 / 16);
          errorB[n] += eb * (7 / 16);
        }
        if (y + 1 < gridH) {
          if (x > 0) {
            final n = idx + gridW - 1;
            errorR[n] += er * (3 / 16);
            errorG[n] += eg * (3 / 16);
            errorB[n] += eb * (3 / 16);
          }
          final nDown = idx + gridW;
          errorR[nDown] += er * (5 / 16);
          errorG[nDown] += eg * (5 / 16);
          errorB[nDown] += eb * (5 / 16);

          if (x + 1 < gridW) {
            final n = idx + gridW + 1;
            errorR[n] += er * (1 / 16);
            errorG[n] += eg * (1 / 16);
            errorB[n] += eb * (1 / 16);
          }
        }
      }
    }
  }

  final preview = img.Image(width: gridW, height: gridH);
  for (int y = 0; y < gridH; y++) {
    for (int x = 0; x < gridW; x++) {
      final idx = assignments[y * gridW + x];
      final argb = paletteValues[idx];
      preview.setPixelRgba(
          x, y, (argb >> 16) & 0xFF, (argb >> 8) & 0xFF, argb & 0xFF, 255);
    }
  }

  return <String, dynamic>{
    'width': gridW,
    'height': gridH,
    'assignments': assignments,
    'counts': counts,
    'palette': paletteRaw,
    'previewPng': Uint8List.fromList(img.encodePng(preview, level: 1)),
  };
}

Map<String, dynamic> _extractCapFromPhotoIsolate(Uint8List sourceBytes) {
  final decoded = img.decodeImage(sourceBytes);
  if (decoded == null) {
    return {
      'dominantColor': Colors.orange.toARGB32(),
      'averageColor': Colors.orange.toARGB32(),
      'usedFallback': true,
      'circleX': 0.5,
      'circleY': 0.5,
      'circleR': 0.3,
      'imageW': 1,
      'imageH': 1,
      'previewPng': Uint8List.fromList(
          img.encodePng(img.Image(width: 1, height: 1), level: 1)),
    };
  }

  const int analysisMaxSize = 480;
  final double scale = decoded.width >= decoded.height
      ? (decoded.width > analysisMaxSize
          ? analysisMaxSize / decoded.width
          : 1.0)
      : (decoded.height > analysisMaxSize
          ? analysisMaxSize / decoded.height
          : 1.0);

  final analysis = scale < 1.0
      ? img.copyResize(decoded,
          width: (decoded.width * scale).round(),
          height: (decoded.height * scale).round(),
          interpolation: img.Interpolation.average)
      : decoded;

  final detectedMaybe = _detectCapCircle(analysis);
  final detected =
      detectedMaybe ?? _fallbackCapCircle(analysis.width, analysis.height);
  final usedFallback = detectedMaybe == null;

  final upscaledCircle = _DetectedCircle(
    cx: detected.cx / scale,
    cy: detected.cy / scale,
    r: detected.r / scale,
  );

  final stats = _sampleCapColors(decoded, upscaledCircle);
  final preview = _buildCirclePreview(analysis, detected);

  return {
    'dominantColor': stats.dominantArgb,
    'averageColor': stats.averageArgb,
    'usedFallback': usedFallback,
    'circleX': upscaledCircle.cx,
    'circleY': upscaledCircle.cy,
    'circleR': upscaledCircle.r,
    'imageW': decoded.width,
    'imageH': decoded.height,
    'previewPng': Uint8List.fromList(img.encodePng(preview, level: 1)),
  };
}

Map<String, dynamic> _extractCapFromAdjustedCircleIsolate(
    Map<String, dynamic> request) {
  final sourceBytes = request['sourceBytes'] as Uint8List;
  final decoded = img.decodeImage(sourceBytes);
  if (decoded == null) {
    return {
      'dominantColor': Colors.orange.toARGB32(),
      'averageColor': Colors.orange.toARGB32(),
      'previewPng': Uint8List.fromList(
          img.encodePng(img.Image(width: 1, height: 1), level: 1)),
    };
  }

  final minSide = math.min(decoded.width, decoded.height).toDouble();
  final normalized = _clampCircleNormalized(
    imageW: decoded.width.toDouble(),
    imageH: decoded.height.toDouble(),
    circleX: (request['circleX'] as num).toDouble(),
    circleY: (request['circleY'] as num).toDouble(),
    circleR: (request['circleR'] as num).toDouble(),
  );

  final circle = _DetectedCircle(
    cx: normalized.x * decoded.width,
    cy: normalized.y * decoded.height,
    r: normalized.r * minSide,
  );
  final stats = _sampleCapColors(decoded, circle);

  const int analysisMaxSize = 480;
  final scale = decoded.width >= decoded.height
      ? (decoded.width > analysisMaxSize
          ? analysisMaxSize / decoded.width
          : 1.0)
      : (decoded.height > analysisMaxSize
          ? analysisMaxSize / decoded.height
          : 1.0);
  final analysis = scale < 1.0
      ? img.copyResize(decoded,
          width: (decoded.width * scale).round(),
          height: (decoded.height * scale).round(),
          interpolation: img.Interpolation.average)
      : decoded;

  final preview = _buildCirclePreview(
    analysis,
    _DetectedCircle(
        cx: circle.cx * scale, cy: circle.cy * scale, r: circle.r * scale),
  );

  return {
    'dominantColor': stats.dominantArgb,
    'averageColor': stats.averageArgb,
    'previewPng': Uint8List.fromList(img.encodePng(preview, level: 1)),
  };
}

_NormalizedCircle _clampCircleNormalized({
  required double imageW,
  required double imageH,
  required double circleX,
  required double circleY,
  required double circleR,
}) {
  final minSide = math.min(imageW, imageH);
  final r = circleR.clamp(8 / minSide, 0.49);
  final minX = r * (minSide / imageW);
  final minY = r * (minSide / imageH);
  return _NormalizedCircle(
    x: circleX.clamp(minX, 1 - minX),
    y: circleY.clamp(minY, 1 - minY),
    r: r,
  );
}

img.Image _buildCirclePreview(img.Image analysis, _DetectedCircle detected) {
  final preview = img.copyResize(analysis,
      width: math.min(analysis.width, 320),
      height: (math.min(analysis.width, 320) * analysis.height / analysis.width)
          .round());
  final previewScale = preview.width / analysis.width;
  _drawCircle(preview, detected.cx * previewScale, detected.cy * previewScale,
      detected.r * previewScale);
  return preview;
}

_DetectedCircle? _detectCapCircle(img.Image image) {
  final width = image.width;
  final height = image.height;
  if (width < 40 || height < 40) return null;

  final gray = List<double>.filled(width * height, 0);
  for (int y = 0; y < height; y++) {
    for (int x = 0; x < width; x++) {
      final p = image.getPixel(x, y);
      gray[y * width + x] = 0.2126 * p.r + 0.7152 * p.g + 0.0722 * p.b;
    }
  }

  final edge = List<double>.filled(width * height, 0);
  double edgeMax = 1;
  for (int y = 1; y < height - 1; y++) {
    for (int x = 1; x < width - 1; x++) {
      final gx = gray[y * width + (x + 1)] - gray[y * width + (x - 1)];
      final gy = gray[(y + 1) * width + x] - gray[(y - 1) * width + x];
      final m = math.sqrt(gx * gx + gy * gy);
      edge[y * width + x] = m;
      if (m > edgeMax) edgeMax = m;
    }
  }

  final minRadius = (math.min(width, height) * 0.14).round();
  final maxRadius = (math.min(width, height) * 0.48).round();
  if (maxRadius <= minRadius) return null;

  _DetectedCircle? best;
  double bestScore = 0;

  for (int r = minRadius; r <= maxRadius; r += 4) {
    final centerStep = math.max(4, r ~/ 7);
    final samples = math.max(24, (2 * math.pi * r / 5).round());

    for (int cy = r; cy < height - r; cy += centerStep) {
      for (int cx = r; cx < width - r; cx += centerStep) {
        double ringScore = 0;
        int valid = 0;
        for (int i = 0; i < samples; i++) {
          final t = (2 * math.pi * i) / samples;
          final x = (cx + r * math.cos(t)).round();
          final y = (cy + r * math.sin(t)).round();
          if (x < 1 || x >= width - 1 || y < 1 || y >= height - 1) continue;
          ringScore += edge[y * width + x] / edgeMax;
          valid++;
        }
        if (valid < samples * 0.7) continue;

        final normalizedRing = ringScore / valid;
        if (normalizedRing < 0.22) continue;

        final centerIdx = cy * width + cx;
        final centerPenalty = 0.85 + (gray[centerIdx] / 255.0) * 0.15;
        final score = normalizedRing * centerPenalty;

        if (score > bestScore) {
          bestScore = score;
          best = _DetectedCircle(
              cx: cx.toDouble(), cy: cy.toDouble(), r: r.toDouble());
        }
      }
    }
  }

  return bestScore >= 0.25 ? best : null;
}

_DetectedCircle _fallbackCapCircle(int width, int height) {
  return _DetectedCircle(
    cx: width / 2,
    cy: height / 2,
    r: math.min(width, height) * 0.28,
  );
}

_CapColorStats _sampleCapColors(img.Image image, _DetectedCircle circle) {
  final samples = <_ColorSample>[];

  final insetRadius = circle.r * 0.76;
  final r2 = insetRadius * insetRadius;
  final minX = math.max(0, (circle.cx - insetRadius).floor());
  final maxX = math.min(image.width - 1, (circle.cx + insetRadius).ceil());
  final minY = math.max(0, (circle.cy - insetRadius).floor());
  final maxY = math.min(image.height - 1, (circle.cy + insetRadius).ceil());

  for (int y = minY; y <= maxY; y++) {
    final dy = y - circle.cy;
    for (int x = minX; x <= maxX; x++) {
      final dx = x - circle.cx;
      final dist2 = (dx * dx) + (dy * dy);
      if (dist2 > r2) continue;

      final p = image.getPixel(x, y);
      final r = p.r.toInt();
      final g = p.g.toInt();
      final b = p.b.toInt();
      final hsv = _rgbToHsv(r, g, b);
      final lum = 0.2126 * r + 0.7152 * g + 0.0722 * b;
      final radial = 1.0 - math.sqrt(dist2) / insetRadius;

      samples.add(_ColorSample(
        r: r,
        g: g,
        b: b,
        saturation: hsv[1],
        value: hsv[2],
        luminance: lum,
        radialWeight: radial.clamp(0.1, 1.0),
      ));
    }
  }

  if (samples.isEmpty) {
    final fallback = const Color(0xFFFF9800).toARGB32();
    return _CapColorStats(averageArgb: fallback, dominantArgb: fallback);
  }

  final lumValues = samples.map((s) => s.luminance).toList()..sort();
  final lowLum = _percentile(lumValues, 0.18);
  final highLum = _percentile(lumValues, 0.98);

  final filtered = samples.where((s) {
    if (s.luminance < lowLum || s.luminance > highLum) return false;
    if (s.value < 0.18) return false;
    return true;
  }).toList();

  final usable = filtered.isEmpty ? samples : filtered;

  final avg = _weightedAverage(usable);
  final dominant = _weightedDominant(usable);

  return _CapColorStats(averageArgb: avg, dominantArgb: dominant);
}

void _drawCircle(img.Image image, double cx, double cy, double r) {
  final x = cx.round();
  final y = cy.round();
  final radius = r.round();
  for (int i = 0; i < 3; i++) {
    img.drawCircle(
      image,
      x: x,
      y: y,
      radius: math.max(2, radius - i),
      color: img.ColorRgb8(255, 255, 255),
    );
  }
  img.drawCircle(
    image,
    x: x,
    y: y,
    radius: math.max(2, radius - 3),
    color: img.ColorRgb8(0, 140, 255),
  );
}

class _DetectedCircle {
  final double cx;
  final double cy;
  final double r;

  const _DetectedCircle({required this.cx, required this.cy, required this.r});
}

class _CapColorStats {
  final int averageArgb;
  final int dominantArgb;

  const _CapColorStats({required this.averageArgb, required this.dominantArgb});
}

class _ColorSample {
  final int r;
  final int g;
  final int b;
  final double saturation;
  final double value;
  final double luminance;
  final double radialWeight;

  const _ColorSample({
    required this.r,
    required this.g,
    required this.b,
    required this.saturation,
    required this.value,
    required this.luminance,
    required this.radialWeight,
  });

  double get weight => radialWeight * (0.55 + saturation * 0.75);
}

class _WeightedRgb {
  double weight = 0;
  double r = 0;
  double g = 0;
  double b = 0;

  void add(_ColorSample s, double w) {
    weight += w;
    r += s.r * w;
    g += s.g * w;
    b += s.b * w;
  }
}

class _Candidate {
  final int index;
  final double distance;

  const _Candidate({required this.index, required this.distance});
}

int _weightedAverage(List<_ColorSample> samples) {
  final acc = _WeightedRgb();
  for (final s in samples) {
    final w = s.weight;
    acc.add(s, w);
  }
  if (acc.weight <= 0) return const Color(0xFFFF9800).toARGB32();
  return Color.fromARGB(
    255,
    (acc.r / acc.weight).round().clamp(0, 255),
    (acc.g / acc.weight).round().clamp(0, 255),
    (acc.b / acc.weight).round().clamp(0, 255),
  ).toARGB32();
}

int _weightedDominant(List<_ColorSample> samples) {
  final bins = <int, _WeightedRgb>{};
  for (final s in samples) {
    final hsv = _rgbToHsv(s.r, s.g, s.b);
    final hBin = (hsv[0] / 20).floor().clamp(0, 17);
    final sBin = (hsv[1] * 4).floor().clamp(0, 3);
    final vBin = (hsv[2] * 4).floor().clamp(0, 3);
    final key = (hBin << 6) | (sBin << 3) | vBin;
    final bucket = bins.putIfAbsent(key, () => _WeightedRgb());
    bucket.add(s, s.weight);
  }

  _WeightedRgb? best;
  for (final b in bins.values) {
    if (best == null || b.weight > best.weight) best = b;
  }
  if (best == null || best.weight <= 0) return _weightedAverage(samples);

  return Color.fromARGB(
    255,
    (best.r / best.weight).round().clamp(0, 255),
    (best.g / best.weight).round().clamp(0, 255),
    (best.b / best.weight).round().clamp(0, 255),
  ).toARGB32();
}

List<double> _rgbToHsv(int r, int g, int b) {
  final rf = r / 255.0;
  final gf = g / 255.0;
  final bf = b / 255.0;
  final maxC = math.max(rf, math.max(gf, bf));
  final minC = math.min(rf, math.min(gf, bf));
  final delta = maxC - minC;

  double h;
  if (delta == 0) {
    h = 0;
  } else if (maxC == rf) {
    h = 60 * (((gf - bf) / delta) % 6);
  } else if (maxC == gf) {
    h = 60 * (((bf - rf) / delta) + 2);
  } else {
    h = 60 * (((rf - gf) / delta) + 4);
  }
  if (h < 0) h += 360;

  final s = maxC == 0 ? 0.0 : delta / maxC;
  final v = maxC;
  return [h, s, v];
}

double _percentile(List<double> sorted, double p) {
  if (sorted.isEmpty) return 0;
  final pos = (sorted.length - 1) * p.clamp(0.0, 1.0);
  final lo = pos.floor();
  final hi = pos.ceil();
  if (lo == hi) return sorted[lo];
  final t = pos - lo;
  return sorted[lo] * (1 - t) + sorted[hi] * t;
}

double _mix(double a, double b, double t) => a + (b - a) * t;

List<double> _argbToLab(int argb) {
  final rgb = argb & 0x00FFFFFF;
  return _rgbToLab(rgb);
}

List<double> _rgbToLab(int rgb) {
  double r = ((rgb >> 16) & 0xFF) / 255.0;
  double g = ((rgb >> 8) & 0xFF) / 255.0;
  double b = (rgb & 0xFF) / 255.0;

  r = r <= 0.04045 ? r / 12.92 : math.pow((r + 0.055) / 1.055, 2.4).toDouble();
  g = g <= 0.04045 ? g / 12.92 : math.pow((g + 0.055) / 1.055, 2.4).toDouble();
  b = b <= 0.04045 ? b / 12.92 : math.pow((b + 0.055) / 1.055, 2.4).toDouble();

  final x = (r * 0.4124 + g * 0.3576 + b * 0.1805) / 0.95047;
  final y = (r * 0.2126 + g * 0.7152 + b * 0.0722) / 1.00000;
  final z = (r * 0.0193 + g * 0.1192 + b * 0.9505) / 1.08883;

  double f(double t) => t > 0.008856
      ? math.pow(t, 1.0 / 3.0).toDouble()
      : (7.787 * t) + (16 / 116);

  final fx = f(x);
  final fy = f(y);
  final fz = f(z);

  final l = (116 * fy) - 16;
  final a = 500 * (fx - fy);
  final bStar = 200 * (fy - fz);

  return [l, a, bStar];
}

double _deltaE76(List<double> lab1, List<double> lab2) {
  final dl = lab1[0] - lab2[0];
  final da = lab1[1] - lab2[1];
  final db = lab1[2] - lab2[2];
  return math.sqrt(dl * dl + da * da + db * db);
}