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

require 'pwn'
require 'json'
require 'optparse'

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

  options.on('-aPROFILE', '--assume-profile=PROFILE', '<Required if "--target-freq" is Nil - Profile to assume for common radio protocols.  Use "--list-profiles" to display supported protocols (Defaults to nil)') do |p|
    opts[:profile] = p
  end

  options.on('-l', '--list-profiles', '<Optional - List supported profiles and exit>') do |l|
    opts[:list_profiles] = l
  end

  options.on('-tFREQ', '--target-freq=FREQ', '<Required if "--assume-profile" is Nil - Frequency to Conclude Scanning (e.g. 900.000.000 == 900 mHz>') do |e|
    opts[:target_freq] = e
  end

  options.on('-sFREQ', '--start-freq=FREQ', '<Optional - Frequency to Set when Scanning Begins (Defaults to last known frequency)>') do |s|
    opts[:start_freq] = s
  end

  options.on('-hHOST', '--host=HOST', '<Optional - GQRX Host (Defaults to 127.0.0.1)>') do |h|
    opts[:host] = h
  end

  options.on('-pPORT', '--port=PORT', '<Optional - GQRX Port (Defaults to 7356)>') do |p|
    opts[:port] = p
  end

  options.on('-AFLOAT', '--audio-gain=FLOAT', '<Optional - Set audio gain -80.0 to 50.0 (Defaults to 1.0)>') do |a|
    opts[:audio_gain_db] = a
  end

  options.on('-bHZ', '--bandwidth=HZ', '<Optional - Set Bandwidth 0.0 - SDR Bandwidth Limit, e.g. 20.000.000 (Defaults to 270.000)>') do |b|
    opts[:bandwidth] = b
  end

  options.on('-DMODE', '--demodulator-mode=MODE', '<Optional - Set Demodulator Mode OFF | RAW | AM | FM | WFM | WFM_ST | WFM_ST_OIRT | LSB | USB | CW | CWL | CWU (Defaults to WFM_ST)>') do |d|
    opts[:demodulator_mode] = d
  end

  options.on('-PINT', '--precision=INT', '<Optional - Precision of Frequency 1-12 (Defaults to 5)>') do |p|
    opts[:precision] = p
  end

  options.on('-SFLOAT', '--strength-lock=FLOAT', '<Optional - Strength to lock onto frequency (Defaults to -45.0)>') do |s|
    opts[:strength_lock] = s
  end

  options.on('-LFLOAT', '--lock-freq-duration=FLOAT', '<Optional - Duration to lock onto Freqency when Strength < --strength-lock value (Defaults to 0.5)>') do |l|
    opts[:lock_freq_duration] = l
  end

  options.on('-QFLOAT', '--squelch=FLOAT', '<Optional - Squelch Threshold -150.0 to 0 (Defaults to -50.0)>') do |q|
    opts[:squelch] = q
  end

  options.on('-RFLOAT', '--rf-gain=FLOAT', '<Optional - RF Gain 0.0-16.0(Defaults to 16.0)>') do |r|
    opts[:rf_gain] = r
  end

  options.on('-IFLOAT', '--intermediate-gain=FLOAT', '<Optional - Intermediate Gain 0.0-40.0 (Defaults to 40.0)>') do |i|
    opts[:intermediate_gain] = i
  end

  options.on('-BFLOAT', '--basedband-gain=FLOAT', '<Optional - Baseband Gain 0.0-62.0 (Defaults to 10.0)>') do |b|
    opts[:baseband_gain] = b
  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' }

  list_profiles = opts[:list_profiles]
  if list_profiles
    profiles_available = PWN::Plugins::GQRX.list_profiles
    puts JSON.pretty_generate(profiles_available)
    exit 0
  end

  profile = opts[:profile]
  opts = PWN::Plugins::GQRX.assume_profile(profile: profile) unless profile.nil?

  target_freq = opts[:target_freq]
  target_freq = target_freq.to_s.delete('.') unless target_freq.nil?
  target_freq = target_freq.to_i
  raise 'ERROR: --assume-profile || --target-freq is required.' if target_freq.zero? && profile.nil?

  host = opts[:host]
  port = opts[:port]

  puts "Connecting to GQRX at #{host}:#{port}..."
  gqrx_sock = PWN::Plugins::GQRX.connect(target: host, port: port)

  start_freq = opts[:start_freq]
  start_freq = start_freq.to_s.delete('.') unless start_freq.nil?
  start_freq = start_freq.to_i
  if start_freq.zero?
    start_freq = PWN::Plugins::GQRX.gqrx_cmd(
      gqrx_sock: gqrx_sock, cmd: 'f',
      resp_ok: 'RPRT 0'
    ).to_i
  end

  demodulator_mode = opts[:demodulator_mode] ||= 'WFM_ST'
  puts "Demodulator Mode: #{demodulator_mode}"
  # demodulator_mode.upcase! if opts[:demodulator_mode]
  demodulator_modes = %i[OFF RAW AM FM WFM WFM_ST WFM_ST_OIRT LSB USB CW CWL CWU]
  raise "ERROR: Invalid demodulator mode: #{demodulator_mode}" unless demodulator_modes.include?(demodulator_mode)

  bandwidth = opts[:bandwidth] ||= '200.000'

  puts "Setting demodulator mode to #{demodulator_mode} and bandwidth to #{bandwidth}..."
  bandwidth = bandwidth.to_s.delete('.').to_i unless bandwidth.nil?
  demod_resp = PWN::Plugins::GQRX.gqrx_cmd(
    gqrx_sock: gqrx_sock,
    cmd: "M #{demodulator_mode} #{bandwidth}",
    resp_ok: 'RPRT 0'
  )

  audio_gain_db = opts[:audio_gain_db] ||= 1.0
  audio_gain_db = audio_gain_db.to_f
  audio_gain_db_resp = PWN::Plugins::GQRX.gqrx_cmd(
    gqrx_sock: gqrx_sock,
    cmd: "L AF #{audio_gain_db}",
    resp_ok: 'RPRT 0'
  )

  squelch = opts[:squelch] ||= -63.0
  squelch = squelch.to_f
  squelch_resp = PWN::Plugins::GQRX.gqrx_cmd(
    gqrx_sock: gqrx_sock,
    cmd: "L SQL #{squelch}",
    resp_ok: 'RPRT 0'
  )

  precision = opts[:precision] ||= 5
  precision = precision.to_i
  raise "ERROR: Invalid precision: #{precision}" unless (1..12).include?(precision)

  lock_freq_duration = opts[:lock_freq_duration] ||= 0.5
  lock_freq_duration = lock_freq_duration.to_f

  strength_lock = opts[:strength_lock] ||= -60.0
  strength_lock = strength_lock.to_f

  rf_gain = opts[:rf_gain] ||= 0.0
  rf_gain = rf_gain.to_f
  rf_gain_resp = PWN::Plugins::GQRX.gqrx_cmd(
    gqrx_sock: gqrx_sock,
    cmd: "L RF_GAIN #{rf_gain}",
    resp_ok: 'RPRT 0'
  )

  intermediate_gain = opts[:intermediate_gain] ||= 32.0
  intermediate_gain = intermediate_gain.to_f
  intermediate_resp = PWN::Plugins::GQRX.gqrx_cmd(
    gqrx_sock: gqrx_sock,
    cmd: "L IF_GAIN #{intermediate_gain}",
    resp_ok: 'RPRT 0'
  )

  baseband_gain = opts[:baseband_gain] ||= 10.0
  baseband_gain = baseband_gain.to_f
  baseband_resp = PWN::Plugins::GQRX.gqrx_cmd(
    gqrx_sock: gqrx_sock,
    cmd: "L BB_GAIN #{baseband_gain}",
    resp_ok: 'RPRT 0'
  )

  s_freq_pretty = start_freq.to_s.chars.insert(-4, '.').insert(-8, '.').join
  t_freq_pretty = target_freq.to_s.chars.insert(-4, '.').insert(-8, '.').join
  puts "*** Scanning from #{s_freq_pretty} to #{t_freq_pretty}\n\n\n"

  PWN::Plugins::GQRX.scan_range(
    gqrx_sock: gqrx_sock,
    demodulator_mode: demodulator_mode,
    bandwidth: bandwidth,
    start_freq: start_freq,
    target_freq: target_freq,
    precision: precision,
    lock_freq_duration: lock_freq_duration,
    strength_lock: strength_lock,
    squelch: squelch
  )
  puts 'Scan Complete.'
rescue StandardError => e
  raise e
rescue Interrupt, SystemExit
  puts "\nGoodbye."
ensure
  gqrx_sock = PWN::Plugins::GQRX.disconnect(gqrx_sock: gqrx_sock) unless gqrx_sock.nil?
end