#!/usr/bin/env ruby
$VERBOSE = nil  # Don't care about world writable dir warnings and the like

require 'pathname'
require 'fileutils'
#require 'byebug' # Un-comment to debug this file

class OrigenBootError < StandardError
end

ORIGEN_MIN_GCC_VERSION = '4.6.3'

# Keep a note of the pwd at the time when Origen was first loaded, this is initially used
# by the site_config lookup.
$_origen_invocation_pwd ||= Pathname.pwd

load File.expand_path('../../lib/origen/operating_systems.rb', __FILE__)
load File.expand_path('../../lib/origen/site_config.rb', __FILE__)

# This will be referenced later in ruby_version_check, the origen used to launch
# the process is different than the one that actually runs under bundler
$origen_launch_root = Pathname.new(File.dirname(__FILE__)).parent

# Override any influence from $LANG in the users environment
Encoding.default_external = Encoding::UTF_8
Encoding.default_internal = Encoding::UTF_8
ENV['LC_ALL'] = nil
ENV['LANG'] = nil
ENV['LANG'] = 'en_US.UTF-8'

# Work out what Origen.root is if we are running inside an Origen application, this will be
# later used to execute from that app's bundle even if the origen executable lives somewhere
# else (e.g. in the tools repository)
app_config = File.join('config', 'application.rb')
if File.exist?(app_config)
  origen_root = Dir.pwd
else
  path = Pathname.new(Dir.pwd)
  until path.root? || origen_root
    if File.exist?(File.join(path, app_config))
      origen_root = path.to_s
    else
      path = path.parent
    end
  end
end

if origen_root
  # Force everyone to have a consistent way of installing gems with bundler
  ENV['BUNDLE_GEMFILE'] = File.join(origen_root, 'Gemfile')
  ENV['BUNDLE_PATH'] = File.expand_path(Origen.site_config.gem_install_dir)
  ENV['BUNDLE_BIN'] = File.join(origen_root, 'lbin')

  # Ensure that system gems are copied to the local gem dir every time, this might waste a little bit
  # of time, but it ensures that any updates to the system gem list are automatically applied which
  # is helpful in a corporate environment with no sudo access to the Ruby installation
  #
  # This is invoked from an external process so that it can step out of this bundled environment
  # and have visibility of the system gems
  if Origen.site_config.gem_manage_bundler && Origen.site_config.gem_use_from_system
    exe = File.expand_path('../copy_system_gems', __FILE__)
    gems = Origen.site_config.gem_use_from_system.map { |g,v| "#{g} #{v}" }.join(' ')
    local_gem_dir = "#{ENV['BUNDLE_PATH']}/ruby/#{Pathname.new(Gem.dir).basename}"
    Bundler.with_clean_env do
      system "#{exe} #{local_gem_dir} #{gems}"
    end
  end

  # If it looks like a bundled binstub of origen exists, and we have not been invoked through that,
  # then run that instead.
  if Origen.site_config.gem_manage_bundler && File.exist?("#{origen_root}/lbin/origen") && !ENV['BUNDLE_BIN_PATH'] &&
     File.exist?(File.expand_path(Origen.site_config.gem_install_dir))
    exec Gem.ruby, "#{origen_root}/lbin/origen", *ARGV
    exit 0
  end
end

if origen_root && File.exist?(ENV['BUNDLE_GEMFILE']) && Origen.site_config.gem_manage_bundler
  # Overriding bundler here so that bundle install can be automated as required
  require 'bundler/shared_helpers'
  if Bundler::SharedHelpers.in_bundle?
    require 'bundler'
    if STDOUT.tty?
      begin
        fail OrigenBootError unless File.exist?(ENV['BUNDLE_BIN'])
        Bundler.setup
        fail OrigenBootError unless File.exist?(ENV['BUNDLE_BIN'])
      rescue Gem::LoadError, Bundler::BundlerError, OrigenBootError => e
        cmd = "bundle install --gemfile #{ENV['BUNDLE_GEMFILE']} --binstubs #{ENV['BUNDLE_BIN']} --path #{ENV['BUNDLE_PATH']}"
        # puts cmd
        puts 'Installing required gems...'
        puts
        `chmod o-w #{origen_root}` # Stops some annoying world writable warnings during install
        `chmod o-w #{origen_root}/bin` if File.exist?("#{origen_root}/bin")
        `chmod o-w #{origen_root}/.bin` if File.exist?("#{origen_root}/.bin")
        result = false

        Bundler.with_clean_env do
          if Origen.os.unix?
            if Origen.site_config.gem_build_switches
              Origen.site_config.gem_build_switches.each do |switches|
                `bundle config build.#{switches}`
              end
            end
            gcc_version = begin
              begin
                line = `gcc --version`.split("\n").first
              rescue
                puts "You don't seem to have gcc available, make sure you following the Origen installation instructions:"
                puts 'http://origen-sdk.org/origen/latest/guides/starting/installing/'
                exit 1
              end
              if line =~ /(\d+\.\d+\.\d+)/
                Regexp.last_match(1)
              end
            end
            if gcc_version
              if gcc_version < ORIGEN_MIN_GCC_VERSION
                puts "Origen requires a minimum of GCC version #{ORIGEN_MIN_GCC_VERSION}, but you have #{gcc_version}."
                exit 1
              end
            else
              puts 'Unable to determine gcc version, proceeding with fingers crossed...'
            end
          end
          result = system(cmd)
        end
        `chmod o-w #{ENV['BUNDLE_BIN']}`
        # Make .bat versions of all executables, Bundler should really be doing this when running
        # on windows
        if Origen.os.windows?
          bat_present = File.exist? "#{origen_root}/lbin/origen.bat"
          Dir.glob("#{origen_root}/lbin/*").each do |bin|
            unless bin =~ /.bat$/
              bat = "#{bin}.bat"
              unless File.exist?(bat)
                File.open(bat, 'w') { |f| f.write('@"ruby.exe" "%~dpn0" %*') }
              end
            end
          end
          if !bat_present && !result
            puts 'Some Windows specific updates to your workspace were required, please re-run the last command'
            exit 0
          end
        end
        if result
          # This is a shim to help NXP run regression tests between an old version of an app running
          # RGen and a new version running Origen
          origen = File.join(ENV['BUNDLE_BIN'], 'origen')
          rgen = File.join(ENV['BUNDLE_BIN'], 'rgen')
          if File.exist?(rgen) && !File.exist?(origen) && Origen.os.linux?
            exec "ln -s #{rgen} #{origen}"
          end
          exec "origen #{ARGV.join(' ')}"
          exit 0
        else
          puts
          puts "If you have just updated a gem version and are now getting an error that Bundler cannot find compatible versions for it then first try running 'bundle update <gemname>'."
          puts "For example if you have just changed the version of origen_core run 'bundle update origen_core'."
          exit 1
        end
      end
    else
      Bundler.setup
    end
  end
  require 'bundler/setup'
  require 'origen'
else
  $LOAD_PATH.unshift "#{File.expand_path(File.dirname(__FILE__))}/../lib"
  require 'origen'
end

# This is a shim to help NXP run regression tests between an old version of an app running
# RGen and a new version running Origen
# If RGen < 3 is present then abort the process here and execute the rgen bin file instead
begin
  require 'rgen'
  if RGen.version.major == 2
    exec Gem.ruby, "#{RGen.top}/bin/rgen", *ARGV
    exit 0
  end
rescue LoadError
  # No problem, RGen not present
end

begin
  # If this script has been invoked from within an Origen application then open
  # up all commands, if not then only allow the command to create a new Origen
  # application.
  if origen_root
    require 'origen/commands'
  else
    require 'origen/commands_global'
  end
rescue Exception => e
  unless e.is_a?(SystemExit) && e.status == 0
    puts
    if Origen.app_loaded?
      puts 'COMPLETE CALL STACK'
      puts '-------------------'
      puts e.message unless e.is_a?(SystemExit)
      puts e.backtrace

      puts
      puts 'APPLICATION CALL STACK'
      puts '----------------------'
      puts e.message unless e.is_a?(SystemExit)
      # Only print out the application stack trace by default, if verbose logging is
      # enabled then output the full thing
      e.backtrace.each do |line|
        path = Pathname.new(line)
        if path.absolute?
          if line =~ /^#{Origen.root}/ && line !~ /^#{Origen.root}\/lbin/
            puts line
          end
        else
          puts line unless line =~ /^.\/lbin/
        end
      end
    else
      puts 'COMPLETE CALL STACK'
      puts '-------------------'
      puts e.message unless e.is_a?(SystemExit)
      puts e.backtrace
    end
    exit 1
  end
ensure
  if Origen.app_loaded?
    Origen.app.listeners_for(:on_origen_shutdown).each(&:on_origen_shutdown)
    Origen.app.runner.shutdown
  end
end