waylume_server/lib/web/peer_routes.dart

import 'dart:convert';

import 'package:shelf/shelf.dart';
import 'package:shelf_router/shelf_router.dart';
import 'package:waylume_server/wireguard/peers.dart';
import 'package:waylume_server/wireguard/utils.dart';
import 'package:waylume_server/core/utils.dart';
import 'package:waylume_server/services/vpn_session_service.dart';

class PeerRoutes {
  Router get router {
    final router = Router();

    router.post('/peers', _createPeer);
    router.post('/peers/delete', _deletePeer);
    router.post('/peers/config', _getPeerConfig);
    router.post('/peers/speed-limit', _setSpeedLimit);
    router.post('/peers/data-cap', _setDataCap);

    return router;
  }

  Future<Response> _createPeer(Request request) async {
    try {
      final peer = await createPeer();
      final geoData = await getGeolocationData();
      String serverEndpoint = '${geoData.ip}:51820';
      String serverPublicKey = await getServerPublicKey();
      
      final responseData = <String, dynamic>{
        'peer': {
          'ip': peer.ip,
          'privateKey': peer.privateKey,
          'publicKey': peer.publicKey,
        },
        'server': {
          'publicKey': serverPublicKey,
          'endpoint': serverEndpoint,
        },
        'success': true,
      };
      
      return Response.ok(
        jsonEncode(responseData),
        headers: {'Content-Type': 'application/json'},
      );
    } catch (e) {
      return Response.internalServerError(
        body: jsonEncode({
          'success': false,
          'error': e.toString(),
        }),
        headers: {'Content-Type': 'application/json'},
      );
    }
  }

  Future<Response> _deletePeer(Request request) async {
    try {
      final body = await request.readAsString();
      final data = jsonDecode(body) as Map<String, dynamic>;
      final publicKey = data['publicKey'] as String?;
      
      if (publicKey == null) {
        return Response.badRequest(
          body: jsonEncode({
            'success': false,
            'error': 'publicKey parameter is required',
          }),
          headers: {'Content-Type': 'application/json'},
        );
      }
      
      final success = await deletePeer(publicKey);
      
      return Response.ok(
        jsonEncode({
          'success': success,
          'message': success ? 'Peer deleted successfully' : 'Failed to delete peer',
        }),
        headers: {'Content-Type': 'application/json'},
      );
    } catch (e) {
      return Response.internalServerError(
        body: jsonEncode({
          'success': false,
          'error': e.toString(),
        }),
        headers: {'Content-Type': 'application/json'},
      );
    }
  }

  Future<Response> _getPeerConfig(Request request) async {
    try {
      final body = await request.readAsString();
      final data = jsonDecode(body) as Map<String, dynamic>;
      final publicKey = data['publicKey'] as String?;
      
      if (publicKey == null) {
        return Response.badRequest(
          body: jsonEncode({
            'success': false,
            'error': 'publicKey parameter is required',
          }),
          headers: {'Content-Type': 'application/json'},
        );
      }
      
      return Response.notFound(
        jsonEncode({
          'success': false,
          'error': 'Config retrieval not implemented - peer info not stored',
        }),
        headers: {'Content-Type': 'application/json'},
      );
    } catch (e) {
      return Response.internalServerError(
        body: jsonEncode({
          'success': false,
          'error': e.toString(),
        }),
        headers: {'Content-Type': 'application/json'},
      );
    }
  }

  Future<Response> _setSpeedLimit(Request request) async {
    try {
      final body = await request.readAsString();
      final data = jsonDecode(body) as Map<String, dynamic>;
      final publicKey = data['publicKey'] as String?;
      final bytesPerSecond = data['bytesPerSecond'] as int?;
      
      if (publicKey == null) {
        return Response.badRequest(
          body: jsonEncode({
            'success': false,
            'error': 'publicKey parameter is required',
          }),
          headers: {'Content-Type': 'application/json'},
        );
      }
      
      if (bytesPerSecond == null) {
        return Response.badRequest(
          body: jsonEncode({
            'success': false,
            'error': 'bytesPerSecond parameter is required',
          }),
          headers: {'Content-Type': 'application/json'},
        );
      }
      
      await setSpeedLimit(publicKey, bytesPerSecond);
      
      return Response.ok(
        jsonEncode({
          'success': true,
          'message': 'Speed limit set successfully',
        }),
        headers: {'Content-Type': 'application/json'},
      );
    } catch (e) {
      return Response.internalServerError(
        body: jsonEncode({
          'success': false,
          'error': e.toString(),
        }),
        headers: {'Content-Type': 'application/json'},
      );
    }
  }

  Future<Response> _setDataCap(Request request) async {
    try {
      final body = await request.readAsString();
      final data = jsonDecode(body) as Map<String, dynamic>;
      final publicKey = data['publicKey'] as String?;
      final quotaBytes = data['quotaBytes'] as int?;
      
      if (publicKey == null) {
        return Response.badRequest(
          body: jsonEncode({
            'success': false,
            'error': 'publicKey parameter is required',
          }),
          headers: {'Content-Type': 'application/json'},
        );
      }
      
      if (quotaBytes == null) {
        return Response.badRequest(
          body: jsonEncode({
            'success': false,
            'error': 'quotaBytes parameter is required',
          }),
          headers: {'Content-Type': 'application/json'},
        );
      }
      
      await setDataCap(publicKey, quotaBytes);
      
      return Response.ok(
        jsonEncode({
          'success': true,
          'message': 'Data cap set successfully',
        }),
        headers: {'Content-Type': 'application/json'},
      );
    } catch (e) {
      return Response.internalServerError(
        body: jsonEncode({
          'success': false,
          'error': e.toString(),
        }),
        headers: {'Content-Type': 'application/json'},
      );
    }
  }
}