module Onering
  module CLI
    class Report < Plugin
      DEFAULT_CACHE_MAXAGE=600

      def self.configure(global={})
        @global_opts = global
        @api = Onering::CLI.connect(@global_opts.merge({
          :autoconnect => false
        }))

        @opts = ::Trollop::options do
          banner <<-EOS
Generate a system report that can be saved or submitted to a Onering server

Subcommands:
    <none>
      Generate and output the system inventory report.

    get  <property> [fallback]
      Get a specific <property> from the report, return [fallback] if not found.

    save
      Generate and save the system inventory report to Onering.

Usage:
    onering [global] report [options] [subcommands]

Options:
EOS
          opt :id,             "Override the autodetected Hardware ID for this node", :short => '-I', :type => :string
          opt :fields,         "Set the named FIELD to equal VALUE in the format FIELD=VALUE. Can be specified multiple times", :short => '-o', :type => :string, :multi => true
          opt :save,           "Save the report output to the configured Onering server"
          opt :timeout,        "The maximum amount of time to wait for a report to be generated", :type => :integer, :default => 60
          opt :plugin_timeout, "The maximum amount of time to wait for a report plugin to return data", :type => :integer, :default => 10
          opt :local,          "Do not attempt to contact a remote server for retrieving values not found locally", :type => :boolean, :default => false
          opt :cachefile,      "Use the specified file as a local report cache", :type => :string, :short => '-F'
          opt :nocache,        "Do not attempt to use a cache file for report generation", :type => :boolean, :default => false
          opt :maxage,         "Maxmimum age (in seconds) of the cache before it is automatically regenerated", :type => :integer, :default => DEFAULT_CACHE_MAXAGE

          stop_on %w{get save}
        end

      # initialize report generator with user options
        @_reporter = Onering::Reporter.new({
          :id             => @opts[:id],
          :timeout        => @opts[:timeout],
          :plugin_timeout => @opts[:plugin_timeout],
          :nocache        => @opts[:nocache],
          :cachefile      => @opts[:cachefile],
          :maxage         => @opts[:maxage]
        }.compact)
      end

      def self.run(args)
      # saving, by default, should not use the cache (but should update it to keep it fresh)
        if @opts[:save] === true or args[0] == 'save'
          report = _report({
            :cacheregen => true
          })
        else
          report = _report()
        end
        
      # pull overrides from CLI arguments
        @opts[:fields].each do |field|
          key, value = field.split('=', 2)
          Onering::Logger.debug("Override value #{key} from command line argument", "Onering::CLI::Report")

          value = nil if ['null', '', '-'].include?(value.to_s.strip.chomp)
          report = report.set(key, value)
        end

      # save if specified
        if @opts[:save] === true
          _save(report)

        else
          sc = args.shift

          case (sc.downcase.to_sym rescue nil)
  # -----------------------------------------------------------------------------
          when :save
            _save(report)
            return nil

          when :get
            Onering::Logger.fatal!("Expected at least 1 parameter, got #{args.length}", "Onering::CLI::Report") unless args.length >= 1
            return @_reporter.get(args[0], args[1], {
              :data  => report,
              :api   => @global_opts,
              :local => @opts[:local]
            })
          end
        end

        return report
      end

    private
      def self._save(report)
        @api.connect()
        @api.assets.save(report['id']) do
          MultiJson.dump(report)
        end
      end

      def self._report(options={})
        begin
          Onering::Logger.debug("Gathering local data for report", "Onering::CLI::Report")
          Onering::Logger.fatal("Reporter not configured. This is a bug", "Onering::CLI::Report") if @_reporter.nil?
          report = @_reporter.report(options).stringify_keys()

          return report
        rescue Timeout::Error
          Onering::Logger.fatal!("Report took too long to generate, exiting...", "Onering::CLI::Report")
        end
      end
    end
  end
end