// 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.

// OtherResources=file_lock_script.dart

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

import "package:async_helper/async_helper.dart";
import "package:expect/expect.dart";
import "package:path/path.dart";

// Check whether the file is locked or not.
check(String path, int start, int end, FileLock mode, {bool locked}) {
  // Client process returns either 'LOCK FAILED' or 'LOCK SUCCEEDED'.
  var expected = locked ? 'LOCK FAILED' : 'LOCK SUCCEEDED';
  var arguments = []
    ..addAll(Platform.executableArguments)
    ..add(Platform.script.resolve('file_lock_script.dart').toFilePath())
    ..add(path)
    ..add(mode == FileLock.EXCLUSIVE ? 'EXCLUSIVE' : 'SHARED')
    ..add('$start')
    ..add('$end');
  return Process
      .run(Platform.executable, arguments)
      .then((ProcessResult result) {
    if (result.exitCode != 0 || !result.stdout.contains(expected)) {
      print("Client failed, exit code ${result.exitCode}");
      print("  stdout:");
      print(result.stdout);
      print("  stderr:");
      print(result.stderr);
      print("  arguments:");
      print(arguments);
      Expect.fail('Client subprocess exit code: ${result.exitCode}');
    }
  });
}

checkLocked(String path,
        [int start = 0, int end = -1, FileLock mode = FileLock.EXCLUSIVE]) =>
    check(path, start, end, mode, locked: true);

checkNotLocked(String path,
        [int start = 0, int end = -1, FileLock mode = FileLock.EXCLUSIVE]) =>
    check(path, start, end, mode, locked: false);

void testLockWholeFile() {
  Directory directory = Directory.systemTemp.createTempSync('dart_file_lock');
  File file = new File(join(directory.path, "file"));
  file.writeAsBytesSync(new List.filled(10, 0));
  var raf = file.openSync(mode: WRITE);
  raf.lockSync();
  asyncStart();
  checkLocked(file.path).then((_) {
    return checkLocked(file.path, 0, 2).then((_) {
      raf.unlockSync();
      return checkNotLocked(file.path).then((_) {});
    });
  }).whenComplete(() {
    raf.closeSync();
    directory.deleteSync(recursive: true);
    asyncEnd();
  });
}

void testLockWholeFileAsync() {
  Directory directory = Directory.systemTemp.createTempSync('dart_file_lock');
  File file = new File(join(directory.path, "file"));
  file.writeAsBytesSync(new List.filled(10, 0));
  var raf = file.openSync(mode: WRITE);
  asyncStart();
  Future.forEach([
    () => raf.lock(),
    () => checkLocked(file.path, 0, 2),
    () => checkLocked(file.path),
    () => raf.unlock(),
    () => checkNotLocked(file.path),
  ], (f) => f()).whenComplete(() {
    raf.closeSync();
    directory.deleteSync(recursive: true);
    asyncEnd();
  });
}

void testLockRange() {
  Directory directory = Directory.systemTemp.createTempSync('dart_file_lock');
  File file = new File(join(directory.path, "file"));
  file.writeAsBytesSync(new List.filled(10, 0));
  var raf1 = file.openSync(mode: WRITE);
  var raf2 = file.openSync(mode: WRITE);
  asyncStart();
  var tests = [
    () => raf1.lockSync(FileLock.EXCLUSIVE, 2, 3),
    () => raf2.lockSync(FileLock.EXCLUSIVE, 5, 7),
    () => checkNotLocked(file.path, 0, 2),
    () => checkLocked(file.path, 0, 3),
    () => checkNotLocked(file.path, 4, 5),
    () => checkLocked(file.path, 4, 6),
    () => checkLocked(file.path, 6),
    () => checkNotLocked(file.path, 7),
    () => raf1.unlockSync(2, 3),
    () => checkNotLocked(file.path, 0, 5),
    () => checkLocked(file.path, 4, 6),
    () => checkLocked(file.path, 6),
    () => checkNotLocked(file.path, 7),
  ];
  // On Windows regions unlocked must match regions locked.
  if (!Platform.isWindows) {
    tests.addAll([
      () => raf1.unlockSync(5, 6),
      () => checkNotLocked(file.path, 0, 6),
      () => checkLocked(file.path, 6),
      () => checkNotLocked(file.path, 7),
      () => raf2.unlockSync(6, 7),
      () => checkNotLocked(file.path)
    ]);
  } else {
    tests
        .addAll([() => raf2.unlockSync(5, 7), () => checkNotLocked(file.path)]);
  }
  Future.forEach(tests, (f) => f()).whenComplete(() {
    raf1.closeSync();
    raf2.closeSync();
    directory.deleteSync(recursive: true);
    asyncEnd();
  });
}

void testLockRangeAsync() {
  Directory directory = Directory.systemTemp.createTempSync('dart_file_lock');
  File file = new File(join(directory.path, "file"));
  file.writeAsBytesSync(new List.filled(10, 0));
  var raf1 = file.openSync(mode: WRITE);
  var raf2 = file.openSync(mode: WRITE);
  asyncStart();
  var tests = [
    () => raf1.lock(FileLock.EXCLUSIVE, 2, 3),
    () => raf2.lock(FileLock.EXCLUSIVE, 5, 7),
    () => checkNotLocked(file.path, 0, 2),
    () => checkLocked(file.path, 0, 3),
    () => checkNotLocked(file.path, 4, 5),
    () => checkLocked(file.path, 4, 6),
    () => checkLocked(file.path, 6),
    () => checkNotLocked(file.path, 7),
    () => raf1.unlock(2, 3),
    () => checkNotLocked(file.path, 0, 5),
    () => checkLocked(file.path, 4, 6),
    () => checkLocked(file.path, 6),
    () => checkNotLocked(file.path, 7),
  ];
  // On Windows regions unlocked must match regions locked.
  if (!Platform.isWindows) {
    tests.addAll([
      () => raf1.unlock(5, 6),
      () => checkNotLocked(file.path, 0, 6),
      () => checkLocked(file.path, 6),
      () => checkNotLocked(file.path, 7),
      () => raf2.unlock(6, 7),
      () => checkNotLocked(file.path)
    ]);
  } else {
    tests.addAll([() => raf2.unlock(5, 7), () => checkNotLocked(file.path)]);
  }
  Future.forEach(tests, (f) => f()).whenComplete(() {
    raf1.closeSync();
    raf2.closeSync();
    directory.deleteSync(recursive: true);
    asyncEnd();
  });
}

void testLockEnd() {
  Directory directory = Directory.systemTemp.createTempSync('dart_file_lock');
  File file = new File(join(directory.path, "file"));
  file.writeAsBytesSync(new List.filled(10, 0));
  var raf = file.openSync(mode: APPEND);
  asyncStart();
  Future.forEach([
    () => raf.lockSync(FileLock.EXCLUSIVE, 2),
    () => checkNotLocked(file.path, 0, 2),
    () => checkLocked(file.path, 0, 3),
    () => checkLocked(file.path, 9),
    () => raf.writeFromSync(new List.filled(10, 0)),
    () => checkLocked(file.path, 10),
    () => checkLocked(file.path, 19),
    () => raf.unlockSync(2),
    () => checkNotLocked(file.path)
  ], (f) => f()).whenComplete(() {
    raf.closeSync();
    directory.deleteSync(recursive: true);
    asyncEnd();
  });
}

void testLockEndAsync() {
  Directory directory = Directory.systemTemp.createTempSync('dart_file_lock');
  File file = new File(join(directory.path, "file"));
  file.writeAsBytesSync(new List.filled(10, 0));
  var raf = file.openSync(mode: APPEND);
  asyncStart();
  Future.forEach([
    () => raf.lock(FileLock.EXCLUSIVE, 2),
    () => checkNotLocked(file.path, 0, 2),
    () => checkLocked(file.path, 0, 3),
    () => checkLocked(file.path, 9),
    () => raf.writeFromSync(new List.filled(10, 0)),
    () => checkLocked(file.path, 10),
    () => checkLocked(file.path, 19),
    () => raf.unlock(2),
    () => checkNotLocked(file.path)
  ], (f) => f()).whenComplete(() {
    raf.closeSync();
    directory.deleteSync(recursive: true);
    asyncEnd();
  });
}

void testLockShared() {
  Directory directory = Directory.systemTemp.createTempSync('dart_file_lock');
  File file = new File(join(directory.path, "file"));
  file.writeAsBytesSync(new List.filled(10, 0));
  var raf = file.openSync();
  asyncStart();
  Future.forEach([
    () => raf.lock(FileLock.SHARED),
    () => checkLocked(file.path),
    () => checkLocked(file.path, 0, 2),
    () => checkNotLocked(file.path, 0, 2, FileLock.SHARED)
  ], (f) => f()).then((_) {
    raf.closeSync();
    directory.deleteSync(recursive: true);
    asyncEnd();
  });
}

void testLockSharedAsync() {
  Directory directory = Directory.systemTemp.createTempSync('dart_file_lock');
  File file = new File(join(directory.path, "file"));
  file.writeAsBytesSync(new List.filled(10, 0));
  var raf = file.openSync();
  asyncStart();
  Future.forEach([
    () => raf.lock(FileLock.SHARED),
    () => checkLocked(file.path),
    () => checkLocked(file.path, 0, 2),
    () => checkNotLocked(file.path, 0, 2, FileLock.SHARED)
  ], (f) => f()).whenComplete(() {
    raf.closeSync();
    directory.deleteSync(recursive: true);
    asyncEnd();
  });
}

void testLockAfterLength() {
  Directory directory = Directory.systemTemp.createTempSync('dart_file_lock');
  File file = new File(join(directory.path, "file"));
  file.writeAsBytesSync(new List.filled(10, 0));
  var raf = file.openSync(mode: APPEND);
  asyncStart();
  Future.forEach([
    () => raf.lockSync(FileLock.EXCLUSIVE, 2, 15),
    () => checkNotLocked(file.path, 0, 2),
    () => checkLocked(file.path, 0, 3),
    () => checkLocked(file.path, 9),
    () => checkLocked(file.path, 14),
    () => raf.writeFromSync(new List.filled(10, 0)),
    () => checkLocked(file.path, 10),
    () => checkNotLocked(file.path, 15),
    () => raf.unlockSync(2, 15),
    () => checkNotLocked(file.path)
  ], (f) => f()).whenComplete(() {
    raf.closeSync();
    directory.deleteSync(recursive: true);
    asyncEnd();
  });
}

void testLockAfterLengthAsync() {
  Directory directory = Directory.systemTemp.createTempSync('dart_file_lock');
  File file = new File(join(directory.path, "file"));
  file.writeAsBytesSync(new List.filled(10, 0));
  var raf = file.openSync(mode: APPEND);
  asyncStart();
  Future.forEach([
    () => raf.lock(FileLock.EXCLUSIVE, 2, 15),
    () => checkNotLocked(file.path, 0, 2),
    () => checkLocked(file.path, 0, 3),
    () => checkLocked(file.path, 9),
    () => checkLocked(file.path, 14),
    () => raf.writeFromSync(new List.filled(10, 0)),
    () => checkLocked(file.path, 10),
    () => checkNotLocked(file.path, 15),
    () => raf.unlock(2, 15),
    () => checkNotLocked(file.path)
  ], (f) => f()).whenComplete(() {
    raf.closeSync();
    directory.deleteSync(recursive: true);
    asyncEnd();
  });
}

void main() {
  testLockWholeFile();
  testLockWholeFileAsync();
  testLockRange();
  testLockRangeAsync();
  testLockEnd();
  testLockEndAsync();
  testLockShared();
  testLockSharedAsync();
  testLockAfterLength();
  testLockAfterLengthAsync();
}