who really wanted focused commits anyway

* fix a bunch of warnings
* modularize commands
* colorize rendered tweets
* properly url-encode most punctuation (janky as hec)
* support explicit "reconnect" command if twitter stream dropped
* prelim support for DMs
* get user's handle on connect (to prevent incorrect threading attempts)
* render quoted tweets sanely

1 files changed, 511 insertions, 105 deletions

diff --git a/main.rs b/main.rs
index f47f2f3..3b6624d 100644
--- a/main.rs
+++ b/main.rs
@@ -1,6 +1,7 @@
 extern crate serde_json;
 
 use std::str;
+use std::str::FromStr;
 //use std::io::BufRead;
 
 #[macro_use] extern crate chan;
@@ -29,9 +30,15 @@ static token: &str = "629126745-Qt6LPq2kR7w58s7WHzSqcs4CIdiue64kkfYYB7RI";
 static token_secret: &str = "3BI3YC4WVbKW5icpHORWpsTYqYIj5oAZFkrgyIAoaoKnK";
 static lol_auth_token: &str = "641cdf3a4bbddb72c118b5821e8696aee6300a9a";
 
-static streamurl: &str = "https://userstream.twitter.com/1.1/user.json?tweet_mode=extended";
-static tweet_lookup_url: &str = "https://api.twitter.com/1.1/statuses/show.json?tweet_mode=extended";
-static user_lookup_url: &str = "https://api.twitter.com/1.1/users/show.json";
+static STREAMURL: &str = "https://userstream.twitter.com/1.1/user.json?tweet_mode=extended";
+static TWEET_LOOKUP_URL: &str = "https://api.twitter.com/1.1/statuses/show.json?tweet_mode=extended";
+static USER_LOOKUP_URL: &str = "https://api.twitter.com/1.1/users/show.json";
+static FAV_TWEET_URL: &str = "https://api.twitter.com/1.1/favorites/create.json";
+static UNFAV_TWEET_URL: &str = "https://api.twitter.com/1.1/favorites/destroy.json";
+static DEL_TWEET_URL: &str = "https://api.twitter.com/1.1/statuses/destroy";
+static RT_TWEET_URL: &str = "https://api.twitter.com/1.1/statuses/retweet";
+static CREATE_TWEET_URL: &str = "https://api.twitter.com/1.1/statuses/update.json";
+static ACCOUNT_SETTINGS_URL: &str = "https://api.twitter.com/1.1/account/settings.json";
 
 header! { (Authorization, "Authorization") => [String] }
 header! { (Accept, "Accept") => [String] }
@@ -46,14 +53,8 @@ mod tw {
 
     use self::chrono::prelude::*;
 
-    extern crate hyper;
-    extern crate hyper_tls;
     use std::collections::{HashMap, HashSet};
-    use tokio_core::reactor::Core;
-    use hyper_tls::HttpsConnector;
     extern crate serde_json;
-    extern crate serde;
-    extern crate serde_derive;
     use std::io::Write;
 
     use std::fs::OpenOptions;
@@ -65,7 +66,20 @@ mod tw {
         pub handle: String
     }
 
+    impl Default for User {
+        fn default() -> User {
+            User {
+                id: "".to_owned(),
+                name: "_default_".to_owned(),
+                handle: "_default_".to_owned()
+            }
+        }
+    }
+
     pub mod events {
+        extern crate termion;
+        use self::termion::color;
+
         extern crate serde_json;
 
         pub struct Deleted {
@@ -102,7 +116,7 @@ mod tw {
         }
 
         impl Event for Deleted {
-            fn render(self: Box<Self>, tweeter: &::tw::TwitterCache) { }
+            fn render(self: Box<Self>, _tweeter: &::tw::TwitterCache) { }
         }
         impl Event for RT_RT {
             fn render(self: Box<Self>, tweeter: &::tw::TwitterCache) {
@@ -112,8 +126,7 @@ mod tw {
                     println!("  +rt_rt    : {} (@{})", user.name, user.handle);
                 }
                 {
-                    let target = tweeter.retrieve_tweet(&self.twete_id).unwrap();
-                    ::render_twete(target, tweeter);
+                    ::render_twete(&self.twete_id, tweeter);
                 }
                 println!("");
             }
@@ -126,8 +139,7 @@ mod tw {
                     println!("  +rt_fav   : {} (@{})", user.name, user.handle);
                 }
                 {
-                    let target = tweeter.retrieve_tweet(&self.twete_id).unwrap();
-                    ::render_twete(target, tweeter);
+                    ::render_twete(&self.twete_id, tweeter);
                 }
                 println!("");
             }
@@ -137,11 +149,10 @@ mod tw {
                 println!("---------------------------------");
                 {
                     let user = tweeter.retrieve_user(&self.user_id).unwrap();
-                    println!("  +fav      : {} (@{})", user.name, user.handle);
+                    println!("{}  +fav      : {} (@{}){}", color::Fg(color::Yellow), user.name, user.handle, color::Fg(color::Reset));
                 }
                 {
-                    let target = tweeter.retrieve_tweet(&self.twete_id).unwrap();
-                    ::render_twete(target, tweeter);
+                    ::render_twete(&self.twete_id, tweeter);
                 }
                 println!("");
             }
@@ -151,11 +162,10 @@ mod tw {
                 println!("---------------------------------");
                 {
                     let user = tweeter.retrieve_user(&self.user_id).unwrap();
-                    println!("  +fav      : {} (@{})", user.name, user.handle);
+                    println!("{}  -fav      : {} (@{}){}", color::Fg(color::Yellow), user.name, user.handle, color::Fg(color::Reset));
                 }
                 {
-                    let target = tweeter.retrieve_tweet(&self.twete_id).unwrap();
-                    ::render_twete(target, tweeter);
+                    ::render_twete(&self.twete_id, tweeter);
                 }
                 println!("");
             }
@@ -214,6 +224,7 @@ mod tw {
                     })),
     //                &"blocked" => Blocked { },
     //                &"unblocked" => Unblocked { },
+    //                &"quoted_tweet" => ???,
                     e => { println!("unrecognized event: {}", e); None }
                 }
             }
@@ -258,7 +269,9 @@ mod tw {
         pub quoted_tweet_id: Option<String>,
         #[serde(skip_serializing_if="Option::is_none")]
         #[serde(default = "Option::default")]
-        pub rt_tweet: Option<String>
+        pub rt_tweet: Option<String>,
+        #[serde(skip)]
+        pub internal_id: u64
     }
 
     impl Tweet {
@@ -296,7 +309,8 @@ mod tw {
                             quoted_tweet_id: json_map.get("quoted_status_id_str")
                                 .and_then(|x| x.as_str())
                                 .map(|x| x.to_owned()),
-                            rt_tweet: rt_twete
+                            rt_tweet: rt_twete,
+                            internal_id: 0
                         })
                     }
                 }
@@ -329,6 +343,7 @@ mod tw {
             if expanded_url.len() < 200 {
                 if let Some(twid) = quoted_tweet_id {
                     if expanded_url.ends_with(twid) {
+                        twete_text = twete_text.replace(display_url, "");
                         continue;
                     }
                 }
@@ -351,9 +366,13 @@ mod tw {
         lost_followers: HashSet<String>,
         follower_history: HashMap<String, (String, i64)>, // userid:date??
         #[serde(skip)]
+        id_to_tweet_id: HashMap<u64, String>,
+        #[serde(skip)]
         pub needs_save: bool,
         #[serde(skip)]
-        pub caching_permitted: bool
+        pub caching_permitted: bool,
+        #[serde(skip)]
+        pub current_user: User
     }
 
     impl TwitterCache {
@@ -371,8 +390,10 @@ mod tw {
                 followers: HashSet::new(),
                 lost_followers: HashSet::new(),
                 follower_history: HashMap::new(),
+                id_to_tweet_id: HashMap::new(),
                 needs_save: false,
-                caching_permitted: true
+                caching_permitted: true,
+                current_user: User::default()
             }
         }
         fn new_without_caching() -> TwitterCache {
@@ -388,26 +409,27 @@ mod tw {
                         .append(true)
                         .open(TwitterCache::USERS_CACHE)
                         .unwrap();
-                writeln!(file, "{}", serde_json::to_string(&user).unwrap());
+                writeln!(file, "{}", serde_json::to_string(&user).unwrap()).unwrap();
                 self.users.insert(user.id.to_owned(), user);
             }
         }
 
         fn cache_tweet(&mut self, tweet: Tweet) {
             if !self.tweets.contains_key(&tweet.id) {
+
                 let mut file =
                     OpenOptions::new()
                         .create(true)
                         .append(true)
                         .open(TwitterCache::TWEET_CACHE)
                         .unwrap();
-                writeln!(file, "{}", serde_json::to_string(&tweet).unwrap());
-                self.tweets.insert(tweet.id.to_owned(), tweet);
+                writeln!(file, "{}", serde_json::to_string(&tweet).unwrap()).unwrap();
+                self.number_and_insert_tweet(tweet);
             }
         }
         pub fn store_cache(&self) {
             if Path::new(TwitterCache::PROFILE_DIR).is_dir() {
-                let mut profile = OpenOptions::new()
+                let profile = OpenOptions::new()
                     .write(true)
                     .create(true)
                     .append(false)
@@ -419,19 +441,28 @@ mod tw {
             }
             // store cache
         }
+        fn number_and_insert_tweet(&mut self, mut tw: Tweet) {
+            if !self.tweets.contains_key(&tw.id.to_owned()) {
+                if tw.internal_id == 0 {
+                    tw.internal_id = (self.tweets.len() as u64) + 1;
+                    self.id_to_tweet_id.insert(tw.internal_id, tw.id.to_owned());
+                    self.tweets.insert(tw.id.to_owned(), tw);
+                }
+            }
+        }
         pub fn load_cache() -> TwitterCache {
             if Path::new(TwitterCache::PROFILE_CACHE).is_file() {
                 let mut buf = vec![];
                 let mut profile = File::open(TwitterCache::PROFILE_CACHE).unwrap();
                 match profile.read_to_end(&mut buf) {
-                    Ok(sz) => {
+                    Ok(_sz) => {
                         match serde_json::from_slice(&buf) {
                             Ok(result) => {
                                 let mut cache: TwitterCache = result;
                                 cache.tweets = HashMap::new();
                                 for line in BufReader::new(File::open(TwitterCache::TWEET_CACHE).unwrap()).lines() {
                                     let t: Tweet = serde_json::from_str(&line.unwrap()).unwrap();
-                                    cache.tweets.insert(t.id.to_owned(), t);
+                                    cache.number_and_insert_tweet(t);
                                 }
                                 for line in BufReader::new(File::open(TwitterCache::USERS_CACHE).unwrap()).lines() {
                                     let u: User = serde_json::from_str(&line.unwrap()).unwrap();
@@ -501,6 +532,8 @@ mod tw {
                 Some("follow") => {
                     let follower = json["source"]["id_str"].as_str().unwrap().to_string();
                     let followed = json["target"]["id_str"].as_str().unwrap().to_string();
+                    self.cache_api_user(json["target"].clone());
+                    self.cache_api_user(json["source"].clone());
                     if follower == "iximeow" {
                         // self.add_follow(
                     } else {
@@ -510,6 +543,8 @@ mod tw {
                 Some("unfollow") => {
                     let follower = json["source"]["id_str"].as_str().unwrap().to_string();
                     let followed = json["target"]["id_str"].as_str().unwrap().to_string();
+                    self.cache_api_user(json["target"].clone());
+                    self.cache_api_user(json["source"].clone());
                     if follower == "iximeow" {
                         // self.add_follow(
                     } else {
@@ -521,6 +556,10 @@ mod tw {
                 /* nothing else to care about now, i think? */
             }
         }
+        pub fn tweet_by_innerid(&self, inner_id: u64) -> Option<&Tweet> {
+            let id = &self.id_to_tweet_id[&inner_id];
+            self.retrieve_tweet(id)
+        }
         pub fn retrieve_tweet(&self, tweet_id: &String) -> Option<&Tweet> {
             self.tweets.get(tweet_id)
         }
@@ -600,13 +639,17 @@ mod tw {
         }
 
         fn look_up_user(&mut self, id: &str, queryer: &mut ::Queryer) -> Option<serde_json::Value> {
-            let url = &format!("{}?user_id={}", ::user_lookup_url, id);
-            queryer.do_api_req(url)
+            let url = &format!("{}?user_id={}", ::USER_LOOKUP_URL, id);
+            queryer.do_api_get(url)
         }
 
         fn look_up_tweet(&mut self, id: &str, queryer: &mut ::Queryer) -> Option<serde_json::Value> {
-            let url = &format!("{}?id={}", ::tweet_lookup_url, id);
-            queryer.do_api_req(url)
+            let url = &format!("{}?id={}", ::TWEET_LOOKUP_URL, id);
+            queryer.do_api_get(url)
+        }
+
+        pub fn get_settings(&self, queryer: &mut ::Queryer) -> Option<serde_json::Value> {
+            queryer.do_api_get(::ACCOUNT_SETTINGS_URL)
         }
     }
 }
@@ -617,12 +660,17 @@ pub struct Queryer {
 }
 
 impl Queryer {
-    fn do_api_req(&mut self, url: &str) -> Option<serde_json::Value> {
+    fn do_api_get(&mut self, url: &str) -> Option<serde_json::Value> {
         self.issue_request(signed_api_get(url))
     }
+    fn do_api_post(&mut self, url: &str) -> Option<serde_json::Value> {
+        self.issue_request(signed_api_post(url))
+    }
+    /*
     fn do_web_req(&mut self, url: &str) -> Option<serde_json::Value> {
         self.issue_request(signed_web_get(url))
-    }
+    }*/
+    // TODO: make this return the status as well!
     fn issue_request(&mut self, req: hyper::client::Request) -> Option<serde_json::Value> {
         let lookup = self.client.request(req);
 
@@ -644,6 +692,9 @@ impl Queryer {
                 }
             }
             Err(e) => {
+                if status != hyper::StatusCode::Ok {
+                    println!("!! Requests returned status: {}", status);
+                }
                 println!("error deserializing json: {}", e);
                 None
             }
@@ -651,8 +702,35 @@ impl Queryer {
     }
 }
 
+extern crate termion;
+
+use termion::color;
+
+fn color_for(handle: &String) -> termion::color::Fg<&color::Color> {
+    let color_map: Vec<&color::Color> = vec![
+        &color::Blue,
+        &color::Cyan,
+        &color::Green,
+        &color::LightBlue,
+        &color::LightCyan,
+        &color::LightGreen,
+        &color::LightMagenta,
+        &color::LightYellow,
+        &color::Magenta,
+        &color::Yellow
+    ];
+
+    let mut quot_hash_quot = std::num::Wrapping(0);
+    for b in handle.as_bytes().iter() {
+        quot_hash_quot = quot_hash_quot + std::num::Wrapping(*b);
+    }
+    color::Fg(color_map[quot_hash_quot.0 as usize % color_map.len()])
+}
+
 
-fn render_twete(twete: &tw::Tweet, tweeter: &tw::TwitterCache) {
+fn render_twete(twete_id: &String, tweeter: &tw::TwitterCache) {
+    let id_color = color::Fg(color::Rgb(180, 80, 40));
+    let twete = tweeter.retrieve_tweet(twete_id).unwrap();
     // if we got the tweet, the API gave us the user too
     let user = tweeter.retrieve_user(&twete.author_id).unwrap();
     match twete.rt_tweet {
@@ -661,25 +739,47 @@ fn render_twete(twete: &tw::Tweet, tweeter: &tw::TwitterCache) {
             let rt = tweeter.retrieve_tweet(rt_id).unwrap();
             // and its author
             let rt_author = tweeter.retrieve_user(&rt.author_id).unwrap();
-            println!("{} (@{}) via {} (@{}) RT:                           https://twitter.com/i/web/status/{}", rt_author.name, rt_author.handle, user.name, user.handle, rt.id);
+            println!("{}  id:{} (rt_id:{}){}",
+                id_color, rt.internal_id, twete.internal_id, color::Fg(color::Reset)
+            );
+            println!("  {}{}{} ({}@{}{}) via {}{}{} ({}@{}{}) RT:",
+                color_for(&rt_author.handle), rt_author.name, color::Fg(color::Reset),
+                color_for(&rt_author.handle), rt_author.handle, color::Fg(color::Reset),
+                color_for(&user.handle), user.name, color::Fg(color::Reset),
+                color_for(&user.handle), user.handle, color::Fg(color::Reset)
+            );
         }
         None => {
-            println!("{} (@{})                                            https://twitter.com/i/web/status/{}", user.name, user.handle, twete.id);
+            println!("{}  id:{}{}",
+                id_color, twete.internal_id, color::Fg(color::Reset)
+            );
+            println!("  {}{}{} ({}@{}{})",
+                color_for(&user.handle), user.name, color::Fg(color::Reset),
+                color_for(&user.handle), user.handle, color::Fg(color::Reset)
+            );
         }
     }
 
-    println!("{}", twete.text);
+    println!("      {}", twete.text.split("\n").collect::<Vec<&str>>().join("\n      "));
 
     if let Some(ref qt_id) = twete.quoted_tweet_id {
-        let qt = tweeter.retrieve_tweet(qt_id).unwrap();
-        let qt_author = tweeter.retrieve_user(&qt.author_id).unwrap();
-        println!(
-            "  {} (@{})                                             https://twitter.com/i/web/status/{}\n    {}",
-            qt_author.name,
-            qt_author.handle,
-            qt.id,
-            qt.text.split("\n").collect::<Vec<&str>>().join("\n    ")
-        );
+        if let Some(ref qt) = tweeter.retrieve_tweet(qt_id) {
+            let qt_author = tweeter.retrieve_user(&qt.author_id).unwrap();
+            println!("{}    id:{}{}",
+                id_color, qt.internal_id, color::Fg(color::Reset)
+            );
+            println!(
+                "    {}{}{} ({}@{}{})",
+                color_for(&qt_author.handle), qt_author.name, color::Fg(color::Reset),
+                color_for(&qt_author.handle), qt_author.handle, color::Fg(color::Reset)
+            );
+            println!(
+                "        {}",
+                qt.text.split("\n").collect::<Vec<&str>>().join("\n        ")
+            );
+        } else {
+            println!("    << don't have quoted tweet! >>");
+        }
     }
 }
 
@@ -693,25 +793,49 @@ fn render_twitter_event(
             event.render(&tweeter);
         };
     } else if structure.contains_key("friends") {
+//        println!("welcome: {:?}", structure);
         let user_id_nums = structure["friends"].as_array().unwrap();
         let user_id_strs = user_id_nums.into_iter().map(|x| x.as_u64().unwrap().to_string());
         tweeter.set_following(user_id_strs.collect());
+        let settings = tweeter.get_settings(queryer).unwrap();
+        let maybe_my_name = settings["screen_name"].as_str();
+        if let Some(my_name) = maybe_my_name {
+            tweeter.current_user = tw::User {
+                id: "".to_string(),
+                handle: my_name.to_owned(),
+                name: my_name.to_owned()
+            };
+            println!("You are {}", tweeter.current_user.handle);
+        } else {
+            println!("Unable to make API call to figure out who you are...");
+        }
     } else if structure.contains_key("delete") {
-        println!("delete...");
         let deleted_user_id = structure["delete"]["status"]["user_id_str"].as_str().unwrap().to_string();
+        let deleted_tweet_id = structure["delete"]["status"]["id_str"].as_str().unwrap().to_string();
         if let Some(handle) = tweeter.retrieve_user(&deleted_user_id).map(|x| &x.handle) {
-            println!("who? {} - {}", deleted_user_id, handle);
+            if let Some(_tweet) = tweeter.retrieve_tweet(&deleted_tweet_id) {
+                println!("-------------DELETED------------------");
+                render_twete(&deleted_tweet_id, tweeter);
+                println!("-------------DELETED------------------");
+            } else {
+                println!("dunno what, but do know who: {} - {}", deleted_user_id, handle);
+            }
         } else {
+            println!("delete...");
             println!("dunno who...");
         }
     } else if structure.contains_key("user") && structure.contains_key("id") {
         let twete_id = structure["id_str"].as_str().unwrap().to_string();
         tweeter.cache_api_tweet(serde_json::Value::Object(structure));
-        render_twete(tweeter.retrieve_tweet(&twete_id).unwrap(), tweeter);
+        render_twete(&twete_id, tweeter);
+    } else if structure.contains_key("direct_message") {
+        // show DM
+        println!("{}", structure["direct_message"]["text"].as_str().unwrap());
+        println!("Unknown struture {:?}", structure);
     }
     println!("");
 }
-
+/*
 fn signed_web_get(url: &str) -> hyper::client::Request {
 //    let params: Vec<(String, String)> = vec![("track".to_string(), "london".to_string())];
     let params: Vec<(String, String)> = vec![];
@@ -740,46 +864,52 @@ fn signed_web_get(url: &str) -> hyper::client::Request {
     {
         let mut headers = req.headers_mut();
         headers.set(Cookie(format!("auth_token={}", lol_auth_token)));
-        headers.set(Accept("*/*".to_owned()));
+        headers.set(Accept("* / *".to_owned()));
         headers.set(ContentType("application/x-www-form-urlencoded".to_owned()));
     };
 
     req
 }
+*/
+
+fn signed_api_post(url: &str) -> hyper::client::Request {
+    signed_api_req(url, Method::Post)
+}
 
 fn signed_api_get(url: &str) -> hyper::client::Request {
+    signed_api_req(url, Method::Get)
+}
+
+fn signed_api_req(url: &str, method: Method) -> hyper::client::Request {
 //    let params: Vec<(String, String)> = vec![("track".to_string(), "london".to_string())];
+    let method_string = match method {
+        Method::Get => "GET",
+        Method::Post => "POST",
+        _ => panic!(format!("unsupported method {}", method))
+    };
+
     let params: Vec<(String, String)> = vec![];
-    let param_string: String = params.iter().map(|p| p.0.clone() + &"=".to_string() + &p.1).collect::<Vec<String>>().join("&");
+    let _param_string: String = params.iter().map(|p| p.0.clone() + &"=".to_string() + &p.1).collect::<Vec<String>>().join("&");
 
-    let header = oauthcli::authorization_header(
-        "GET",
-        url::Url::parse(url).unwrap(),
-        None, // Realm
+    let header = oauthcli::OAuthAuthorizationHeaderBuilder::new(
+        method_string,
+        &url::Url::parse(url).unwrap(),
         consumer_key,
         consumer_secret,
-        Some(token),
-        Some(token_secret),
         oauthcli::SignatureMethod::HmacSha1,
-        &oauthcli::timestamp(),
-        &oauthcli::nonce(),
-        None, // oauth_callback
-        None, // oauth_verifier
-        params.clone().into_iter()
-    );
+    )
+    .token(token, token_secret)
+    .finish();
 
-    let mut req = Request::new(Method::Get, url.parse().unwrap());
-
-    req.set_body(param_string);
+    let mut req = Request::new(method, url.parse().unwrap());
 
     {
-        println!("{}", header.to_owned());
-        let mut headers = req.headers_mut();
-        headers.set(Authorization(header.to_owned()));
+        let headers = req.headers_mut();
+        headers.set(Authorization(header.to_string()));
         headers.set(Accept("*/*".to_owned()));
-        headers.set(ContentType("application/x-www-form-urlencoded".to_owned()));
     };
 
+//    println!("Request built: {:?}", req);
     req
 }
 
@@ -802,15 +932,14 @@ fn main() {
 
     println!("starting!");
 
-    let (ui_tx, ui_rx) = chan::sync::<Vec<u8>>(0);
+    let (ui_tx, mut ui_rx) = chan::sync::<Vec<u8>>(0);
 
-    let twete_rx = connect_twitter_stream();
+    let mut twete_rx = connect_twitter_stream();
 
     std::thread::spawn(move || {
-        use std::io::Read;
         loop {
             let mut line = String::new();
-            std::io::stdin().read_line(&mut line);
+            std::io::stdin().read_line(&mut line).unwrap();
             ui_tx.send(line.into_bytes());
         }
     });
@@ -829,24 +958,41 @@ fn main() {
 
     let c2 = Core::new().unwrap(); // i swear this is not where the botnet lives
     let handle = &c2.handle();
-    let secondaryConnector = HttpsConnector::new(4, handle).unwrap();
+    let secondary_connector = HttpsConnector::new(4, handle).unwrap();
 
-    let secondaryClient = Client::configure()
-        .connector(secondaryConnector)
+    let secondary_client = Client::configure()
+        .connector(secondary_connector)
         .build(handle);
 
     let mut queryer = Queryer {
-        client: secondaryClient,
+        client: secondary_client,
         core: c2
     };
 
     loop {
-        let ui_rx_b = &ui_rx;
+        match do_ui(ui_rx, twete_rx, &mut tweeter, &mut queryer) {
+            Some((new_ui_rx, new_twete_rx)) => {
+                ui_rx = new_ui_rx;
+                twete_rx = new_twete_rx;
+            },
+            None => {
+                break;
+            }
+        }
+    }
+
+    println!("Bye bye");
+}
+
+fn do_ui(ui_rx_orig: chan::Receiver<Vec<u8>>, twete_rx: chan::Receiver<Vec<u8>>, mut tweeter: &mut tw::TwitterCache, mut queryer: &mut ::Queryer) -> Option<(chan::Receiver<Vec<u8>>, chan::Receiver<Vec<u8>>)> {
+    loop {
+        let ui_rx_a = &ui_rx_orig;
+        let ui_rx_b = &ui_rx_orig;
         chan_select! {
             twete_rx.recv() -> twete => match twete {
                 Some(line) => {
                     let jsonstr = std::str::from_utf8(&line).unwrap().trim();
-//                            println!("{}", jsonstr);
+//                    println!("{}", jsonstr);
                     /* TODO: replace from_str with from_slice */
                     let json: serde_json::Value = serde_json::from_str(&jsonstr).unwrap();
                     display_event(json, &mut tweeter, &mut queryer);
@@ -858,13 +1004,19 @@ fn main() {
                     println!("Twitter stream hung up...");
                     chan_select! {
                         ui_rx_b.recv() -> input => match input {
-                            Some(line) => handle_user_input(line, &mut tweeter, &mut queryer),
+                            Some(line) => {
+                                if line == "reconnect\n".as_bytes() {
+                                    return Some((ui_rx_orig.clone(), connect_twitter_stream()));
+                                } else {
+                                    handle_user_input(line, &mut tweeter, &mut queryer);
+                                }
+                            }
                             None => std::process::exit(0)
                         }
                     }
                 }
             },
-            ui_rx.recv() -> user_input => match user_input {
+            ui_rx_a.recv() -> user_input => match user_input {
                 Some(line) => {
                     handle_user_input(line, &mut tweeter, &mut queryer);
                 },
@@ -872,12 +1024,43 @@ fn main() {
             }
         }
     }
+}
 
-    println!("Bye bye");
+fn url_encode(s: &str) -> String {
+    s
+        .replace(" ", "+")
+        .replace("%", "%25")
+        .replace("\\n", "%0d")
+        .replace("!", "%21")
+        .replace("#", "%23")
+        .replace("&", "%26")
+        .replace("'", "%27")
+        .replace("(", "%28")
+        .replace(")", "%29")
+        .replace("*", "%2a")
+//                            .replace("+", "%2b")
+        .replace(",", "%2c")
+        .replace("-", "%2d")
+        .replace(".", "%2e")
+        .replace("/", "%2f")
+        .replace(":", "%3a")
+        .replace(">", "%3e")
+        .replace("<", "%3c")
+        .replace("?", "%3f")
+        .replace("@", "%40")
+        .replace("\\", "%5c")
 }
 
-fn handle_user_input(line: Vec<u8>, tweeter: &mut tw::TwitterCache, mut queryer: &mut Queryer) {
-    if line == String::from("show_cache\n").into_bytes() {
+struct Command {
+    keyword: &'static str,
+    params: u8,
+    exec: fn(line: String, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer)
+}
+
+static SHOW_CACHE: Command = Command {
+    keyword: "show_cache",
+    params: 0,
+    exec: |_line: String, tweeter: &mut tw::TwitterCache, mut queryer: &mut Queryer| {
         println!("----* USERS *----");
         for (uid, user) in &tweeter.users {
             println!("User: {} -> {:?}", uid, user);
@@ -896,28 +1079,250 @@ fn handle_user_input(line: Vec<u8>, tweeter: &mut tw::TwitterCache, mut queryer:
                 None => { println!("  ..."); }
             }
         }
-    } else if line == String::from("q\n").into_bytes() {
+    }
+};
+
+static QUIT: Command = Command {
+    keyword: "q",
+    params: 0,
+    exec: |_line: String, tweeter: &mut tw::TwitterCache, _queryer: &mut Queryer| {
         println!("Bye bye!");
         tweeter.store_cache();
         std::process::exit(0);
-    } else if line.starts_with("look_up_".as_bytes()) {
-        let linestr = std::str::from_utf8(&line).unwrap().trim();
-        if linestr.starts_with("look_up_tweet") {
-            let tweetid = &linestr.split(" ").collect::<Vec<&str>>()[1].to_string();
-            if let Some(tweet) = tweeter.fetch_tweet(tweetid, &mut queryer) {
-                println!("{:?}", tweet);
+    }
+};
+
+static LOOK_UP_USER: Command = Command {
+    keyword: "look_up_user",
+    params: 1,
+    exec: |line: String, tweeter: &mut tw::TwitterCache, mut queryer: &mut Queryer| {
+        if let Some(user) = tweeter.fetch_user(&line, &mut queryer) {
+            println!("{:?}", user);
+        } else {
+//            println!("Couldn't retrieve {}", userid);
+        }
+    }
+};
+
+static LOOK_UP_TWEET: Command = Command {
+    keyword: "look_up_tweet",
+    params: 1,
+    exec: |line: String, tweeter: &mut tw::TwitterCache, mut queryer: &mut Queryer| {
+        if let Some(tweet) = tweeter.fetch_tweet(&line, &mut queryer) {
+            println!("{:?}", tweet);
+        } else {
+//            println!("Couldn't retrieve {}", tweetid);
+        }
+    }
+};
+
+static VIEW: Command = Command {
+    keyword: "view",
+    params: 1,
+    exec: |line: String, tweeter: &mut tw::TwitterCache, _queryer: &mut Queryer| {
+        // TODO handle this unwrap
+        let inner_twid = u64::from_str(&line).unwrap();
+        let twete = tweeter.tweet_by_innerid(inner_twid).unwrap();
+        render_twete(&twete.id, tweeter);
+        println!("link: https://twitter.com/i/web/status/{}", twete.id);
+    }
+};
+
+static UNFAV: Command = Command {
+    keyword: "unfav",
+    params: 1,
+    exec: |line: String, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer| {
+        // TODO handle this unwrap
+        let inner_twid = u64::from_str(&line).unwrap();
+        let twete = tweeter.tweet_by_innerid(inner_twid).unwrap();
+        queryer.do_api_post(&format!("{}?id={}", UNFAV_TWEET_URL, twete.id));
+    }
+};
+
+static FAV: Command = Command {
+    keyword: "fav",
+    params: 1,
+    exec: |line: String, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer| {
+        // TODO handle this unwrap
+        let inner_twid = u64::from_str(&line).unwrap();
+        let twete = tweeter.tweet_by_innerid(inner_twid).unwrap();
+        queryer.do_api_post(&format!("{}?id={}", FAV_TWEET_URL, twete.id));
+    }
+};
+
+static DEL: Command = Command {
+    keyword: "del",
+    params: 1,
+    exec: |line: String, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer| {
+        let inner_twid = u64::from_str(&line).unwrap();
+        let twete = tweeter.tweet_by_innerid(inner_twid).unwrap();
+        queryer.do_api_post(&format!("{}/{}.json", DEL_TWEET_URL, twete.id));
+    }
+};
+
+static TWETE: Command = Command {
+    keyword: "t",
+    params: 1,
+    exec: |line: String, _tweeter: &mut tw::TwitterCache, queryer: &mut Queryer| {
+        let text = line.trim();
+        let substituted = url_encode(text);
+        println!("msg len: {}", text.len());
+        println!("excessively long? {}", text.len() > 140);
+        if text.len() > 140 {
+            queryer.do_api_post(&format!("{}?status={}", CREATE_TWEET_URL, substituted));
+        } else {
+            queryer.do_api_post(&format!("{}?status={}&weighted_character_count=true", CREATE_TWEET_URL, substituted));
+        }
+//        println!("{}", &format!("{}?status={}", CREATE_TWEET_URL, substituted));
+    }
+};
+
+static THREAD: Command = Command {
+    keyword: "thread",
+    params: 2,
+    exec: |line: String, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer| {
+        let mut text: String = line.trim().to_string();
+        if let Some(id_end_idx) = text.find(" ") {
+            let reply_bare = text.split_off(id_end_idx + 1);
+            let reply = reply_bare.trim();
+            let id_str = text.trim();
+            if reply.len() > 0 {
+                if let Some(inner_twid) = u64::from_str(&id_str).ok() {
+                    if let Some(twete) = tweeter.tweet_by_innerid(inner_twid) {
+                        let handle = &tweeter.retrieve_user(&twete.author_id).unwrap().handle;
+                        // TODO: definitely breaks if you change your handle right now
+                        if handle == &tweeter.current_user.handle {
+                            let substituted = url_encode(reply);
+                            queryer.do_api_post(&format!("{}?status={}&in_reply_to_status_id={}", CREATE_TWEET_URL, substituted, twete.id));
+                        } else {
+                            println!("you can only thread your own tweets");
+                            // ask if it should .@ instead?
+                        }
+                        let substituted = url_encode(reply);
+                        queryer.do_api_post(&format!("{}?status={}&in_reply_to_status_id={}", CREATE_TWEET_URL, substituted, twete.id));
+                    }
+                }
             } else {
-//                                        println!("Couldn't retrieve {}", tweetid);
+                println!("thread <id> your sik reply");
             }
-        } else if linestr.starts_with("look_up_user") {
-            let userid = &linestr.split(" ").collect::<Vec<&str>>()[1].to_string();
-            if let Some(user) = tweeter.fetch_user(userid, &mut queryer) {
-                println!("{:?}", user);
+        } else {
+            println!("thread <id> your sik reply");
+        }
+    }
+};
+
+static REP: Command = Command {
+    keyword: "rep",
+    params: 2,
+    exec: |line: String, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer| {
+        let mut text: String = line.trim().to_string();
+        if let Some(id_end_idx) = text.find(" ") {
+            let reply_bare = text.split_off(id_end_idx + 1);
+            let reply = reply_bare.trim();
+            let id_str = text.trim();
+            if reply.len() > 0 {
+                if let Some(inner_twid) = u64::from_str(&id_str).ok() {
+                    if let Some(twete) = tweeter.tweet_by_innerid(inner_twid) {
+                        let substituted = url_encode(reply);
+                        queryer.do_api_post(&format!("{}?status={}&in_reply_to_status_id={}", CREATE_TWEET_URL, substituted, twete.id));
+                    }
+                }
             } else {
-//                                        println!("Couldn't retrieve {}", userid);
+                println!("rep <id> your sik reply");
             }
+        } else {
+            println!("rep <id> your sik reply");
         }
     }
+};
+
+static QUOTE: Command = Command {
+    keyword: "qt",
+    params: 2,
+    exec: |line: String, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer| {
+        let mut text: String = line.trim().to_string();
+        if let Some(id_end_idx) = text.find(" ") {
+            let reply_bare = text.split_off(id_end_idx + 1);
+            let reply = reply_bare.trim();
+            let id_str = text.trim();
+            if reply.len() > 0 {
+                if let Some(inner_twid) = u64::from_str(&id_str).ok() {
+                    if let Some(twete) = tweeter.tweet_by_innerid(inner_twid) {
+                        let substituted = url_encode(reply);
+                        let attachment_url = url_encode(
+                            &format!(
+                                "https://www.twitter.com/{}/status/{}",
+                                tweeter.retrieve_user(&twete.author_id).unwrap().handle,
+                                twete.id
+                            )
+                        );
+                        println!("{}", substituted);
+                        queryer.do_api_post(
+                            &format!("{}?status={}&attachment_url={}",
+                                     CREATE_TWEET_URL,
+                                     substituted,
+                                     attachment_url
+                            )
+                        );
+                    }
+                }
+            } else {
+                println!("rep <id> your sik reply");
+            }
+        } else {
+            println!("rep <id> your sik reply");
+        }
+    }
+};
+
+static RETWETE: Command = Command {
+    keyword: "rt",
+    params: 1,
+    exec: |line: String, tweeter: &mut tw::TwitterCache, queryer: &mut Queryer| {
+        let inner_twid = u64::from_str(&line).unwrap();
+        let twete = tweeter.tweet_by_innerid(inner_twid).unwrap();
+        queryer.do_api_post(&format!("{}/{}.json", RT_TWEET_URL, twete.id));
+    }
+};
+
+fn parse_word_command<'a, 'b>(line: &'b str, commands: Vec<&'a Command>) -> Option<(&'b str, &'a Command)> {
+    for cmd in commands.into_iter() {
+        if cmd.params == 0 {
+            if line == cmd.keyword {
+                return Some(("", &cmd));
+            }
+        } else if line.starts_with(cmd.keyword) {
+            // let inner_twid = u64::from_str(&linestr.split(" ").collect::<Vec<&str>>()[1]).unwrap();
+            return Some((line.get((cmd.keyword.len() + 1)..).unwrap().trim(), &cmd));
+        }
+    }
+    return None
+}
+
+fn handle_user_input(line: Vec<u8>, tweeter: &mut tw::TwitterCache, mut queryer: &mut Queryer) {
+    let commands = vec![
+        &SHOW_CACHE,
+        &QUIT,
+        &LOOK_UP_USER,
+        &LOOK_UP_TWEET,
+        &VIEW,
+        &UNFAV,
+        &FAV,
+        &DEL,
+        &TWETE,
+        &QUOTE,
+        &RETWETE,
+        &REP,
+        &THREAD
+    ];
+    let command_bare = String::from_utf8(line).unwrap();
+    let command = command_bare.trim();
+    if let Some((line, cmd)) = parse_word_command(&command, commands) {
+        (cmd.exec)(line.to_owned(), tweeter, &mut queryer);
+    } else {
+        println!("I don't know what {} means", command);
+    }
+    println!(""); // temporaryish because there's no visual distinction between output atm
 }
 
 fn connect_twitter_stream() -> chan::Receiver<Vec<u8>> {
@@ -936,14 +1341,15 @@ fn connect_twitter_stream() -> chan::Receiver<Vec<u8>> {
     //    println!("{}", do_web_req("https://caps.twitter.com/v2/capi/passthrough/1?twitter:string:card_uri=card://887655800482787328&twitter:long:original_tweet_id=887655800981925888&twitter:string:response_card_name=poll3choice_text_only&twitter:string:cards_platform=Web-12", &client, &mut core).unwrap());
     //    println!("{}", look_up_tweet("887655800981925888", &client, &mut core).unwrap());
 
-        let req = signed_api_get(streamurl);
+        let req = signed_api_get(STREAMURL);
         let work = client.request(req).and_then(|res| {
             let status = res.status();
             if status != hyper::StatusCode::Ok {
                 println!("Twitter stream connect was abnormal: {}", status);
+                println!("result: {:?}", res);
             }
             LineStream::new(res.body()
-                .map(|chunk| futures::stream::iter(chunk.into_iter().map(|b| Ok(b))))
+                .map(|chunk| futures::stream::iter_ok(chunk.into_iter()))
                 .flatten())
                 .for_each(|s| {
                     if s.len() != 1 {
@@ -955,7 +1361,7 @@ fn connect_twitter_stream() -> chan::Receiver<Vec<u8>> {
 
         let resp = core.run(work);
         match resp {
-            Ok(good) => (),
+            Ok(_good) => (),
             Err(e) => println!("Error in setting up: {}", e)
         }
     });