use actix_web::{web, HttpResponse};
use diesel::RunQueryDsl;

use crate::{
    database::establish_connection, json_serialization::new_feed::NewFeedSchema,
    models::feed::new_feed::NewFeed, schema::feed,
};

use super::feeds;

pub async fn add(new_feed: web::Json<NewFeedSchema>) -> HttpResponse {
    let mut connection = establish_connection();
    let title: String = new_feed.title.clone();
    let url: String = new_feed.url.clone();
    let user_id: i32 = new_feed.user_id;

    let result = feeds::get_feed(&url).await;
    match result {
        Ok(channel) => {
            log::info!("valid channel");
            if channel.items.is_empty() {
                return HttpResponse::ServiceUnavailable().await.unwrap();
            }
        }
        Err(e) => {
            log::error!("{:?}", e);
            return HttpResponse::NotFound().await.unwrap();
        }
    }

    let new_feed = NewFeed::new(title, url, user_id);

    let insert_result = diesel::insert_into(feed::table)
        .values(&new_feed)
        .execute(&mut connection);

    match insert_result {
        Ok(_) => HttpResponse::Created().await.unwrap(),
        Err(e) => {
            log::error!("{e}");
            HttpResponse::Conflict().await.unwrap()
        }
    }
}

#[cfg(test)]
mod tests {
    use actix_web::http::StatusCode;
    use actix_web::{test, web, App};

    use super::add;
    use crate::test_helpers::unique_suffix;

    #[actix_web::test]
    async fn add_fails_for_unfetchable_feed_url() {
        let app = test::init_service(App::new().route("/add", web::post().to(add))).await;
        let req = test::TestRequest::post()
            .uri("/add")
            .set_json(serde_json::json!({
                "title": "Bad feed",
                "url": format!("not-a-valid-url-{}", unique_suffix()),
                "user_id": 1
            }))
            .to_request();
        let resp = test::call_service(&app, req).await;

        assert_eq!(StatusCode::NOT_FOUND, resp.status());
    }
}