#!/usr/bin/env python

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

"""
Legpad is used to compile .dart files to javascript, using the dart2js compiler.

This is accomplished by creating an html file (usually called
<something>.legpad.html) that executes the dart2js compiler when the page
is loaded by a web browser (or DumpRenderTree).

The <something>.legpad.html file contains:

  1. all the dart files that compose a user's dart program
  2. all the dart files of dart:core and other standard dart libraries
      (or any other symbol that can follow "dart:" in an import statement
  3. legpad.dart (compiled to javascript)

The contents of each dart file is placed in a separate <script> tag.

When the html page is loaded by a browser, the leg compiler is invoked
and the dart program is compiled to javascript.  The generated javascript is
placed in a <pre> element with id "output".

When the html page is passed to DumpRenderTree, the dumped output will
have the generated javascript.

See 'example.sh' for an example of how to run legpad.
"""

import logging
import optparse
import os.path
import platform
import re
import subprocess
import sys


class FileNotFoundException(Exception):
  def __init__(self, file_name):
    self._name = file_name

  def __str__(self):
    return self._name


class CommandFailedException(Exception):
  def __init__(self, message):
    self._message = message

  def GetMessage(self):
    return self._message


# Template for the legpad.html page we're going to generate.
HTML = """<!DOCTYPE html>
<html>
<head>
  <style type="text/css">
    textarea {
      width: 100%;
      height: 200px;
    }
    .label {
      margin-top: 5px;
    }
    pre {
      border: 2px solid black;
    }
  </style>
  {{script_tags}}
  <script type="text/javascript">
    if (window.layoutTestController) {
      layoutTestController.dumpAsText();
    }
  </script>
</head>
<body>
  <h1>Legpad</h1>
  <div class="label">Input:</div>
  <textarea id="input"></textarea>
  <div class="label">Compiler Messages:</div>
  <pre id="warnings"></pre>
  <div class="label">Timing:</div>
  <pre id="timing"></pre>
  <div class="label">Output:</div>
  <pre id="output"></pre>
  <script type="text/javascript">
    {{LEGPAD_JS}}
  </script>
</body>
</html>
"""

# This finds everything after the word "Output:" in the html page.
# (Note, because the javascript we're fishing out spans multiple lines
# we need to use the DOTALL switch here.)
OUTPUT_JAVASCRIPT_REGEX = re.compile(".*\nOutput:\n(.*)\n#EOF", re.DOTALL)

# If the legpad.dart encounters a compilation error, the generated
# javascript will contains the words "dart2js compilation error".
COMPILATION_ERROR_REGEX = re.compile(".*dart2js compilation error.*", re.DOTALL)

# We use "application/inert" here to make the browser ignore the
# these script tags.  (legpad.dart will fish out the contents as needed.)
#
SCRIPT_TAG = """<script type="application/inert" id="{{id}}">
{{contents}}
</script>
"""

# Regex that finds #import, #source and #native directives in .dart files.
#   match.group(1) = "import", "source" or "native"
#   match.group(2) = url of file being imported
DIRECTIVE_RE = re.compile(r"^#(import|source|native)\([\"']([^\"']*)[\"']")

# id of script tag that holds name of the top dart file to be compiled,
# (This file name passed will be passed to the leg compiler by legpad.dart.)
MAIN_ID = "main_id"

# TODO(mattsh): read this from some config file once ahe/zundel create it
DART_LIBRARIES = {
    "core": "lib/compiler/implementation/lib/core.dart",
    "_js_helper": "lib/compiler/implementation/lib/js_helper.dart",
    "_interceptors": "lib/compiler/implementation/lib/interceptors.dart",
    "dom": "lib/dom/frog/dom_frog.dart",
    "html": "lib/html/frog/html_frog.dart",
    "io": "lib/compiler/implementation/lib/io.dart",
    "isolate": "lib/isolate/isolate_leg.dart",
    "json": "lib/json/json.dart",
    "uri": "lib/uri/uri.dart",
    "utf": "lib/utf/utf.dart",
}

class Pad(object):
  """
  Accumulates all source files that are needed to compile a dart program,
  and places them in <script> tags on an html page.
  """

  def __init__(self, argv):
    parser = optparse.OptionParser(usage=
      "%prog [options] file_to_compile.dart"
    )
    parser.add_option("-o", "--out",
        help="name of javascript output file")
    parser.add_option("-v", "--verbose", action="store_true",
        help="more verbose logging")
    (options, args) = parser.parse_args(argv)

    log_level = logging.INFO
    if options.verbose:
      log_level = logging.DEBUG
    logging.basicConfig(level=log_level)

    if len(args) < 2:
      parser.print_help()
      sys.exit(1)

    self.main_file = os.path.abspath(args[1])

    # directory of this script
    self.legpad_dir = os.path.abspath(os.path.dirname(argv[0]))

    # root of dart source repo
    self.dart_dir = os.path.dirname(os.path.dirname(os.path.dirname(
        self.legpad_dir)))

    logging.debug("dart_dir: '%s'" % self.dart_dir)

    if options.out:
      # user has specified an output file name
      self.js_file = os.path.abspath(options.out)
    else:
      # User didn't specify an output file, so use the input
      # file name as the base of the output file name.
      self.js_file = self.main_file + ".legpad.js"

    logging.debug("js_file: '%s" % self.js_file)

    # this is the html file that we pass to DumpRenderTree
    self.html_file = self.main_file + ".legpad.html"
    logging.debug("html_file: '%s'" % self.html_file)

    # map from file name to File object (contains entries for all corelib
    # and all other dart files needed to compile main_file)
    self.name_to_file = {}

    # map from script tag id to File object
    self.id_to_file = {}

    self.load_libraries()
    self.load_file(self.main_file)

    html = self.generate_html()
    write_file(self.html_file, html)

    js = self.generate_js()
    write_file(self.js_file, js)

    line_count = len(js.splitlines())
    logging.debug("generated '%s' (%d lines)", self.js_file, line_count)

    match = COMPILATION_ERROR_REGEX.match(js)
    if match:
      sys.exit(1)

  def generate_html(self):
    tags = []
    for f in self.id_to_file.values():
      tags.append(self._create_tag(f.id, f.contents))
    tags.append(self._create_tag(MAIN_ID, self.shorten(self.main_file)))
    html = HTML.replace("{{script_tags}}", "".join(tags))

    legpad_js = os.path.join(self.legpad_dir, "legpad.dart.js")
    check_exists(legpad_js)

    html = html.replace("{{LEGPAD_JS}}", read_file(legpad_js))
    return html

  def generate_js(self):
    drt = os.path.join(self.dart_dir, "client/tests/drt/DumpRenderTree")
    if platform.system() == 'Darwin':
      drt += ".app"
    elif platform.system() == 'Windows':
      raise Exception("legpad does not run on Windows")

    check_exists(drt)
    args = []
    args.append(drt)
    args.append(self.html_file)

    stdout = run_command(args)
    match = OUTPUT_JAVASCRIPT_REGEX.match(stdout)
    if not match:
      raise Exception("can't find regex in DumpRenderTree output")
    return match.group(1)

  @staticmethod
  def _create_tag(id, contents):
    s = SCRIPT_TAG
    s = s.replace("{{id}}", id)
    # TODO(mattsh) - need to html escape here
    s = s.replace("{{contents}}", contents)
    return s

  def dart_library(self, name):
    path = DART_LIBRARIES[name]
    if not path:
      raise Exception("unrecognized 'dart:%s'", name)
    return os.path.join(self.dart_dir, path)

  def load_libraries(self):
    for name in DART_LIBRARIES:
      self.load_file(self.dart_library(name))

  def load_file(self, name):
    name = os.path.abspath(name)
    if name in self.name_to_file:
      return
    f = File(self, name)
    self.name_to_file[f.name] = f
    if f.id in self.id_to_file:
      raise Exception("ambiguous id '%s'" % f.id)
    self.id_to_file[f.id] = f
    f.directives()

  def shorten(self, name):
    """
    Change that full path of the dart svn repo to simply "dartdir"
    """
    return name.replace(self.dart_dir, "dartdir")

  def make_id(self, name):
    """
    Generates an id (based on the file name) for the <script> tag that will
    hold the contents of this file.
    """
    return self.shorten(name).replace("/", "_").replace(".", "_")


class File(object):
  def __init__(self, pad, name):
    self.pad = pad
    self.name = name
    self.id = pad.make_id(name)
    self.contents = read_file(name)

  def directives(self):
    """Load files referenced by #source, #import and #native directives."""
    lines = self.contents.split("\n")
    self.line_number = 0
    for line in lines:
      self.line_number += 1
      self._directive(line)

  def _directive(self, line):
    match = DIRECTIVE_RE.match(line)
    if not match:
      return
    url = match.group(2)
    if url.startswith("dart:"):
      path = self.pad.dart_library(url[len("dart:"):])
    else:
      path = os.path.join(os.path.dirname(self.name), url)
    self.pad.load_file(path)


def read_file(file_name):
  check_exists(file_name)
  with open(file_name, "r") as input:
    contents = input.read()
  logging.debug("read_file '%s' (%d bytes)" % (file_name, len(contents)))
  return contents


def write_file(file_name, contents):
  with open(file_name, "w") as output:
    output.write(contents)

  check_exists(file_name)
  logging.debug("write_file '%s' (%d bytes)" % (file_name, len(contents)))


def check_exists(file_name):
  if not os.path.exists(file_name):
    raise FileNotFoundException(file_name)


def format_command(args):
  return ' '.join(args)


def run_command(args):
  """
  Args:
    command: comamnd with arguments to exec
  Returns:
    all output that this command sent to stdout
  """

  command = format_command(args)
  logging.info("RUNNING: '%s'" % command)
  child = subprocess.Popen(args,
      stdout=subprocess.PIPE,
      stderr=subprocess.PIPE,
      close_fds=True)
  (stdout, stderr) = child.communicate()
  exit_code = child.wait()
  if exit_code:
    for line in stderr.splitlines():
      logging.info(line)
    msg = "FAILURE (exit_code=%d): '%s'" % (exit_code, command)
    logging.error(msg)
    raise CommandFailedException(msg)
  logging.debug("SUCCEEDED (%d bytes)" % len(stdout))
  return stdout


def main(argv):
  Pad(argv)

if __name__ == "__main__":
  sys.exit(main(sys.argv))