#!/usr/bin/env ruby
require 'rubygems'
begin
  require 'jsus'
rescue LoadError
  $: << File.expand_path(File.dirname(__FILE__) + "/../lib")
  require "jsus"
end

require "fileutils"
require 'choice'
start_time = Time.now

Choice.options do
  header "Jsus version #{Jsus.version}"
  
  option 'input_directory', :required => true do
    short "-i"
    long "--input-directory=DIRECTORY"
    desc "Path to directory containing your package to compile."
  end

  option 'output_directory', :required => true do
    short "-o"
    long "--output-directory=DIRECTORY"
    desc "Path to directory to output the compiled package."
  end
  
  option "dependencies", :required => false do
    short "-d"
    long  "--with-dependencies=DIRECTORY"
    desc "Path to directory containing packages this package relies on. " <<
         "If set, all the packages will be compiled into a single file."
  end

  option "without_scripts_info", :required => false do
    long "--without-scripts-info"
    desc "When this flag is set, jsus doesn't generate scripts.json" <<
         "file with general info about your package."
  end

  option "without_tree", :required => false do
    long "--without-tree"
    desc "When this flag is set, jsus doesn't generate tree.json file" <<
         "with tree structure of your package."
  end

  option "generate_includes", :required => false do
    short "-g"
    long  "--generate-includes=[ROOT]"
    desc  "Generates includes.js file that you may use for ad-hoc requiring" <<
          "of the needed javascripts. Defaults to output_directory."
  end

  option "benchmark", :required => false do
    long "--benchmark"
    short "-b"
    desc "Performs a benchmark, indicating how much time you needed to" <<
         "compile the package"
  end

  option "docs_classes", :required => false do
    default []
    long "--generate-docs *CLASSES"
    desc "Generate documentation for classes via murdoc. You need to use FULL PATHS, e.g.: " <<
         "/mootools/*, /LSD/*, /**/*"

  end

  option "no_syntax_highlight", :required => false do
    default false
    long "--no-syntax-highlight"
    desc "Disable syntax highlighting in murdoc. Greatly increases docs generation speed. " <<
         "Note: This option won't have any effect unless you have Pygments installed."
  end

  option "verbose", :required => false do
    default false
    short "-v"
    long "--verbose"
    desc "When verbose mode is enabled, some debug information is displayed. Defaults to false."
  end

  option "validate_with", :required => false do
    default []
    long "--validate-with *VALIDATORS"
    desc "performs validation of the resulting source. " <<
         "Available validators: mooforge"
  end
end

compile_start_time = Time.now

Jsus.verbose = Choice.choices[:verbose]

pool_load_start_time = Time.now
pool = if Choice.choices[:dependencies]
  Jsus::Pool.new(Choice.choices[:dependencies])
else
  Jsus::Pool.new
end
pool_load_finish_time = Time.now

package = Jsus::Package.new(Choice.choices[:input_directory], :pool => pool)
package.include_dependencies! if Choice.choices[:dependencies]
output_directory = Choice.choices[:output_directory]
package.compile(output_directory)
package.generate_scripts_info(output_directory) unless Choice.choices[:without_scripts_info]
package.generate_tree(output_directory) unless Choice.choices[:without_tree]

# Validations
validators_map = {"mooforge" => Jsus::Validator::Mooforge}
Choice.choices[:validate_with].each do |validator_name|
  if validator = validators_map[validator_name.downcase]
    errors = validator.new(pool.sources.to_a & package.source_files.to_a).validation_errors
    unless errors.empty?
      puts "Validator found errors: "
      errors.each {|e| puts "  * #{e}"}
    end
  else
    puts "No such validator: #{validator_name}"
  end
end

# Hack, hack, hack :[
if Choice.choices[:generate_includes]
  root = Choice.choices[:generate_includes] == true ? Choice.choices[:output_directory] : Choice.choices[:generate_includes]
  File.open(File.join(Choice.choices[:output_directory], "includes.js"), "w") do |f|
    c = Jsus::Container.new(*(package.source_files.to_a + package.linked_external_dependencies.to_a))
    script = %{(function(prefix) {
      var sources = %sources%;
      for (var i = 0, j = sources.length; i < j; i++) document.write('<scr' + 'ipt src="' + (prefix || '') + sources[i] + '"></script>');
    })(window.prefix);}.sub("%sources%", JSON.pretty_generate(c.required_files(root)))
    f.puts script
  end
end

# Generate documentation
unless Choice.choices[:docs_classes].empty?  
  documenter = Jsus::Documenter.new(:highlight_source => !Choice.choices[:no_syntax_highlight])
  package.source_files.each {|source| documenter << source }
  pool.sources.each {|source| documenter << source } if pool
  documenter.only(Choice.choices[:docs_classes]).generate(Choice.choices[:output_directory] + "/docs")
end


finish_time = Time.now


if Choice.choices[:benchmark]
  puts "Benchmarking results:"
  puts "Total execution time:   #{format("%.3f" ,finish_time - start_time)}s"
  puts ""
  puts "Of them:"
  puts "Pool preloading time:   #{format("%.3f", pool_load_finish_time - pool_load_start_time)}s"
  puts "Total compilation time: #{format("%.3f", finish_time - compile_start_time - (pool_load_finish_time - pool_load_start_time))}s"
end