$LOAD_PATH.unshift('./lib/')

require 'consolr/version'
require 'collins_auth'
require 'optparse'
require 'yaml'


module Consolr
  class Console

    attr_reader :ipmitool_exec, :dangerous_assets, :dangerous_status, :dangerous_actions, :options, :opt_parser

    def initialize
      potential_config_paths = [ENV['CONSOLR_CONFIG'],
                                '~/.consolr.yml', '~/.consolr.yaml',
                                '/etc/consolr.yml', '/etc/consolr.yaml',
                                '/var/db/consolr.yml', '/var/db/consolr.yaml']
      config_file = potential_config_paths.compact.find do |conf|
        begin
          expanded_path = File.expand_path(conf, __FILE__)
          File.readable?(expanded_path) and File.size(expanded_path) > 0
        rescue ArgumentError
          # if $HOME is not set, or if `~` cannot be expanded, `expand_path` will throw and ArgumentError
          # in that case, just go to the next potential config file - this one obviously will not work
          false
        end
      end

      @config_params = begin
        YAML.load(File.open(File.expand_path(config_file, __FILE__)))
      rescue TypeError => e
        puts "-------"
        puts "Failed to load Configuration File ... "
        puts "Looks like a configuration file doesn't exist."
        puts "Please look at README.md on creating a configuration file"
        puts "-------"
        exit 1
      rescue ArgumentError => e
        puts "------"
        puts "Failed to load Configuration File ... "
        puts "Looks like the configuration file is not correctly formatted"
        puts "Please check if your file conforms to YAML spec"
        puts "------"
        exit 1
      end
      #
      # Will be ignored for dangerous actions, no matter what, even with --force
      begin
        @dangerous_assets = @config_params['dangerous_assets']
      rescue Exception => e
        puts e
        puts "-------"
        puts "Dangerous Assets -- #{dangrous}"
        puts "Please make sure dangerous_assets exists and is valid."
        puts "Supply them in a comma separated list."
      end

      # Dangerous actions wont be run in these status, override with --force
      begin
        @dangerous_status = @config_params['dangerous_status']
      rescue Exception => e
        puts e
        puts "-------"
        puts "Dangerous Status -- #{@dangeous_status}"
        puts "Please specify the statuses which are dangerorous, during which dangerous shouldn't be run."
        puts "-------"
        exit 1
      end

      @dangerous_actions = [:off, :reboot] # Must match the symbol in options{}
    end

    def start options
      abort("Please pass either the asset tag or hostname") if options[:tag].nil? and options[:hostname].nil?

      dangerous_body = "Dangerous actions: #{dangerous_actions.join(', ')}\n"\
        "Dangerous status: #{dangerous_status.join(', ')} (override with --force)\n"\
        "Dangerous assets: #{dangerous_assets.join(', ')} (ignored no matter what, even with --force)"

      if options[:dangerous]
        puts dangerous_body
        exit 1
      end

      begin
        collins = Collins::Authenticator.setup_client
      rescue Exception => e
        puts e
        puts "-------"
        puts "There was a problem setting up a connection with Collins."
        puts "-------"
        exit 1
      end

      if options[:tag] and options[:hostname]
        abort("Please pass either the hostname OR the tag but not both.")
      end

      if options[:runner].nil?
        runners = load_runners(@config_params.fetch('runners', []))
        # Default to the ipmitool runner for backwards compatibility
        if runners.empty?
          require 'consolr/runners/ipmitool'
          runners = [Consolr::Runners::Ipmitool.new(@config_params.fetch('ipmitool', {}))]
        end
      else
        runners = load_runners([options[:runner]])
        if runners.empty?
          abort('Specified runner could not be loaded. Aborting.')
        end
      end

      # match assets like vm-67f5eh, zt-*, etc.
      nodes = options[:tag] ? (collins.find :tag => options[:tag]) : (collins.find :hostname => options[:hostname])
      @node = nodes.length == 1 ? nodes.first : abort("Found #{nodes.length} assets, aborting.")

      # select the first runner that support the node
      runner = runners.select {|runner|
        runner.can_run? @node
      }.first

      if runner.nil?
        abort("No runners available for node #{@node.hostname} (#{@node.tag})")
      end

      if not runner.verify @node
        abort("Cannot verify asset #{@node.hostname} (#{@node.tag})")
      end

      selected_dangerous_actions = dangerous_actions.select { |o| options[o] }
      if dangerous_assets.include?(@node.tag) and selected_dangerous_actions.any?
        abort "Asset #{@node.tag} is a crucial asset. Can't ever execute dangerous actions on this asset.\n#{dangerous_body}"
      end

      if options[:force].nil? and selected_dangerous_actions.any? and dangerous_status.include?(@node.status)
        abort "Cannot run dangerous commands on #{@node.hostname} (#{@node.tag} - #{@node.status}) because it is in a protected status. This can be overridden with the --force flag\n#{dangerous_body}"
      end

      case
      when options[:console]
        puts '--> Opening SOL session (type ~~. to quit)'
        puts runner.console @node
      when options[:kick]
        puts runner.kick @node
      when options[:identify]
        puts runner.identify @node
      when options[:sdr]
        puts runner.sdr @node
      when options[:log] == 'list'
        puts runner.log_list @node
      when options[:log] == 'clear'
        puts runner.log_clear @node
      when options[:on]
        puts runner.on @node
      when options[:off]
        puts runner.off @node
      when options[:soft_off]
        puts runner.soft_off @node
      when options[:reboot]
        puts runner.reboot @node
      when options[:soft_reboot]
        puts runner.soft_reboot @node
      when options[:status]
        puts runner.status @node
      when options[:sensors]
        puts runner.sensors @node
      when options[:get_sol_info]
        puts runner.sol_info @node
      else
        begin
          puts "specify an action"
          exit 1
        end
      end
    end

    private
    def load_runners runners
      runners.map {|runner|
        begin
          require "consolr/runners/#{runner}"
          Consolr::Runners.const_get(runner.capitalize).new @config_params.fetch(runner, {})
        rescue NameError, LoadError => e
          puts "Could not load runner #{runner.capitalize}, skipping."
        end
      }.compact
    end
  end
end