# encoding: utf-8
module Ayadn
  class App < Thor
    package_name "Ayadn"

    begin
      %w{action api descriptions endpoints cnx view workers settings post status extend databases fileops logs set alias errors blacklist mark nicerank debug check diagnostics}.each { |r| require_relative "#{r}" }
    rescue Interrupt
      puts "\nExit: stopped by user while launching\n\n"
      exit
    end

    ##
    # These methods are intended to be called from the CLI.

    desc "timeline", "Show your App.net timeline, aka the Unified Stream (-tl)"
    map "unified" => :timeline
    map "-tl" => :timeline
    long_desc Descriptions.unified
    option :scroll, aliases: "-s", type: :boolean, desc: "Scroll the stream"
    option :new, aliases: "-n", type: :boolean, desc: Descriptions.options_new
    option :count, aliases: "-c", type: :numeric, desc: Descriptions.options_count
    option :index, aliases: "-i", type: :boolean, desc: Descriptions.options_index
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    def timeline
      Action.new.unified(options)
    end

    desc "checkins", "Show the Checkins Stream (-ck)"
    map "-ck" => :checkins
    long_desc Descriptions.checkins
    option :scroll, aliases: "-s", type: :boolean, desc: "Scroll the stream"
    option :new, aliases: "-n", type: :boolean, desc: Descriptions.options_new
    option :count, aliases: "-c", type: :numeric, desc: Descriptions.options_count
    option :index, aliases: "-i", type: :boolean, desc: Descriptions.options_index
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    def checkins
      Action.new.checkins(options)
    end

    desc "global", "Show the Global Stream (-gl)"
    map "-gl" => :global
    long_desc Descriptions.global
    option :scroll, aliases: "-s", type: :boolean, desc: "Scroll the stream"
    option :new, aliases: "-n", type: :boolean, desc: Descriptions.options_new
    option :count, aliases: "-c", type: :numeric, desc: Descriptions.options_count
    option :index, aliases: "-i", type: :boolean, desc: Descriptions.options_index
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    def global
      Action.new.global(options)
    end

    desc "trending", "Show the Trending Stream (-tr)"
    map "-tr" => :trending
    long_desc Descriptions.trending
    option :scroll, aliases: "-s", type: :boolean, desc: "Scroll the stream"
    option :new, aliases: "-n", type: :boolean, desc: Descriptions.options_new
    option :count, aliases: "-c", type: :numeric, desc: Descriptions.options_count
    option :index, aliases: "-i", type: :boolean, desc: Descriptions.options_index
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    def trending
      Action.new.trending(options)
    end

    desc "photos", "Show the Photos Stream (-ph)"
    map "-ph" => :photos
    long_desc Descriptions.photos
    option :scroll, aliases: "-s", type: :boolean, desc: "Scroll the stream"
    option :new, aliases: "-n", type: :boolean, desc: Descriptions.options_new
    option :count, aliases: "-c", type: :numeric, desc: Descriptions.options_count
    option :index, aliases: "-i", type: :boolean, desc: Descriptions.options_index
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    def photos
      Action.new.photos(options)
    end

    desc "conversations", "Show the Conversations Stream (-cq)"
    map "-cq" => :conversations
    long_desc Descriptions.conversations
    option :scroll, aliases: "-s", type: :boolean, desc: "Scroll the stream"
    option :new, aliases: "-n", type: :boolean, desc: Descriptions.options_new
    option :count, aliases: "-c", type: :numeric, desc: Descriptions.options_count
    option :index, aliases: "-i", type: :boolean, desc: Descriptions.options_index
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    def conversations
      Action.new.conversations(options)
    end

    desc "mentions @USERNAME", "Show posts containing a mention of @username (-m)"
    map "-m" => :mentions
    long_desc Descriptions.mentions
    option :scroll, aliases: "-s", type: :boolean, desc: "Scroll the stream"
    option :count, aliases: "-c", type: :numeric, desc: Descriptions.options_count
    option :index, aliases: "-i", type: :boolean, desc: Descriptions.options_index
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    def mentions(*username)
      Action.new.mentions(username, options)
    end

    desc "userposts @USERNAME", "Show posts by @username (-up)"
    map "-up" => :userposts
    long_desc Descriptions.posts
    option :scroll, aliases: "-s", type: :boolean, desc: "Scroll the stream"
    option :count, aliases: "-c", type: :numeric, desc: Descriptions.options_count
    option :index, aliases: "-i", type: :boolean, desc: Descriptions.options_index
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    def userposts(*username)
      Action.new.posts(username, options)
    end

    desc "interactions", "Show your recent ADN activity (-int)"
    map "-int" => :interactions
    long_desc Descriptions.interactions
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    def interactions
      Action.new.interactions(options)
    end

    desc "whatstarred @USERNAME", "Show posts starred by @username (-was)"
    map "-was" => :whatstarred
    long_desc Descriptions.whatstarred
    option :count, aliases: "-c", type: :numeric, desc: Descriptions.options_count
    option :index, aliases: "-i", type: :boolean, desc: Descriptions.options_index
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :extract, aliases: "-e", type: :boolean, desc: Descriptions.options_extract
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    option :cache, type: :boolean, desc: "Cache the results"
    option :again, type: :boolean, desc: "Run the last request from cache"
    def whatstarred(*username)
      Action.new.whatstarred(username, options)
    end

    desc "whoreposted POST", "List users who reposted a post (-wor)"
    map "-wor" => :whoreposted
    long_desc Descriptions.whoreposted
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :force, aliases: "-f", type: :boolean, desc: "Force retrieve the actual post id (ignores index)"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    option :cache, type: :boolean, desc: "Cache the results"
    option :again, type: :boolean, desc: "Run the last request from cache"
    def whoreposted(post_id)
      Action.new.whoreposted(post_id, options)
    end

    desc "whostarred POST", "List users who starred a post (-wos)"
    map "-wos" => :whostarred
    long_desc Descriptions.whostarred
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :force, aliases: "-f", type: :boolean, desc: "Force retrieve the actual post id (ignores index)"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    option :cache, type: :boolean, desc: "Cache the results"
    option :again, type: :boolean, desc: "Run the last request from cache"
    def whostarred(post_id)
      Action.new.whostarred(post_id, options)
    end

    desc "convo POST", "Show the conversation thread around a post (-co)"
    map "-co" => :convo
    map "thread" => :convo
    option :scroll, aliases: "-s", type: :boolean, desc: "Scroll the stream"
    option :index, aliases: "-i", type: :boolean, desc: Descriptions.options_index
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    long_desc Descriptions.convo
    def convo(post_id)
      Action.new.convo(post_id, options)
    end

    desc "followings @USERNAME", "List users @username is following (-fwg)"
    map "-fwg" => :followings
    long_desc Descriptions.followings
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :reverse, aliases: "-r", type: :boolean, desc: "Reverses the list original order"
    option :username, aliases: "-u", type: :boolean, desc: "Sort the list by: username"
    option :name, aliases: "-n", type: :boolean, desc: "Sort the list by: name"
    option :posts, aliases: "-p", type: :boolean, desc: "Sort the list by: total posts"
    option :date, aliases: "-t", type: :boolean, desc: "Sort the list by: date (only with 'lastposts' option)"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    option :lastpost, aliases: "-l", type: :boolean, desc: "Displays the last post of each user"
    option :cache, type: :boolean, desc: "Cache the results"
    option :again, type: :boolean, desc: "Run the last request from cache"
    def followings(*username)
      Action.new.followings(username, options)
    end

    desc "followers @USERNAME", "List users following @username (-fwr)"
    map "-fwr" => :followers
    long_desc Descriptions.followers
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :reverse, aliases: "-r", type: :boolean, desc: "Reverses the list original order"
    option :username, aliases: "-u", type: :boolean, desc: "Sort the list by: username"
    option :name, aliases: "-n", type: :boolean, desc: "Sort the list by: name"
    option :posts, aliases: "-p", type: :boolean, desc: "Sort the list by: total posts"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    option :cache, type: :boolean, desc: "Cache the results"
    option :again, type: :boolean, desc: "Run the last request from cache"
    def followers(*username)
      Action.new.followers(username, options)
    end

    desc "muted", "List the users you muted (-mtd)"
    map "-mtd" => :muted
    long_desc Descriptions.muted
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :reverse, aliases: "-r", type: :boolean, desc: "Reverses the list original order"
    option :username, aliases: "-u", type: :boolean, desc: "Sort the list by: username"
    option :name, aliases: "-n", type: :boolean, desc: "Sort the list by: name"
    option :posts, aliases: "-p", type: :boolean, desc: "Sort the list by: total posts"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    option :cache, type: :boolean, desc: "Cache the results"
    option :again, type: :boolean, desc: "Run the last request from cache"
    def muted
      Action.new.muted(options)
    end

    desc "blocked", "List the users you blocked (-bkd)"
    map "-bkd" => :blocked
    long_desc Descriptions.blocked
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :reverse, aliases: "-r", type: :boolean, desc: "Reverses the list original order"
    option :username, aliases: "-u", type: :boolean, desc: "Sort the list by: username"
    option :name, aliases: "-n", type: :boolean, desc: "Sort the list by: name"
    option :posts, aliases: "-p", type: :boolean, desc: "Sort the list by: total posts"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    option :cache, type: :boolean, desc: "Cache the results"
    option :again, type: :boolean, desc: "Run the last request from cache"
    def blocked
      Action.new.blocked(options)
    end

    desc "hashtag HASHTAG", "Show recent posts containing #HASHTAG (-t)"
    map "-t" => :hashtag
    long_desc Descriptions.hashtag
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :extract, aliases: "-e", type: :boolean, desc: Descriptions.options_extract
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    def hashtag(hashtag)
      require_relative("search")
      Action.new.hashtag(hashtag, options)
    end

    desc "search WORD(S)", "Show recents posts containing WORD(S) (-s)"
    map "-s" => :search
    long_desc Descriptions.search
    option :count, aliases: "-c", type: :numeric, desc: Descriptions.options_count
    option :index, aliases: "-i", type: :boolean, desc: Descriptions.options_index
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    option :extract, aliases: "-e", type: :boolean, desc: Descriptions.options_extract
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    option :messages, type: :boolean, desc: 'Search for WORD(S) in messages, including PMs.'
    option :users, type: :boolean, desc: 'Search for App.net users by searching WORD(S) in their bio/description.'
    option :channels, type: :boolean, desc: 'Search for App.net channels by searching WORD(S) in their description.'
    option :annotations, type: :boolean, desc: 'Search for posts containing a specific App.net annotation.'
    def search(*words)
      require_relative("search")
      Action.new.search(words.join(","), options)
    end

    desc "settings", "List current Ayadn settings (-sg)"
    map "-sg" => :settings
    long_desc Descriptions.settings
    option :raw, aliases: "-x", type: :boolean, desc: "Outputs the raw list in JSON"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    def settings
      Action.new.view_settings(options)
    end

    desc "userinfo @USERNAME", "Show detailed informations about @username (-ui)"
    map "-ui" => :userinfo
    long_desc Descriptions.userinfo
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    def userinfo(*username)
      Action.new.userinfo(username, options)
    end

    desc "userupdate", "Update your user profile informations (-U)"
    map "-U" => :userupdate
    long_desc Descriptions.userupdate
    option :delete, aliases: "-D", type: :boolean, desc: "Delete this content from your profile"
    option :bio, type: :boolean, desc: "Update your user bio"
    option :name, type: :boolean, desc: "Update your user full name"
    option :twitter, type: :boolean, desc: "Update your Twitter username"
    option :blog, type: :boolean, desc: "Update your blog url"
    option :web, type: :boolean, desc: "Update your web url"
    option :avatar, type: :array, desc: "Update your avatar picture"
    option :cover, type: :array, desc: "Update your cover picture"
    def userupdate
      require_relative("profile")
      Action.new.userupdate(options)
    end

    desc "postinfo POST", "Show detailed informations about a post (-pi)"
    map "-pi" => :postinfo
    long_desc Descriptions.postinfo
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    def postinfo(post_id)
      Action.new.postinfo(post_id, options)
    end

    desc "files", "List your files (-fl)"
    map "-fl" => :files
    long_desc Descriptions.files
    option :count, aliases: "-c", type: :numeric, desc: "Specify the number of files to display"
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :all, aliases: "-a", type: :boolean, desc: "Retrieve the list of all your files"
    def files
      Action.new.files(options)
    end

    desc "delete POST", "Delete a post (-D)"
    map "-D" => :delete
    long_desc Descriptions.delete
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    def delete(*post_id)
      Action.new.delete(post_id, options)
    end

    desc "delete_m CHANNEL MESSAGE", "Delete a message (-DM)"
    map "-DM" => :delete_m
    long_desc Descriptions.delete_m
    def delete_m(*args)
      Action.new.delete_m(args)
    end

    desc "unfollow @USERNAME", "Unfollow @username (-UF)"
    map "-UF" => :unfollow
    long_desc Descriptions.unfollow
    def unfollow(*username)
      Action.new.unfollow(username)
    end

    desc "unmute @USERNAME", "Unmute @username (-UM)"
    map "-UM" => :unmute
    long_desc Descriptions.unmute
    def unmute(*username)
      Action.new.unmute(username)
    end

    desc "unblock @USERNAME", "Unblock @username (-UB)"
    map "-UB" => :unblock
    long_desc Descriptions.unblock
    def unblock(*username)
      Action.new.unblock(username)
    end

    desc "unrepost POST", "Unrepost a post (-UR)"
    map "-UR" => :unrepost
    long_desc Descriptions.unrepost
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    def unrepost(*post_id)
      Action.new.unrepost(post_id, options)
    end

    desc "unstar POST", "Unstar a post (-US)"
    map "-US" => :unstar
    long_desc Descriptions.unstar
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    def unstar(*post_id)
      Action.new.unstar(post_id, options)
    end

    desc "star POST", "Star a post (-ST)"
    map "-ST" => :star
    long_desc Descriptions.star
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    def star(*post_id)
      Action.new.star(post_id, options)
    end

    desc "repost POST", "Repost a post (-O)"
    map "-O" => :repost
    long_desc Descriptions.repost
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    def repost(*post_id)
      Action.new.repost(post_id, options)
    end

    desc "follow @USERNAME", "Follow @username (-FO)"
    map "-FO" => :follow
    long_desc Descriptions.follow
    def follow(*username)
      Action.new.follow(username)
    end

    desc "mute @USERNAME", "Mute @username (-MU)"
    map "-MU" => :mute
    long_desc Descriptions.mute
    def mute(*username)
      Action.new.mute(username)
    end

    desc "block @USERNAME", "Block @username (-BL)"
    map "-BL" => :block
    long_desc Descriptions.block
    def block(*username)
      Action.new.block(username)
    end

    desc "channels", "List your active channels (-ch)"
    map "-ch" => :channels
    long_desc Descriptions.channels
    option :id, aliases: "-i", type: :array, desc: "Retrieve only the specified channel(s)"
    option :broadcasts, aliases: "-b", type: :boolean, desc: "Only your broadcast channel(s)"
    option :messages, aliases: "-m", type: :boolean, desc: "Only your private messaging channel(s)"
    option :patter, aliases: "-p", type: :boolean, desc: "Only your patter room channel(s)"
    option :other, aliases: "-o", type: :boolean, desc: "Only other than private messaging and broadcasts channel(s)"
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    def channels
      Action.new.channels(options)
    end

    desc "messages CHANNEL", "Show messages in a CHANNEL (-ms)"
    map "-ms" => :messages
    long_desc Descriptions.messages
    option :scroll, aliases: "-s", type: :boolean, desc: "Scroll the stream"
    option :new, aliases: "-n", type: :boolean, desc: Descriptions.options_new
    option :count, aliases: "-c", type: :numeric, desc: "Specify the number of messages to retrieve"
    option :raw, aliases: "-x", type: :boolean, desc: Descriptions.options_raw
    option :silent, aliases: "-z", type: :boolean, desc: "Do not mark the channel as read"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    def messages(channel_id)
      Action.new.messages(channel_id, options)
    end

    desc "messages_unread", "Show your unread private messages (-pmu)"
    map "-pmu" => :messages_unread
    option :silent, aliases: "-z", type: :boolean, desc: "Do not mark the channels as read"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    long_desc Descriptions.messages_unread
    def messages_unread
        Action.new.messages_unread(options)
    end

    desc "pin POST TAG(S)", "Export a post's link and text with tags to Pinboard"
    long_desc Descriptions.pin
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    def pin(post_id, *tags)
      require_relative("pinboard")
      Action.new.pin(post_id, tags, options)
    end

    desc "post Your text", "Simple post to App.net (-P)"
    map "-P" => :post
    long_desc Descriptions.post
    option :embed, aliases: "-E", type: :array, desc: "Embed one or several pictures in the new post"
    option :youtube, aliases: "-Y", type: :array, desc: "Embed a Youtube video in the new post"
    option :vimeo, aliases: "-V", type: :array, desc: "Embed a Vimeo video in the new post"
    option :poster, aliases: "-M", type: :array, desc: "Embed a movie poster, from title, in the new post"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already (after posting)"
    def post(*args)
      Action.new.post(args, options)
    end

    desc "write", "Multi-line post to App.net (-W)"
    map "compose" => :write
    map "-W" => :write
    long_desc Descriptions.write
    option :embed, aliases: "-E", type: :array, desc: "Embed one or several pictures in the new post"
    option :youtube, aliases: "-Y", type: :array, desc: "Embed a Youtube video in the new post"
    option :vimeo, aliases: "-V", type: :array, desc: "Embed a Vimeo video in the new post"
    option :poster, aliases: "-M", type: :array, desc: "Embed a movie poster, from title, in the new post"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already (after posting)"
    def write
      Action.new.write(options)
    end

    desc "pm @USERNAME", "Send a private message to @username"
    long_desc Descriptions.pmess
    option :embed, aliases: "-E", type: :array, desc: "Embed one or several pictures in the new message"
    option :youtube, aliases: "-Y", type: :array, desc: "Embed a Youtube video in the new message"
    option :vimeo, aliases: "-V", type: :array, desc: "Embed a Vimeo video in the new message"
    option :poster, aliases: "-M", type: :array, desc: "Embed a movie poster, from title, in the new message"
    option :silent, aliases: "-z", type: :boolean, desc: "Do not mark the channel as read"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already (after posting)"
    def pm(*username)
      Action.new.pmess(username, options)
    end

    desc "send CHANNEL", "Send a message to a CHANNEL (-C)"
    map "-C" => :send_to_channel
    long_desc Descriptions.send_to_channel
    option :embed, aliases: "-E", type: :array, desc: "Embed one or several pictures in the new message"
    option :youtube, aliases: "-Y", type: :array, desc: "Embed a Youtube video in the new message"
    option :vimeo, aliases: "-V", type: :array, desc: "Embed a Vimeo video in the new message"
    option :poster, aliases: "-M", type: :array, desc: "Embed a movie poster, from title, in the new message"
    option :silent, aliases: "-z", type: :boolean, desc: "Do not mark the channel as read"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already (after posting)"
    def send_to_channel(channel_id)
      Action.new.send_to_channel(channel_id, options)
    end

    desc "reply POST", "Reply to post n°POST (-R)"
    map "-R" => :reply
    long_desc Descriptions.reply
    option :embed, aliases: "-E", type: :array, desc: "Embed one or several pictures in the new post"
    option :youtube, aliases: "-Y", type: :array, desc: "Embed a Youtube video in the new post"
    option :vimeo, aliases: "-V", type: :array, desc: "Embed a Vimeo video in the new post"
    option :poster, aliases: "-M", type: :array, desc: "Embed a movie poster, from title, in the new post"
    option :noredirect, aliases: "-n", type: :boolean, desc: "Do not respond to the original post but to the reposted one if possible"
    option :force, aliases: "-f", type: :boolean, desc: Descriptions.options_force
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already (after posting)"
    def reply(id)
      ayadn = Action.new
      ayadn.reply(id, options)
    end

    desc "auto", "Auto post every line of input to App.net"
    long_desc Descriptions.auto
    def auto
      Action.new.auto(options)
    end

    desc "set TYPE PARAM VALUE", "Set/configure a parameter and save it"
    long_desc Descriptions.set
    subcommand "set", Set

    desc "alias COMMAND (PARAM)", "Create/delete/list aliases for channels (-A)"
    map "-A" => :alias
    long_desc Descriptions.alias
    subcommand "alias", Alias

    desc "mark POST (TITLE)", "Bookmark a conversation / manage bookmarks"
    long_desc Descriptions.mark
    subcommand "mark", Mark

    desc "download FILE", "Download the file with id FILE (-df)"
    map "-df" => :download
    long_desc Descriptions.download
    def download(file_id)
      ayadn = Action.new
      ayadn.download(file_id)
    end

    desc "blacklist COMMAND (PARAM)", "Manage your blacklist (-K)"
    map "-K" => :blacklist
    long_desc Descriptions.blacklist
    subcommand "blacklist", Blacklist

    desc "nowplaying", "Post the current playing track from iTunes, Deezer or Last.fm (-NP)"
    map "-np" => :nowplaying
    map "-NP" => :nowplaying
    long_desc Descriptions.nowplaying
    option :no_url, aliases: "-n", type: :boolean, desc: "Don't append preview or album art at the end of the post"
    option :lastfm, aliases: "-l", type: :boolean, desc: "Get current track from Last.fm instead of iTunes"
    option :deezer, aliases: "-d", type: :boolean, desc: "Get current track from Deezer instead of iTunes"
    option :hashtag, aliases: "-h", type: :array, desc: "Specify a custom hashtag"
    option :text, aliases: "-t", type: :array, desc: "Add custom text"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already (after posting)"
    def nowplaying
      require_relative("nowplaying")
      Action.new.nowplaying(options)
    end

    desc "movie TITLE", "Create a post from a movie title (-NW)"
    map "nowwatching" => :movie
    map "imdb" => :movie
    map "-NW" => :movie
    long_desc Descriptions.nowwatching
    option :alt, aliases: "-a", type: :boolean, desc: "Select an alternative response if the first didn't match"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already (after posting)"
    def movie(*title)
      require_relative("nowwatching")
      Action.new.nowwatching(title, options)
    end

    desc "tvshow TITLE", "Create a post from a TV show title (-TV)"
    map "-TV" => :tvshow
    long_desc Descriptions.tvshow
    option :alt, aliases: "-a", type: :boolean, desc: "Select an alternative response if the first didn't match"
    option :banner, aliases: "-b", type: :boolean, desc: "Inserts the show banner instead of the show poster"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already (after posting)"
    def tvshow(*title)
      require_relative("tvshow")
      Action.new.tvshow(title, options)
    end

    desc "random", "Show random posts from App.net (-rnd)"
    map "-rnd" => :random
    option :wait, aliases: "-w", type: :numeric, desc: "In seconds, time to wait before next page"
    option :compact, aliases: "-k", type: :boolean, desc: "Force the view to be compact if not already"
    long_desc Descriptions.random_posts
    def random
      Action.new.random_posts(options)
    end

    desc "authorize", "Authorize Ayadn (-AU)"
    map "-auth" => :authorize
    map "-AU" => :authorize
    option :api, aliases: "-a", type: :array, desc: "Provide an alternative root URL for the API call."
    option :token, aliases: "-t", type: :array, desc: "Provide the token directly (bypass the webpage)"
    long_desc Descriptions.authorize
    def authorize()
      require_relative("authorize")
      require_relative("switch")
      Authorize.new.authorize(options)
    end

    desc "unauthorize @USERNAME", "Unauthorize an Ayadn user account (-UA)"
    map "-unauth" => :unauthorize
    map "-UA" => :unauthorize
    option :delete, aliases: "-D", type: :boolean, desc: "Deletes user folders (default: false)"
    long_desc Descriptions.unauthorize
    def unauthorize(*user)
      require_relative("authorize")
      require_relative("switch")
      Authorize.new.unauthorize(user, options)
    end

    desc "switch @USERNAME", "Switch between authorized App.net accounts (-@)"
    map "-@" => :switch
    map "login" => :switch
    option :list, aliases: "-l", type: :boolean, desc: "List authorized accounts"
    long_desc Descriptions.switch
    def switch(*username)
      require_relative("switch")
      unless options[:list]
        Switch.new.switch(username)
      else
        Switch.new.list
      end
    end

    desc "version", "Show the current Ayadn version (-v)"
    map "-v" => :version
    def version
      Status.new.version
    end

    desc "diagnostics", "Run diagnostics (-dg)"
    map "-dg" => :diagnostics
    map "check" => :diagnostics
    map "test" => :diagnostics
    subcommand "diagnostics", Diagnostics

  end
end