extern crate telegram_bot;
use telegram_bot::{Api, Message, MessageType};
use std::thread;
use std::time::Duration;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};

use feature::FeatureResult;
use feature::Feature;

pub struct Jisoku {
    running: Arc<AtomicBool>,
}

const MESSAGES: [&'static str; 5] = ["JISOKU METER FURIKIRI UBAU GAME",
                                     "I AM A CHASER DARE YORI HAYAI RACE",
                                     "LIFE IS FIRE TSUKIRU MADE HIGH PACE",
                                     "LETS GET READY TO RUMBLE MEZAMERO PASSION",
                                     "*insert dubstep*"];

impl Feature for Jisoku {
    fn name(&self) -> &'static str {
        "Jisoku Meter"
    }
    fn init(&mut self) {}
    fn handle(&mut self, a: Api, m: Message) -> Result<FeatureResult, String> {
        if let MessageType::Text(ref s) = m.msg {
            if !(&s).contains("JISOKU METER") {
                return Ok(FeatureResult::Skip);
            }
        } else {
            return Ok(FeatureResult::Skip);
        }

        if self.running.compare_and_swap(false, true, Ordering::SeqCst) {
            return Ok(FeatureResult::Skip);
        }
        let running = self.running.clone();
        thread::spawn(move || {
            for s in MESSAGES.into_iter() {
                if let Err(e) = a.send_message(m.chat.id(),
                                               (*s).to_owned(),
                                               None,
                                               None,
                                               None,
                                               None) {
                    println!("{}", e);
                    break;
                };
                thread::sleep(Duration::new(1, 0));
            }
            running.store(false, Ordering::SeqCst);
        });
        Ok(FeatureResult::Handled)
    }
}

impl Jisoku {
    pub fn new() -> Jisoku {
        Jisoku { running: Arc::new(AtomicBool::new(false)) }
    }
}