// Parse large JSON in the background
Future<List<Product>> parseProducts(String jsonString) async {
  return compute(_parseProductsIsolate, jsonString);
}

// Must be top-level or static
List<Product> _parseProductsIsolate(String jsonString) {
  final List<dynamic> data = jsonDecode(jsonString);
  return data.map((json) => Product.fromJson(json)).toList();
}

// Usage
Future<List<Product>> _loadProducts() async {
  final response = await http.get(Uri.parse('https://api.example.com/products'));
  return compute(_parseProductsIsolate, response.body);
}

// Apply image filter in background
Future<Uint8List> applyFilter(Uint8List imageBytes) async {
  return Isolate.run(() => _applyGrayscaleFilter(imageBytes));
}

Uint8List _applyGrayscaleFilter(Uint8List bytes) {
  final img = decodeImage(bytes)!;
  for (int y = 0; y < img.height; y++) {
    for (int x = 0; x < img.width; x++) {
      final pixel = img.getPixel(x, y);
      final gray = (pixel.r * 0.299 + pixel.g * 0.587 + pixel.b * 0.114).toInt();
      img.setPixel(x, y, ColorRgb8(gray, gray, gray));
    }
  }
  return Uint8List.fromList(encodeJpg(img));
}

class DataProcessor {
  late Isolate _isolate;
  late SendPort _sendPort;
  final _receivePort = ReceivePort();

  Future<void> start() async {
    _isolate = await Isolate.spawn(_processorIsolate, _receivePort.sendPort);
    _sendPort = await _receivePort.first as SendPort;
  }

  Future<ProcessedData> process(RawData data) async {
    final responsePort = ReceivePort();
    _sendPort.send([data, responsePort.sendPort]);
    return await responsePort.first as ProcessedData;
  }

  void dispose() {
    _isolate.kill(priority: Isolate.immediate);
    _receivePort.close();
  }
}

void _processorIsolate(SendPort mainSendPort) {
  final receivePort = ReceivePort();
  mainSendPort.send(receivePort.sendPort);

  receivePort.listen((message) {
    final data = message[0] as RawData;
    final replyPort = message[1] as SendPort;
    replyPort.send(_heavyProcessing(data));
  });
}

@riverpod
Future<AnalysisResult> analyzeData(Ref ref, String rawData) async {
  return Isolate.run(() => _performAnalysis(rawData));
}

class AnalysisPage extends ConsumerWidget {
  final String data;
  const AnalysisPage(this.data);

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final result = ref.watch(analyzeDataProvider(data));

    return switch (result) {
      AsyncData(:final value) => ResultDisplay(value),
      AsyncError(:final error) => ErrorWidget(message: error.toString()),
      AsyncLoading() => const CircularProgressIndicator(),
    };
  }
}

Future<void> benchmarkCompute() async {
  const iterations = 1000;
  final testData = List.generate(iterations, (i) => {'id': i, 'value': 'test$i'});
  final jsonString = jsonEncode(testData);

  // Synchronous — blocks main thread
  final syncStart = DateTime.now();
  jsonDecode(jsonString);
  final syncDuration = DateTime.now().difference(syncStart);

  // compute — runs in background
  final asyncStart = DateTime.now();
  await compute(jsonDecode, jsonString);
  final asyncDuration = DateTime.now().difference(asyncStart);

  print('Sync: ${syncDuration.inMilliseconds}ms');
  print('Async: ${asyncDuration.inMilliseconds}ms');
}