#!/usr/bin/env ruby
# frozen_string_literal: false

require 'optparse'
require 'pwn'
require 'yaml'

opts = {}
OptionParser.new do |options|
  options.banner = "USAGE:
    #{$PROGRAM_NAME} [opts]
  "

  options.on('-cCONFIG', '--config=CONFIG', '<Required - Black Duck Binary Analysis YAML config>') do |c|
    opts[:config] = c
  end

  options.on('-CGROUP', '--create=GROUP', '<Optional - Group/Sub-Group to Create>') do |g|
    opts[:group_name] = g
  end

  options.on('-lNAME', '--list-group=NAME', '<Optional - List Group Details>') do |l|
    opts[:list_group_name] = l
  end

  options.on('-pPNAME', '--parent-group=PNAME', '<Optional - Black Duck Binary Analysis Parent Group Name to Associate with Group>') do |p|
    opts[:parent_group_name] = p
  end
end.parse!

if opts.empty?
  puts `#{$PROGRAM_NAME} --help`
  exit 1
end

begin
  pwn_provider = 'ruby-gem'
  pwn_provider = ENV.fetch('PWN_PROVIDER') if ENV.keys.any? { |s| s == 'PWN_PROVIDER' }

  config = opts[:config]
  raise "ERROR: BDBA YAML Config File Not Found: #{config}" unless File.exist?(config)

  yaml_config = YAML.load_file(config, symbolize_names: true)

  token = yaml_config[:token]
  raise "ERROR: BDBA Token Not Found: #{token}" if token.nil?

  list_group_name = opts[:list_group_name]
  parent_group_name = opts[:parent_group_name]
  parent_id = nil

  if list_group_name || parent_group_name
    groups_resp = PWN::Plugins::BlackDuckBinaryAnalysis.get_groups(
      token: token
    )

    raise 'No groups found in BDBA.  Use the --create flag to create your first group.' if groups_resp.nil?

    list_or_parent = list_group_name unless list_group_name.nil?
    list_or_parent = parent_group_name unless parent_group_name.nil?

    group_arr = groups_resp[:groups].select { |g| g[:name] == list_or_parent }

    if list_group_name && group_arr.empty?
      puts 'BDBA Group Not Found.'
      exit 1
    end

    group_arr_sorted = group_arr.sort_by { |g| g[:id] }
    if group_arr_sorted.length > 1
      dup_groups_arr = []
      group_arr_sorted.each do |group|
        this_group_id = group[:id]
        this_group_details = PWN::Plugins::BlackDuckBinaryAnalysis.get_group_details(
          token: token,
          group_id: this_group_id
        )
        dup_groups_arr.push(this_group_details[:group])
      end

      puts "ERROR: Multiple BDBA Groups Found:\n#{dup_groups_arr}"
      exit 1
    end

    group = group_arr_sorted.last
    parent_id = group[:id]

    if list_group_name
      group_id = parent_id
      group_details_resp = PWN::Plugins::BlackDuckBinaryAnalysis.get_group_details(
        token: token,
        group_id: group_id
      )
      puts group_details_resp.to_json
      exit 0
    end
  end

  group_name = opts[:group_name]
  raise "ERROR: BDBA Group Name Not Provided: #{group_name}" if group_name.nil?

  create_group_resp = PWN::Plugins::BlackDuckBinaryAnalysis.create_group(
    token: token,
    name: group_name,
    parent_id: parent_id
  )

  puts create_group_resp.to_json
rescue SystemExit, Interrupt
  puts "\nGoodbye."
rescue StandardError => e
  raise e
end