class Govau

# File plugins/govau.rb, line 115
def self.command_error
  { error: usage_message }
end

# File plugins/govau.rb, line 27
def self.command_pattern
  /govau(?:\s+(.+))?$/i
end

# File plugins/govau.rb, line 141
def self.dispatch_command(args_text, user: nil, ckan_fetch: nil, ptv_fetch: nil, tfnsw_fetch: nil, devid: nil, key: nil, tfnsw_key: nil, time: Time.now, store: Game.default_store, network: nil, channel: nil, db_store: RabbotDb)
  parsed = parse_command(args_text)
  return { error: parsed[:error] } if parsed[:error]
  return { reply: help_reply } if parsed[:action] == :help

  creds = GovauConfig.ptv_credentials(devid: devid, key: key)
  tfnsw_creds = GovauConfig.tfnsw_credentials(api_key: tfnsw_key)

  case parsed[:action]
  when :search
    results = GovauCkan.search_datasets(parsed[:query], fetch: ckan_fetch)
    { reply: GovauCkan.format_search(parsed[:query], results) }
  when :dataset
    row = GovauCkan.fetch_dataset(parsed[:name], fetch: ckan_fetch)
    { reply: GovauCkan.format_dataset(row, name: parsed[:name]) }
  when :station
    return { error: PTV_SETUP_HINT } unless GovauConfig.ptv_configured?(**creds)

    stops = GovauPtv.search_stops(parsed[:query], devid: creds[:devid], key: creds[:key], fetch: ptv_fetch)
    { reply: GovauPtv.format_stations(parsed[:query], stops) }
  when :routes
    return { error: PTV_SETUP_HINT } unless GovauConfig.ptv_configured?(**creds)

    rows = GovauRoutes.fetch_routes(devid: creds[:devid], key: creds[:key], fetch: ptv_fetch)
    { reply: GovauRoutes.format_routes(rows) }
  when :status
    ptv_check = if GovauConfig.ptv_configured?(**creds)
                  GovauStatus.check_ptv(devid: creds[:devid], key: creds[:key], fetch: ptv_fetch)
                else
                  { ready: false, detail: "credentials not set" }
                end
    {
      reply: GovauStatus.format_status(
        ptv_configured: GovauConfig.ptv_configured?(**creds),
        ptv_check: ptv_check
      )
    }
  when :next_train
    return { error: PTV_SETUP_HINT } unless GovauConfig.ptv_configured?(**creds)

    rows = GovauPtv.fetch_next_departures(
      parsed[:station],
      devid: creds[:devid],
      key: creds[:key],
      fetch: ptv_fetch
    )
    { reply: GovauPtv.format_departures(parsed[:station], rows) }
  when :disruptions
    return { error: PTV_SETUP_HINT } unless GovauConfig.ptv_configured?(**creds)

    payload = GovauPtv.fetch_disruptions(devid: creds[:devid], key: creds[:key], fetch: ptv_fetch)
    rows = GovauPtv.parse_disruptions(payload)
    { reply: GovauPtv.format_disruptions(rows) }
  when :planned
    return { error: PTV_SETUP_HINT } unless GovauConfig.ptv_configured?(**creds)

    payload = GovauPtv.fetch_disruptions(devid: creds[:devid], key: creds[:key], fetch: ptv_fetch)
    rows = GovauPtv.parse_disruptions(payload, status: "Planned")
    {
      reply: GovauPtv.format_disruptions(
        rows,
        title: "Planned metro disruptions",
        footer_label: "#{rows.length} planned"
      )
    }
  when :derby
    return { error: PTV_SETUP_HINT } unless GovauConfig.ptv_configured?(**creds)

    rows = GovauPtv.fetch_next_departures(
      parsed[:station],
      devid: creds[:devid],
      key: creds[:key],
      fetch: ptv_fetch,
      max_results: 1
    )
    result = GovauDerby.play(
      user: user.to_s.strip.empty? ? "player" : user.to_s,
      pick: parsed[:pick],
      amount: parsed[:amount],
      station: parsed[:station],
      departures: rows,
      time: time,
      store: store
    )
    return { error: result[:error] } if result[:error]

    { reply: result[:message] }
  when :detective
    unless network && channel
      return { error: "Dataset Detective must be used in a channel." }
    end

    if parsed[:detective_action] == :guess
      result = GovauDetective.submit_guess(
        network: network,
        channel: channel,
        user: user.to_s.strip.empty? ? "player" : user.to_s,
        guess: parsed[:guess],
        store: db_store
      )
    else
      result = GovauDetective.start_round(
        ckan_fetch: ckan_fetch,
        network: network,
        channel: channel,
        store: db_store
      )
    end
    return { error: result[:error] } if result[:error]

    { reply: result[:message] }
  when :nsw_stop
    return { error: TFNSW_SETUP_HINT } unless GovauConfig.tfnsw_configured?(**tfnsw_creds)

    stops = GovauTfnsw.search_stops(parsed[:query], api_key: tfnsw_creds[:api_key], fetch: tfnsw_fetch)
    { reply: GovauTfnsw.format_stops(parsed[:query], stops) }
  when :nsw_departures
    return { error: TFNSW_SETUP_HINT } unless GovauConfig.tfnsw_configured?(**tfnsw_creds)

    rows = GovauTfnsw.fetch_departures(parsed[:stop], api_key: tfnsw_creds[:api_key], fetch: tfnsw_fetch, when_time: time)
    { reply: GovauTfnsw.format_departures(parsed[:stop], rows) }
  when :nsw_derby
    return { error: TFNSW_SETUP_HINT } unless GovauConfig.tfnsw_configured?(**tfnsw_creds)

    rows = GovauTfnsw.fetch_departures(parsed[:stop], api_key: tfnsw_creds[:api_key], fetch: tfnsw_fetch, when_time: time)
    result = GovauTfnswDerby.play(
      user: user.to_s.strip.empty? ? "player" : user.to_s,
      pick: parsed[:pick],
      amount: parsed[:amount],
      stop: parsed[:stop],
      api_key: tfnsw_creds[:api_key],
      departures: rows,
      time: time,
      store: store
    )
    return { error: result[:error] } if result[:error]

    { reply: result[:message] }
  else
    command_error
  end
end

# File plugins/govau.rb, line 119
def self.help_reply
  lines = [
    IrcFormat.report_header(tag: "GOVAU", title: "data.gov.au · PTV trains", style: GovauPtv::STYLE_TITLE),
    "!govau next train <station> — real-time departures",
    "!govau station <query> — find metro train stations",
    "!govau routes — list metro train lines",
    "!govau disruptions — current metro train disruptions",
    "!govau planned — planned metro train disruptions",
    "!govau derby ontime|late [amount] [station] — peak-hour Delay Derby",
    "!govau detective — Dataset Detective (guess the publisher)",
    "!govau detective guess <agency|state>",
    "!govau nsw stop <query> — find NSW stops",
    "!govau nsw departures <stop> — real-time departures",
    "!govau nsw derby ontime|late [amount] [stop] — peak-hour Delay Derby",
    "!govau search <query> — CKAN dataset search",
    "!govau dataset <name> — CKAN dataset detail",
    "!govau status — PTV and CKAN service status",
    IrcFormat.report_footer("PTV Timetable API", "data.gov.au")
  ]
  lines.join("\n")
end

# File plugins/govau.rb, line 40
def self.parse_command(text)
  args = text.to_s.strip
  return { action: :help } if args.empty?

  parts = args.split(/\s+/)
  case parts[0].downcase
  when "help"
    { action: :help }
  when "search"
    query = parts[1..].join(" ").strip
    return command_error if query.empty?

    { action: :search, query: query }
  when "dataset"
    name = parts[1..].join(" ").strip
    return command_error if name.empty?

    { action: :dataset, name: name }
  when "station"
    query = parts[1..].join(" ").strip
    return command_error if query.empty?

    { action: :station, query: query }
  when "routes"
    { action: :routes }
  when "status"
    { action: :status }
  when "next"
    return command_error unless parts[1]&.casecmp("train")&.zero?

    station = parts[2..].join(" ").strip
    return command_error if station.empty?

    { action: :next_train, station: station }
  when "disruptions"
    { action: :disruptions }
  when "planned"
    { action: :planned }
  when "derby"
    parsed = GovauDerby.parse_derby_args(parts[1..])
    return parsed if parsed[:error]

    { action: :derby, **parsed }
  when "detective"
    sub = GovauDetective.parse_detective_args(parts[1..])
    return sub if sub[:error]

    { action: :detective, detective_action: sub[:action], guess: sub[:guess] }.compact
  when "nsw"
    return command_error if parts.length < 2

    case parts[1].downcase
    when "stop"
      query = parts[2..].join(" ").strip
      return command_error if query.empty?

      { action: :nsw_stop, query: query }
    when "departures", "departure"
      stop = parts[2..].join(" ").strip
      return command_error if stop.empty?

      { action: :nsw_departures, stop: stop }
    when "derby"
      parsed = GovauTfnswDerby.parse_derby_args(parts[2..])
      return parsed if parsed[:error]

      { action: :nsw_derby, pick: parsed[:pick], amount: parsed[:amount], stop: parsed[:stop] }
    else
      command_error
    end
  else
    command_error
  end
end

# File plugins/govau.rb, line 36
def self.usage_message
  "Usage: !govau next train <station> | station <query> | routes | disruptions | planned | derby ontime|late [amount] [station] | detective [guess <answer>] | search <query> | dataset <name> | status"
end

# File plugins/govau.rb, line 284
def execute(m, args_text = nil)
  result = self.class.dispatch_command(
    args_text,
    user: m.user.nick,
    network: m.channel ? bot.config.server : nil,
    channel: m.channel&.name
  )
  if result[:error]
    themed_flood_safe_reply(m, result[:error])
  else
    themed_flood_safe_reply(m, result[:reply])
  end
end