#!/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

# 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 running inside an application workspace
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')

  # 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
  
  boot_app = true

# If running outside an application and a user or central tool Origen bundle is to be used
elsif Origen.site_config.gem_manage_bundler && (Origen.site_config.user_install_enable || Origen.site_config.tool_repo_install_dir)
  # Force everyone to have a consistent way of installing gems with bundler.
  # In this case, we aren't running from an Origen application, so build everything at Origen.home instead
  # Have two options here: if user_install_enable is true, use user_install_dir. Otherwise, use the tool_repo_install_dir
  Origen.site_config.user_install_enable ? origen_root = File.expand_path(Origen.site_config.user_install_dir) : origen_root = File.expand_path(Origen.site_config.tool_repo_install_dir)
  unless Dir.exists?(origen_root)
    load File.expand_path('../../lib/origen/utility/input_capture.rb', __FILE__)
    include Origen::Utility::InputCapture
    
    puts "Root directory '#{origen_root}' does not exist. Would you like to create it?"
    if get_text(confirm: :return_boolean)
      FileUtils.mkdir(origen_root)
    else
      puts "Exiting with creating Origen install"
      exit!
    end
  end
  
  gemfile = File.join(origen_root, 'Gemfile')
  unless File.exists?(gemfile)
    # Create a default Gemfile that can be further customized by the user.
    # Initial Gemfile only requires Origen. Nothing else. Essentially a blank installation.
    Dir.chdir(origen_root) do
      `bundle init`
    end
    # The above will give a general Gemfile from Bundler. We'll just append "gem 'origen' to the end.
    File.open(gemfile, 'a') do |f|
     f << "gem 'origen'\n"
    end
  end
  ENV['BUNDLE_GEMFILE'] = gemfile
  ENV['BUNDLE_PATH'] = File.expand_path(Origen.site_config.gem_install_dir)
  ENV['BUNDLE_BIN'] = File.join(origen_root, 'lbin')

  origen_exec = File.join(ENV['BUNDLE_BIN'], 'origen')

  # If the user/tool bundle already exists but we have not been invoked through that, abort this thread
  # and re-launch under the required bundler environment
  if File.exist?(origen_exec) && !ENV['BUNDLE_BIN_PATH'] && File.exist?(ENV['BUNDLE_PATH'])
    exec Gem.ruby, origen_exec, *ARGV
    exit 0
  else
    boot_app = false
  end
end

if origen_root && File.exist?(ENV['BUNDLE_GEMFILE']) && Origen.site_config.gem_manage_bundler && (boot_app || Origen.site_config.user_install_enable || Origen.site_config.tool_repo_install_dir)
  # 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
          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
          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'
  if Origen.site_config.use_bootsnap && !Origen.os.windows?
    puts 'Gettin bootsnappy up in here!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
    ENV["BOOTSNAP_CACHE_DIR"] ||= "#{origen_root}/tmp/cache"
    require 'bootsnap/setup'
  else
    puts 'NOT SO SNAPPY'
  end
  require 'origen'
else
  $LOAD_PATH.unshift "#{File.expand_path(File.dirname(__FILE__))}/../lib"
  require 'origen'
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 && boot_app
    require 'origen/commands'
  else
    require 'origen/commands_global'
  end
rescue Exception => e
  # A formatted stack dump will not be printed if the application ends via 'exit 0' or 'exit 1'. In that
  # case the application code is responsible for printing a helpful error message.
  # This will intercept all other exits, e.g. via 'fail "Something has done wrong"', and split the stack
  # dump to separate all in-application references from Origen core/plugin references.
  if e.is_a?(SystemExit)
    exit e.status
  else
    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