graveyard.dartx

final eventAsyncValue = ref.watch(bonsoir_service.eventsProvider);


child: eventAsyncValue.when(
  data: (events) => ListView.builder(
    itemCount: events.length,
    itemBuilder: (context, index) {
      final event = events[index];
      final name = event.service?.toJson()['service.name'];
      final address = event.service?.toJson()['service.host'];
      return ListTile(
        title: Text('Name: $name'),
        subtitle: Text('Address: $address'),
      );
    },
  ),
  loading: () => const CircularProgressIndicator(),
  error: (err, stack) => Text('Error: $err'),
),



var server = Server();

/// Stream provider for the socket events
@riverpod
Stream<SocketEvent> socketEvents(Ref ref) async* {
  final duktiServicePort = await ref.watch(duktiServicePortProvider.future);

  /// Controller for the socket events
  final socketEventController = StateProvider<StreamController<SocketEvent>>((ref) {
    return StreamController<SocketEvent>.broadcast();
  });

  // Handle events on the '/clipboard' namespace
  server.of('/clipboard').on('connection', (client) {
    logger.i('Connection on /clipboard');

    client.on('clipboard', (data) {
      logger.i('Data from /clipboard => $data');
      client.emit('fromServer', 'ok');

      // Yield the event
      final event = SocketEvent(
        namespace: '/clipboard',
        eventName: 'clipboard',
        data: data,
        type: SocketDataType.clipboard,
      );
      ref.read(socketEventController).add(event);
    });
  });

  server.of('/upload').on('connection', (client) {
    logger.i('Connection on /upload');

    client.on('upload', (data) {
      logger.i('Data from /upload => $data');
      client.emit('fromServer', 'ok');

      // Yield the event
      final event = SocketEvent(
        namespace: '/upload',
        eventName: 'upload',
        data: data,
        type: SocketDataType.upload,
      );
      ref.read(socketEventController).add(event);
    });
  });

  // Handle events on the default namespace
  server.on('connection', (client) {
    logger.i('Connection on default namespace');

    client.on('event', (data) {
      logger.i('Data from default namespace => $data');
      client.emit('fromServer', 'ok');

      // Yield the event
      final event = SocketEvent(
        namespace: '/',
        eventName: 'event',
        data: data,
        type: SocketDataType.none,
      );
      ref.read(socketEventController).add(event);
    });
  });

  // Start the server
  server.listen(duktiServicePort);

  // Stream controller to emit socket events
  final controller = StreamController<SocketEvent>();

  // Expose the controller to be used in callbacks
  ref.read(socketEventController.notifier).state = controller;

  // Dispose resources when the provider is destroyed
  ref.onDispose(() {
    server.close();
    controller.close();
  });

  yield* controller.stream;
}


class AppLifecycleManager extends StatefulWidget {
  final Widget child;

  const AppLifecycleManager({super.key, required this.child});

  @override
  AppLifecycleManagerState createState() => AppLifecycleManagerState();
}

class AppLifecycleManagerState extends State<AppLifecycleManager> with WidgetsBindingObserver {
  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addObserver(this);
  }

  @override
  void dispose() {
    // Perform cleanup here
    // For example, stop servers, close streams, etc.
    WidgetsBinding.instance.removeObserver(this);
    super.dispose();
  }

  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    if (state == AppLifecycleState.detached) {
      logger.t('AppLifecycleState.detached $state');
      // The app is exiting
      // Perform cleanup if needed
    }
  }

  @override
  Widget build(BuildContext context) {
    return widget.child;
  }
}


 void _uploadFile(WidgetRef ref) async {
    final uploadProgressNotifier = ref.read(uploadProgressProvider.notifier);
    final uploadSpeedNotifier = ref.read(uploadSpeedProvider.notifier);

    final result = await FilePicker.platform.pickFiles();

    if (result != null && result.files.single.path != null) {
      final filePath = result.files.single.path!;
      final fileName = result.files.single.name;

      final uri = Uri.parse('http://${client.ip}:${client.port}/upload');
      final request = http.MultipartRequest('POST', uri)
        ..fields['clientId'] = clientId
        ..files.add(await http.MultipartFile.fromPath('file', filePath, filename: fileName));

      final startTime = DateTime.now();

      try {
        final streamedResponse = await request.send();

        streamedResponse.stream.listen((value) {
          final currentTime = DateTime.now();
          final elapsedTime = currentTime.difference(startTime).inSeconds;
          if (elapsedTime > 0) {
            final speed = value.length / elapsedTime; // bytes per second
            uploadSpeedNotifier.set(speed.toInt());
          }
          final progress = value.length / streamedResponse.contentLength!;
          uploadProgressNotifier.set(progress);
          // ref.read(uploadProgressStreamProvider.notifier).set(progress);

          logger.e('Upload progress http: $progress');
        }).onDone(() async {
          if (streamedResponse.statusCode == 200) {
            Future.delayed(const Duration(seconds: 1), () {
              uploadProgressNotifier.set(0.0);
              uploadSpeedNotifier.set(0);
            });
            logger.i('Upload complete');
          } else {
            logger.i('Upload failed: ${streamedResponse.statusCode}');
          }
        });
      } catch (e) {
        logger.i('Upload failed: $e');
      }
    }
  }

    // final uploadProgressStream = ref.watch(uploadProgressStreamProvider);
    // final uploadProgress = uploadProgressStream.hasValue ? uploadProgressStream.value ?? 0.0 : 0.0;



// part 'upload_widget.g.dart';

// @riverpod
// class UploadProgress extends _$UploadProgress {
//   @override
//   double build() {
//     return 0.0;
//   }

//   void set(double value) {
//     state = value;
//   }
// }

// @riverpod
// class UploadProgressStream extends _$UploadProgressStream {
//   final StreamController<double> _controller = StreamController<double>();

//   @override
//   Stream<double> build() {
//     ref.onDispose(() {
//       _controller.close();
//     });

//     return _controller.stream;
//   }

//   void set(double value) {
//     _controller.add(value);
//   }
// }

// @riverpod
// class UploadSpeed extends _$UploadSpeed {
//   @override
//   int build() {
//     return 0;
//   }

//   void set(int value) {
//     state = value;
//   }
// }

// @riverpod
// class FileSelectorOpen extends _$FileSelectorOpen {
//   @override
//   bool build() {
//     return false;
//   }

//   void set(bool value) {
//     state = value;
//   }
// }



// void uploadFile(
//   String filePath,
//   DuktiClient client,
//   Function(double) updateProgress,
//   Function(int) updateSpeed,
// ) async {
//   // fileSelectorOpen.set(true);
//   // setState(() => fileSelectorOpen2 = true);

//   // final result = await FilePicker.platform.pickFiles();

//   // // fileSelectorOpen.set(false);
//   // setState(() => fileSelectorOpen2 = false);

//   // final filePath = '/data/user/0/com.atomar.dukti/cache/file_picker/1733349332034/youtube.apk';

//   logger.i('Uploading file: $filePath');

//   final dio = Dio();

//   final formData = FormData.fromMap({
//     'file': await MultipartFile.fromFile(filePath),
//     'clientId': clientId,
//   });

//   final address = 'http://${client.ip}:${client.port}/upload';
//   logger.i('Uploading to: $address');

//   final startTime = DateTime.now();

//   try {
//     await dio.post(
//       address,
//       data: formData,
//       onSendProgress: (int sent, int total) {
//         // dependency injection of stream controller?

//         final currentTime = DateTime.now();
//         final elapsedTime = currentTime.difference(startTime).inSeconds;
//         if (elapsedTime > 0) {
//           final speed = sent / elapsedTime; // bytes per second

//           // uploadSpeedNotifier.set(speed.toInt());
//           updateSpeed(speed.toInt());
//         }
//         final progress = sent / total;

//         // uploadProgressNotifier.set(progress);
//         updateProgress(progress);

//         // logger.t('Upload progress dio: $progress');
//       },
//     );
//     Future.delayed(const Duration(seconds: 1), () {
//       updateProgress(0.0);
//     });

//     logger.i('Upload complete');
//   } catch (e) {
//     logger.i('Upload failed: $e');
//   }
// }