use diesel::prelude::*;
use diesel;

use schema::{episode, podcast, source};
use models::{Podcast, Source};
use POOL;
use errors::*;

use dbqueries;

#[derive(Insertable)]
#[table_name = "source"]
#[derive(Debug, Clone)]
pub struct NewSource<'a> {
    uri: &'a str,
    last_modified: Option<&'a str>,
    http_etag: Option<&'a str>,
}

impl<'a> NewSource<'a> {
    pub fn new_with_uri(uri: &'a str) -> NewSource {
        NewSource {
            uri,
            last_modified: None,
            http_etag: None,
        }
    }

    fn index(&self) {
        use schema::source::dsl::*;

        let tempdb = POOL.clone().get().unwrap();
        // Throw away the result like `insert or ignore`
        // Diesel deos not support `insert or ignore` yet.
        let _ = diesel::insert_into(source).values(self).execute(&*tempdb);
    }

    // Look out for when tryinto lands into stable.
    pub fn into_source(self) -> QueryResult<Source> {
        self.index();

        dbqueries::get_source_from_uri(self.uri)
    }
}

#[derive(Insertable)]
#[table_name = "episode"]
#[derive(Debug, Clone)]
pub struct NewEpisode<'a> {
    pub title: Option<&'a str>,
    pub uri: Option<&'a str>,
    pub description: Option<&'a str>,
    pub published_date: Option<String>,
    pub length: Option<i32>,
    pub guid: Option<&'a str>,
    pub epoch: i32,
    pub podcast_id: i32,
}

impl<'a> NewEpisode<'a> {
    // TODO: Currently using diesel from master git.
    // Watch out for v0.99.0 beta and change the toml.
    // TODO: Refactor into batch indexes instead.
    pub fn index(&self, con: &SqliteConnection) -> QueryResult<()> {
        use schema::episode::dsl::*;

        let ep = {
            // let tempdb = db.lock().unwrap();
            // dbqueries::get_episode_from_uri(&tempdb, self.uri.unwrap())
            dbqueries::get_episode_from_uri(con, self.uri.unwrap())
        };

        match ep {
            Ok(foo) => if foo.title() != self.title
                || foo.published_date() != self.published_date.as_ref().map(|x| x.as_str())
            {
                // let tempdb = db.lock().unwrap();
                diesel::replace_into(episode).values(self).execute(con)?;
                // .execute(&*tempdb)?;
            },
            Err(_) => {
                // let tempdb = db.lock().unwrap();
                diesel::insert_into(episode).values(self).execute(con)?;
                // .execute(&*tempdb)?;
            }
        }
        Ok(())
    }
}

#[derive(Insertable)]
#[table_name = "podcast"]
#[derive(Debug, Clone)]
pub struct NewPodcast {
    pub title: String,
    pub link: String,
    pub description: String,
    pub image_uri: Option<String>,
    pub source_id: i32,
}

impl NewPodcast {
    // Look out for when tryinto lands into stable.
    pub fn into_podcast(self) -> Result<Podcast> {
        self.index()?;
        let tempdb = POOL.clone().get().unwrap();
        Ok(dbqueries::get_podcast_from_title(&*tempdb, &self.title)?)
    }

    fn index(&self) -> QueryResult<()> {
        use schema::podcast::dsl::*;
        let pd = {
            let tempdb = POOL.clone().get().unwrap();
            dbqueries::get_podcast_from_title(&*tempdb, &self.title)
        };

        match pd {
            Ok(foo) => if foo.link() != self.link {
                let tempdb = POOL.clone().get().unwrap();
                diesel::replace_into(podcast)
                    .values(self)
                    .execute(&*tempdb)?;
            },
            Err(_) => {
                let tempdb = POOL.clone().get().unwrap();
                diesel::insert_into(podcast).values(self).execute(&*tempdb)?;
            }
        }
        Ok(())
    }
}