spotube/lib/services/youtube_engine/quickjs_solver.dart

// import 'dart:async';
// import 'dart:collection';
// import 'dart:convert';
// import 'package:flutter/foundation.dart';
// import 'package:http/http.dart' as http;
// import 'package:youtube_explode_dart/js_challenge.dart';
// // ignore: implementation_imports
// import 'package:youtube_explode_dart/src/reverse_engineering/challenges/ejs/ejs.dart';
// import 'package:jsf/jsf.dart';

// /// [WIP]
// class QuickJSEJSSolver extends BaseJSChallengeSolver {
//   final _playerCache = <String, String>{};
//   final _sigCache = <(String, String, JSChallengeType), String>{};
//   final QuickJSRuntime qjs;
//   QuickJSEJSSolver._(this.qjs);

//   static Future<QuickJSEJSSolver> init() async {
//     final modules = await EJSBuilder.getJSModules();
//     final deno = await QuickJSRuntime.init(modules);
//     return QuickJSEJSSolver._(deno);
//   }

//   @override
//   Future<String> solve(
//       String playerUrl, JSChallengeType type, String challenge) async {
//     final key = (playerUrl, challenge, type);
//     if (_sigCache.containsKey(key)) {
//       return _sigCache[key]!;
//     }

//     var playerScript = _playerCache[playerUrl];
//     if (playerScript == null) {
//       final resp = await http.get(Uri.parse(playerUrl));
//       playerScript = _playerCache[playerUrl] = resp.body;
//     }
//     final jsCall = EJSBuilder.buildJSCall(playerScript, {
//       type: [challenge],
//     });

//     final result = await qjs.eval(jsCall);
//     // Trim the first and last characters (' delimiters of the JS string)
//     final data = json.decode(result.substring(1, result.length - 1))
//         as Map<String, dynamic>;

//     if (data['type'] != 'result') {
//       throw Exception('Unexpected response type: ${data['type']}');
//     }
//     final response = data['responses'][0];
//     if (response['type'] != 'result') {
//       throw Exception('Unexpected item response type: ${response['type']}');
//     }
//     final decoded = response['data'][challenge];
//     if (decoded == null) {
//       throw Exception('No data for challenge: $challenge');
//     }

//     _sigCache[key] = decoded;

//     return decoded;
//   }

//   @override
//   void dispose() {
//     qjs.dispose();
//   }
// }

// class _EvalRequest {
//   final String code;
//   final Completer<String> completer;

//   _EvalRequest(this.code, this.completer);
// }

// class QuickJSRuntime {
//   final JsRuntime _runtime;
//   final StreamController<String> _stdoutController =
//       StreamController.broadcast();

//   // Queue for incoming eval requests
//   final Queue<_EvalRequest> _evalQueue = Queue<_EvalRequest>();
//   bool _isProcessing = false; // Flag to indicate if an eval is currently active

//   QuickJSRuntime(this._runtime);

//   /// Disposes the Deno process.
//   void dispose() {
//     _stdoutController.close();
//     _runtime.dispose();
//   }

//   /// Sends JavaScript code to Deno for evaluation.
//   /// Assumes single-line input produces single-line output.
//   Future<String> eval(String code) {
//     final completer = Completer<String>();
//     final request = _EvalRequest(code, completer);
//     _evalQueue.addLast(request); // Add request to the end of the queue
//     _processQueue(); // Attempt to process the queue

//     return completer.future;
//   }

//   // Processes the eval queue.
//   void _processQueue() {
//     if (_isProcessing || _evalQueue.isEmpty) {
//       return; // Already processing or nothing in queue
//     }

//     _isProcessing = true;
//     final request =
//         _evalQueue.first; // Get the next request without removing it yet

//     StreamSubscription? currentOutputSubscription;
//     Completer<void> lineReceived = Completer<void>();

//     currentOutputSubscription = _stdoutController.stream.listen((data) {
//       if (!lineReceived.isCompleted) {
//         // Assuming single line output per eval.
//         // This will capture the first full line or chunk received after sending the code.
//         request.completer.complete(data.trim());
//         lineReceived.complete();
//         currentOutputSubscription
//             ?.cancel(); // Cancel subscription for this request
//         _evalQueue.removeFirst(); // Remove the processed request
//         _isProcessing = false; // Mark as no longer processing
//         _processQueue(); // Attempt to process next item in queue
//       }
//     }, onError: (e) {
//       if (!request.completer.isCompleted) {
//         request.completer.completeError(e);
//         lineReceived.completeError(e);
//         currentOutputSubscription?.cancel();
//         _evalQueue.removeFirst();
//         _isProcessing = false;
//         _processQueue();
//       }
//     }, onDone: () {
//       if (!request.completer.isCompleted) {
//         request.completer.completeError(
//             StateError('Deno process closed while awaiting eval result.'));
//         lineReceived.completeError(
//             StateError('Deno process closed while awaiting eval result.'));
//         currentOutputSubscription?.cancel();
//         _evalQueue.removeFirst();
//         _isProcessing = false;
//         _processQueue();
//       }
//     });

//     debugPrint("[QuickJS Solver] Evaluate ${request.code}");
//     final result = _runtime.eval(request.code);
//     debugPrint("[QuickJS Solver] Evaluation Result $result");
//     _stdoutController.add(result);
//   }

//   static Future<QuickJSRuntime> init(String initCode) async {
//     debugPrint("[QuickJS Solver] Initializing");
//     debugPrint("[QuickJS Solver] script $initCode");

//     final runtime = JsRuntime();

//     runtime.execInitScript(initCode);

//     return QuickJSRuntime(runtime);
//   }
// }