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

/** The entry point to the compiler. Used to implement `bin/dwc.dart`. */
library dwc;

import 'dart:async';
import 'dart:io';
import 'package:logging/logging.dart' show Level;

import 'src/compiler.dart';
import 'src/file_system.dart';
import 'src/file_system/console.dart';
import 'src/files.dart';
import 'src/messages.dart';
import 'src/compiler_options.dart';
import 'src/utils.dart';

FileSystem _fileSystem;

void main() {
  run(new Options().arguments).then((result) {
    exit(result.success ? 0 : 1);
  });
}

/** Contains the result of a compiler run. */
class CompilerResult {
  final bool success;

  /** Map of output path to source, if there is one */
  final Map<String, String> outputs;

  /** List of files read during compilation */
  final List<String> inputs;

  final List<String> messages;
  String bootstrapFile;

  CompilerResult([this.success = true,
                  this.outputs,
                  this.inputs,
                  this.messages = const [],
                  this.bootstrapFile]);

  factory CompilerResult._(bool success,
      List<String> messages, List<OutputFile> outputs, List<SourceFile> files) {
    var file;
    var outs = new Map<String, String>();
    for (var out in outputs) {
      if (path.basename(out.path).endsWith('_bootstrap.dart')) {
        file = out.path;
      }
      outs[out.path] = out.source;
    }
    var inputs = files.map((f) => f.path).toList();
    return new CompilerResult(success, outs, inputs, messages, file);
  }
}

/**
 * Runs the web components compiler with the command-line options in [args].
 * See [CompilerOptions] for the definition of valid arguments.
 */
// TODO(jmesserly): fix this to return a proper exit code
// TODO(justinfagnani): return messages in the result
Future<CompilerResult> run(List<String> args, {bool printTime,
    bool shouldPrint: true}) {
  var options = CompilerOptions.parse(args);
  if (options == null) return new Future.value(new CompilerResult());
  if (printTime == null) printTime = options.verbose;

  _fileSystem = new ConsoleFileSystem();
  var messages = new Messages(options: options, shouldPrint: shouldPrint);

  return asyncTime('Total time spent on ${options.inputFile}', () {
    var compiler = new Compiler(_fileSystem, options, messages);
    var res;
    return compiler.run()
      .then((_) {
        var success = messages.messages.every((m) => m.level != Level.SEVERE);
        var msgs = options.jsonFormat
            ? messages.messages.map((m) => m.toJson())
            : messages.messages.map((m) => m.toString());
        res = new CompilerResult._(success, msgs.toList(),
            compiler.output, compiler.files);
      })
      .then((_) => _symlinkPubPackages(res, options, messages))
      .then((_) => _emitFiles(compiler.output, options.clean))
      .then((_) => res);
  }, printTime: printTime, useColors: options.useColors);
}

Future _emitFiles(List<OutputFile> outputs, bool clean) {
  outputs.forEach((f) => _writeFile(f.path, f.contents, clean));
  return _fileSystem.flush();
}

void _writeFile(String filePath, String contents, bool clean) {
  if (clean) {
    File fileOut = new File(filePath);
    if (fileOut.existsSync()) {
      fileOut.deleteSync();
    }
  } else {
    _createIfNeeded(path.dirname(filePath));
    _fileSystem.writeString(filePath, contents);
  }
}

void _createIfNeeded(String outdir) {
  if (outdir.isEmpty) return;
  var outDirectory = new Directory(outdir);
  if (!outDirectory.existsSync()) {
    _createIfNeeded(path.dirname(outdir));
    outDirectory.createSync();
  }
}

/**
 * Creates a symlink to the pub packages directory in the output location. The
 * returned future completes when the symlink was created (or immediately if it
 * already exists).
 */
Future _symlinkPubPackages(CompilerResult result, CompilerOptions options,
    Messages messages) {
  if (options.outputDir == null || result.bootstrapFile == null
      || options.packageRoot != null) {
    // We don't need to copy the packages directory if the output was generated
    // in-place where the input lives, if the compiler was called without an
    // entry-point file, or if the compiler was called with a package-root
    // option.
    return new Future.value(null);
  }

  var linkDir = path.dirname(result.bootstrapFile);
  _createIfNeeded(linkDir);
  var linkPath = path.join(linkDir, 'packages');
  // A resolved symlink works like a directory
  // TODO(sigmund): replace this with something smarter once we have good
  // symlink support in dart:io
  if (new Directory(linkPath).existsSync()) {
    // Packages directory already exists.
    return new Future.value(null);
  }

  // A broken symlink works like a file
  var toFile = new File(linkPath);
  if (toFile.existsSync()) {
    toFile.deleteSync();
  }

  var targetPath = path.join(path.dirname(options.inputFile), 'packages');
  // [fullPathSync] will canonicalize the path, resolving any symlinks.
  // TODO(sigmund): once it's possible in dart:io, we just want to use a full
  // path, but not necessarily resolve symlinks.
  var target = new File(targetPath).fullPathSync().toString();
  return createSymlink(target, linkPath, messages: messages);
}


// TODO(jmesserly): this code was taken from Pub's io library.
// Added error handling and don't return the file result, to match the code
// we had previously. Also "target" and "link" only accept strings. And inlined
// the relevant parts of runProcess. Note that it uses "cmd" to get the path
// on Windows.
/**
 * Creates a new symlink that creates an alias of [target] at [link], both of
 * which can be a [String], [File], or [Directory]. Returns a [Future] which
 * completes to the symlink file (i.e. [link]).
 */
Future createSymlink(String target, String link, {Messages messages: null}) {
  messages = messages == null? new Messages.silent() : messages;
  var command = 'ln';
  var args = ['-s', target, link];

  if (Platform.operatingSystem == 'windows') {
    // Call mklink on Windows to create an NTFS junction point. Only works on
    // Vista or later. (Junction points are available earlier, but the "mklink"
    // command is not.) I'm using a junction point (/j) here instead of a soft
    // link (/d) because the latter requires some privilege shenanigans that
    // I'm not sure how to specify from the command line.
    command = 'cmd';
    args = ['/c', 'mklink', '/j', link, target];
  }

  return Process.run(command, args).then((result) {
    if (result.exitCode != 0) {
      var details = 'subprocess stdout:\n${result.stdout}\n'
                    'subprocess stderr:\n${result.stderr}';
      messages.error(
        'unable to create symlink\n target: $target\n link:$link\n$details',
        null);
    }
    return null;
  });
}