// Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

library isolate.example.http_server;

import 'dart:async';
import 'dart:io';
import 'dart:isolate';

import 'package:isolate/isolate_runner.dart';
import 'package:isolate/ports.dart';
import 'package:isolate/runner.dart';

Future<Future<Object?> Function()> runHttpServer(
    Runner runner, int port, HttpListener listener) async {
  var stopPort = await runner.run(_startHttpServer, [port, listener]);

  return () => _sendStop(stopPort);
}

Future<Object?> _sendStop(SendPort stopPort) =>
    singleResponseFuture(stopPort.send);

Future<SendPort> _startHttpServer(List<Object?> args) async {
  var port = args[0] as int;
  var listener = args[1] as HttpListener;

  var server =
      await HttpServer.bind(InternetAddress.anyIPv6, port, shared: true);
  await listener.start(server);

  return singleCallbackPort((SendPort resultPort) {
    sendFutureResult(Future.sync(listener.stop), resultPort);
  });
}

/// An [HttpRequest] handler setup. Gets called when with the server, and
/// is told when to stop listening.
///
/// These callbacks allow the listener to set up handlers for HTTP requests.
/// The object should be sendable to an equivalent isolate.
abstract class HttpListener {
  Future start(HttpServer server);

  Future stop();
}

/// An [HttpListener] that sets itself up as an echo server.
///
/// Returns the message content plus an ID describing the isolate that
/// handled the request.
class EchoHttpListener implements HttpListener {
  static const _delay = Duration(seconds: 2);
  static final _id = Isolate.current.hashCode;
  final SendPort _counter;

  StreamSubscription? _subscription;

  EchoHttpListener(this._counter);

  @override
  Future start(HttpServer server) async {
    print('Starting isolate $_id');
    _subscription = server.listen((HttpRequest request) async {
      await request.response.addStream(request);
      print('Request to $hashCode');
      request.response.write('#$_id\n');
      var watch = Stopwatch()..start();
      while (watch.elapsed < _delay) {
        await Future.delayed(const Duration(milliseconds: 100));
      }
      print('Response from $_id');
      await request.response.close();
      _counter.send(null);
    });
  }

  @override
  Future stop() async {
    print('Stopping isolate $_id');
    await _subscription?.cancel();
  }
}

void main(List<String> args) async {
  var port = 0;
  if (args.isNotEmpty) {
    port = int.parse(args[0]);
  }

  var counter = ReceivePort();
  HttpListener listener = EchoHttpListener(counter.sendPort);

  // Used to ensure the requested port is available or to find an available
  // port if `0` is provided.
  var socket =
      await ServerSocket.bind(InternetAddress.anyIPv6, port, shared: true);

  port = socket.port;
  var isolates = await Future.wait<IsolateRunner>(
      Iterable.generate(5, (_) => IsolateRunner.spawn()), cleanUp: (isolate) {
    isolate.close();
  });

  var stoppers =
      await Future.wait<Function>(isolates.map((IsolateRunner isolate) {
    return runHttpServer(isolate, socket.port, listener);
  }), cleanUp: (shutdownServer) {
    shutdownServer();
  });

  await socket.close();
  var count = 25;

  print('Server listening on port $port for $count requests');
  print('Test with:');
  print('  ab -l -c10 -n $count http://localhost:$port/');
  print("where 'ab' is ApacheBench from, e.g., apache2_tools.");

  await for (var _ in counter) {
    count--;
    if (count == 0) {
      print('Shutting down');
      for (var stopper in stoppers) {
        await stopper();
      }
      counter.close();
    }
  }
  print('Finished');
}