// Copyright (c) 2023, 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.

@Tags(['daily'])
@Timeout(Duration(minutes: 3))
library;

import 'dart:async';
import 'dart:convert';
import 'dart:io';

import 'package:path/path.dart' as p;
import 'package:test/test.dart';

// TODO(elliette): Move to a cron job. This tests that the currently published
// Webdev can be activated and serve a web app. It is intended to catch any
// regressions due to changes in the Dart SDK.

enum StreamType { stdout, stderr }

const processTimeout = Duration(minutes: 1);

void main() {
  Process? createProcess;
  Process? activateProcess;
  Process? serveProcess;
  Directory? tempDir0;

  final testScript = File(
    p.join(p.dirname(Platform.script.toFilePath()), 'test.dart'),
  ).readAsStringSync();
  final thisScript = File.fromUri(
    Uri.parse(
      testScript.substring(
        testScript.lastIndexOf('import', testScript.indexOf('as test;')) + 8,
        testScript.indexOf('as test;') - 2,
      ),
    ),
  );
  final packageDir = p.dirname(p.dirname(thisScript.path));

  Future<void> expectStdoutAndCleanExit(
    Process process, {
    required String expectedStdout,
  }) async {
    final stdoutCompleter = _captureOutput(
      process,
      streamType: StreamType.stdout,
      stopCaptureFuture: process.exitCode,
    );
    final stderrCompleter = _captureOutput(
      process,
      streamType: StreamType.stderr,
      stopCaptureFuture: process.exitCode,
    );
    final exitCode = await _waitForExitOrTimeout(process);
    final stderrLogs = await stderrCompleter.future;
    final stdoutLogs = await stdoutCompleter.future;
    expect(
      exitCode,
      equals(0),
      // Include the stderr and stdout logs if the process does not terminate
      // cleanly:
      reason: 'stderr: $stderrLogs, stdout: $stdoutLogs',
    );
    expect(stderrLogs, isEmpty);
    expect(stdoutLogs, contains(expectedStdout));
  }

  Future<void> expectStdoutThenExit(
    Process process, {
    required String expectedStdout,
  }) async {
    final expectedStdoutCompleter = _waitForStdoutOrTimeout(
      process,
      expectedStdout: expectedStdout,
    );
    final stderrCompleter = _captureOutput(
      process,
      streamType: StreamType.stderr,
      stopCaptureFuture: expectedStdoutCompleter.future,
    );
    final stdoutLogs = await expectedStdoutCompleter.future;
    final stderrLogs = await stderrCompleter.future;
    expect(
      stdoutLogs,
      contains(expectedStdout),
      // Also include the stderr if the stdout is not expected.
      reason: 'stderr: $stderrLogs',
    );
  }

  setUp(() async {
    tempDir0 = Directory.systemTemp.createTempSync('installation_test');

    await Process.run('dart', ['pub', 'global', 'deactivate', 'webdev']);
  });

  tearDown(() async {
    // Kill any stale processes:
    if (createProcess != null) {
      Process.killPid(createProcess!.pid, ProcessSignal.sigint);
      createProcess = null;
    }
    if (activateProcess != null) {
      Process.killPid(activateProcess!.pid, ProcessSignal.sigint);
      activateProcess = null;
    }
    if (serveProcess != null) {
      Process.killPid(serveProcess!.pid, ProcessSignal.sigint);
      serveProcess = null;
    }
  });

  test('can activate and serve webdev', () async {
    final tempDir = tempDir0!;
    final tempPath = tempDir.path;

    // Verify that we can create a new Dart app:
    createProcess = await Process.start('dart', [
      'create',
      '--template',
      'web',
      'temp_app',
    ], workingDirectory: tempPath);
    await expectStdoutAndCleanExit(
      createProcess!,
      expectedStdout: 'Created project temp_app in temp_app!',
    );
    final appPath = p.join(tempPath, 'temp_app');
    expect(await Directory(appPath).exists(), isTrue);

    // Verify that `dart pub global activate` works:
    activateProcess = await Process.start('dart', [
      'pub',
      'global',
      'activate',
      'webdev',
    ]);
    await expectStdoutAndCleanExit(
      activateProcess!,
      expectedStdout: 'Activated webdev',
    );

    // Verify that `webdev serve` works for our new app:
    serveProcess = await Process.start('dart', [
      'pub',
      'global',
      'run',
      'webdev',
      'serve',
    ], workingDirectory: appPath);
    await expectStdoutThenExit(
      serveProcess!,
      expectedStdout: 'Serving `web` on',
    );
  });

  test('activate and serve webdev fails with offline', () async {
    final tempDir = tempDir0!;
    final tempPath = tempDir.path;

    // Verify that we can create a new Dart app:
    createProcess = await Process.start('dart', [
      'create',
      '--no-pub',
      '--template',
      'web',
      'temp_app',
    ], workingDirectory: tempPath);
    await expectStdoutAndCleanExit(
      createProcess!,
      expectedStdout: 'Created project temp_app in temp_app!',
    );
    final appPath = p.join(tempPath, 'temp_app');
    expect(await Directory(appPath).exists(), isTrue);

    // Verify that `dart pub global activate` works:
    activateProcess = await Process.start('dart', [
      'pub',
      'global',
      'activate',
      '--source',
      'path',
      packageDir,
    ]);
    await expectStdoutAndCleanExit(
      activateProcess!,
      expectedStdout: 'Activated webdev',
    );

    // Verify that `webdev serve` works for our new app:
    serveProcess = await Process.start('dart', [
      'pub',
      'global',
      'run',
      'webdev',
      'serve',
      '--offline',
      'web:8081',
    ], workingDirectory: appPath);
    await expectStdoutThenExit(
      serveProcess!,
      expectedStdout: 'Cannot open file\n  pubspec.lock\n',
    );
  });
}

Future<int> _waitForExitOrTimeout(Process process) {
  Timer(processTimeout, () {
    process.kill(ProcessSignal.sigint);
  });
  return process.exitCode;
}

/// Returns the stdout for the [process] once the [expectedStdout] is found.
///
/// Otherwise returns all the stdout up to the [processTimeout].
Completer<String> _waitForStdoutOrTimeout(
  Process process, {
  required String expectedStdout,
}) {
  var output = '';
  final completer = Completer<String>();

  Timer(processTimeout, () {
    process.kill(ProcessSignal.sigint);
    if (!completer.isCompleted) {
      completer.complete(output);
    }
  });
  process.stdout.transform(utf8.decoder).listen((line) {
    output += line;
    if (line.contains(expectedStdout)) {
      process.kill(ProcessSignal.sigint);
      if (!completer.isCompleted) {
        completer.complete(output);
      }
    }
  });

  return completer;
}

Completer<String> _captureOutput(
  Process process, {
  required StreamType streamType,
  required Future stopCaptureFuture,
}) {
  final stream = streamType == StreamType.stdout
      ? process.stdout
      : process.stderr;
  final completer = Completer<String>();
  var output = '';
  stream.transform(utf8.decoder).listen((line) {
    output += line;
    if (line.contains('[SEVERE]')) {
      process.kill(ProcessSignal.sigint);
      if (!completer.isCompleted) {
        completer.complete(output);
      }
    }
  });
  unawaited(
    stopCaptureFuture.then((_) {
      if (!completer.isCompleted) {
        completer.complete(output);
      }
    }),
  );
  return completer;
}