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';

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 config = await generateClientConfigForPeer(peer);
      
      return Response.ok(
        jsonEncode({
          'success': true,
          'peer': peer.toJson(),
          'config': config,
        }),
        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 speedKbps = data['speedKbps'] as int?;
      
      if (publicKey == null) {
        return Response.badRequest(
          body: jsonEncode({
            'success': false,
            'error': 'publicKey parameter is required',
          }),
          headers: {'Content-Type': 'application/json'},
        );
      }
      
      if (speedKbps == null) {
        return Response.badRequest(
          body: jsonEncode({
            'success': false,
            'error': 'speedKbps parameter is required',
          }),
          headers: {'Content-Type': 'application/json'},
        );
      }
      
      await setSpeedLimit(publicKey, speedKbps);
      
      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 dataCapMB = data['dataCapMB'] as int?;
      
      if (publicKey == null) {
        return Response.badRequest(
          body: jsonEncode({
            'success': false,
            'error': 'publicKey parameter is required',
          }),
          headers: {'Content-Type': 'application/json'},
        );
      }
      
      if (dataCapMB == null) {
        return Response.badRequest(
          body: jsonEncode({
            'success': false,
            'error': 'dataCapMB parameter is required',
          }),
          headers: {'Content-Type': 'application/json'},
        );
      }
      
      await setDataCap(publicKey, dataCapMB);
      
      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'},
      );
    }
  }
}