module YtCommands

# File lib/yt_commands.rb, line 14
def command_pattern
  /yt(?:\s+(.+))?$/i
end

# File lib/yt_commands.rb, line 82
def dispatch(
  args_text,
  bot_nick:,
  network:,
  nick:,
  channel: nil,
  is_op: false,
  trusted: false,
  admin_channels: [],
  fetch: nil
)
  parsed = parse_command(args_text)
  return { error: parsed[:error] } if parsed[:action] == :error

  account = YtOAuth.load_account(bot_nick: bot_nick)

  case parsed[:action]
  when :help
    { reply: YtReport.format_help_reply }
  when :auth_start
    return { error: YtOAuth.login_channel_denied_message } unless YtOAuth.private_message?(channel)
    return { error: YtOAuth.auth_denied_message } unless YtOAuth.auth_allowed?(
      network: network, nick: nick, is_op: is_op, admin_channels: admin_channels
    )

    result = YtOAuth.start_device_flow(bot_nick: bot_nick, fetch: fetch)
    return { error: result[:error] } unless result[:success]

    { reply: YtReport.format_auth_start_reply(result) }
  when :auth_status
    return { error: YtOAuth.login_channel_denied_message } unless YtOAuth.private_message?(channel)
    return { error: YtOAuth.auth_denied_message } unless YtOAuth.auth_allowed?(
      network: network, nick: nick, is_op: is_op, admin_channels: admin_channels
    )

    result = YtOAuth.poll_device_flow(bot_nick: bot_nick, fetch: fetch)
    return { error: result[:error] } unless result[:success]

    { reply: YtReport.format_auth_success_reply(result[:account]) }
  when :auth_help
    { reply: YtReport.format_auth_setup_reply }
  when :whoami
    { reply: YtReport.format_whoami_reply(account) }
  when :logout
    return { error: YtOAuth.login_channel_denied_message } unless YtOAuth.private_message?(channel)
    return { error: YtOAuth.auth_denied_message } unless YtOAuth.auth_allowed?(
      network: network, nick: nick, is_op: is_op, admin_channels: admin_channels
    )

    YtOAuth.clear_account(bot_nick: bot_nick)
    YtOAuth.clear_pending(bot_nick: bot_nick)
    { reply: YtReport.format_logout_reply }
  when :playlist_list
    result = YtPlaylist.list_playlists(bot_nick: bot_nick, account: account, fetch: fetch)
    return { error: result[:error] } unless result[:success]

    { reply: YtReport.format_playlist_list_reply(result[:playlists]) }
  when :playlist_show
    result = YtPlaylist.show_playlist(
      bot_nick: bot_nick,
      account: account,
      playlist_ref: parsed[:playlist_ref],
      fetch: fetch
    )
    return { error: result[:error] } unless result[:success]

    { reply: YtReport.format_playlist_show_reply(result[:playlist], result[:items]) }
  when :playlist_create
    return { error: mutation_denied_message } unless trusted

    result = YtPlaylist.create_playlist(
      bot_nick: bot_nick,
      account: account,
      title: parsed[:title],
      privacy: parsed[:privacy],
      fetch: fetch
    )
    return { error: result[:error] } unless result[:success]

    playlist = result[:playlist]
    {
      reply: YtReport.format_playlist_action_reply(
        "created",
        "#{playlist[:title]} — #{playlist[:id]} (#{playlist[:privacy]})"
      )
    }
  when :playlist_delete
    return { error: mutation_denied_message } unless trusted

    resolved = YtPlaylist.resolve_playlist(
      bot_nick: bot_nick,
      account: account,
      ref: parsed[:playlist_ref],
      fetch: fetch
    )
    return { error: resolved[:error] } unless resolved[:success]

    result = YtPlaylist.delete_playlist(
      bot_nick: bot_nick,
      account: account,
      playlist_id: resolved[:playlist][:id],
      fetch: fetch
    )
    return { error: result[:error] } unless result[:success]

    { reply: YtReport.format_playlist_action_reply("deleted", resolved[:playlist][:id]) }
  when :playlist_add
    return { error: mutation_denied_message } unless trusted

    result = YtPlaylist.add_video(
      bot_nick: bot_nick,
      account: account,
      playlist_ref: parsed[:playlist_ref],
      video_ref: parsed[:video_ref],
      fetch: fetch
    )
    return { error: result[:error] } unless result[:success]

    item = result[:item]
    {
      reply: YtReport.format_playlist_action_reply(
        "added",
        "#{item[:title]} — #{item[:video_id]} to #{result[:playlist][:id]}"
      )
    }
  when :playlist_remove
    return { error: mutation_denied_message } unless trusted

    result = YtPlaylist.remove_item(
      bot_nick: bot_nick,
      account: account,
      playlist_ref: parsed[:playlist_ref],
      target_ref: parsed[:target_ref],
      fetch: fetch
    )
    return { error: result[:error] } unless result[:success]

    removed = result[:removed]
    {
      reply: YtReport.format_playlist_action_reply(
        "removed",
        "#{removed[:title]} — #{removed[:video_id]} from #{result[:playlist][:id]}"
      )
    }
  else
    { error: USAGE }
  end
end

# File lib/yt_commands.rb, line 231
def mutation_denied_message
  "Playlist changes require voice, op, or registered voice+ in channel."
end

# File lib/yt_commands.rb, line 18
def parse_command(text)
  stripped = text.to_s.strip
  return { action: :help } if stripped.empty?

  return { action: :help } if stripped.match?(/\Ahelp\z/i)
  return { action: :whoami } if stripped.match?(/\Awhoami\z/i)
  return { action: :logout } if stripped.match?(/\Alogout\z/i)

  if stripped.match?(/\Aauth\z/i)
    return { action: :auth_start }
  end

  if stripped.match?(/\Aauth\s+status\z/i)
    return { action: :auth_status }
  end

  if stripped.match?(/\Aauth\s+help\z/i)
    return { action: :auth_help }
  end

  if (match = stripped.match(/\Aplaylist\s+list\z/i))
    return { action: :playlist_list }
  end

  if (match = stripped.match(/\Aplaylist\s+show\s+(.+)\z/i))
    return { action: :playlist_show, playlist_ref: match[1].strip }
  end

  if (match = stripped.match(/\Aplaylist\s+create\s+(.+)\z/i))
    rest = match[1].strip
    privacy_match = rest.match(/\A(.+?)\s+(public|private|unlisted)\z/i)
    if privacy_match
      return {
        action: :playlist_create,
        title: privacy_match[1].strip,
        privacy: privacy_match[2].downcase
      }
    end
    return { action: :playlist_create, title: rest, privacy: "private" }
  end

  if (match = stripped.match(/\Aplaylist\s+delete\s+(\S+)\z/i))
    return { action: :playlist_delete, playlist_ref: match[1].strip }
  end

  if (match = stripped.match(/\Aplaylist\s+add\s+(\S+)\s+(.+)\z/i))
    return {
      action: :playlist_add,
      playlist_ref: match[1].strip,
      video_ref: match[2].strip
    }
  end

  if (match = stripped.match(/\Aplaylist\s+rem(?:ove)?\s+(\S+)\s+(.+)\z/i))
    return {
      action: :playlist_remove,
      playlist_ref: match[1].strip,
      target_ref: match[2].strip
    }
  end

  { action: :error, error: USAGE }
end