use clap::Parser;
use std::collections::HashMap;
use std::error::Error;
#[macro_use]
extern crate rocket;
use cached::proc_macro::cached;
use http_cache_reqwest::{CACacheManager, Cache, CacheMode, HttpCache};
use reqwest::StatusCode;
use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
use rocket::response::content::RawHtml;
use rocket::serde::json::Json;

mod cohost_account;
mod cohost_posts;
mod syndication;
mod webfinger;
use cohost_account::{CohostAccount, COHOST_ACCOUNT_API_URL};
use cohost_posts::{cohost_posts_api_url, CohostPost, CohostPostsPage};
use webfinger::CohostWebfingerResource;

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
    /// The base URL for the corobel instance
    #[clap(short, long, required = true)]
    domain: String,
    /// The base URL for the corobel instance
    #[clap(short, long, default_value_t = default_base_url() )]
    base_url: String,
}

fn default_base_url() -> String {
    "/".into()
}

fn user_agent() -> String {
    format!(
        "{}/{} (RSS feed converter) on {}",
        env!("CARGO_PKG_NAME"),
        env!("CARGO_PKG_VERSION"),
        &ARGS.domain
    )
}

static ARGS: once_cell::sync::Lazy<Args> = once_cell::sync::Lazy::new(|| Args::parse());
static CLIENT: once_cell::sync::Lazy<ClientWithMiddleware> = once_cell::sync::Lazy::new(|| {
    ClientBuilder::new(
        reqwest::Client::builder()
            .user_agent(user_agent())
            .build()
            .unwrap(),
    )
    .with(Cache(HttpCache {
        mode: CacheMode::Default,
        manager: CACacheManager::default(),
        options: None,
    }))
    .build()
});

#[get("/")]
fn index() -> RawHtml<&'static str> {
    RawHtml(include_str!("../static/index.html"))
}

#[derive(Responder)]
#[response(content_type = "text/markdown")]
struct MdResponse {
    inner: String,
}

#[derive(Debug, Clone, Responder)]
#[response(content_type = "application/rss+xml")]
struct RssResponse {
    inner: String,
}

#[derive(Debug, Responder)]
#[response(content_type = "text/plain")]
enum ErrorResponse {
    #[response(status = 404)]
    NotFound(String),
    #[response(status = 500)]
    InternalError(String),
}

#[cached(time = 60, result)]
async fn get_post_from_page(project_id: String, post_id: u64) -> Result<CohostPost, ErrorResponse> {
    let mut page = 0;
    loop {
        let new_page = get_page_data(project_id.clone(), page).await?;
        if new_page.items.is_empty() {
            // Once there are no posts, we're done.
            return Err(ErrorResponse::NotFound(
                "End of posts reached, ID not found.".into(),
            ));
        } else {
            page += 1;
            if let Some(post) = new_page.items.into_iter().find(|post| post.id == post_id) {
                return Ok(post);
            }
        }
    }
}

#[cached(time = 120, result)]
async fn get_full_post_data(project_id: String) -> Result<CohostPostsPage, ErrorResponse> {
    let mut page = 0;
    let mut merged_page = get_page_data(project_id.clone(), page).await?;
    loop {
        let mut new_page = get_page_data(project_id.clone(), page).await?;
        if new_page.items.is_empty() {
            // Once there are no posts, we're done.
            break;
        } else {
            page += 1;
            merged_page.number_items += new_page.number_items;
            merged_page.items.append(&mut new_page.items);
        }
    }
    Ok(merged_page)
}

// Not cached because it's never used individually.
async fn get_page_data(project_id: String, page: u64) -> Result<CohostPostsPage, ErrorResponse> {
    let posts_url = cohost_posts_api_url(&project_id, page);
    eprintln!("making request to {}", posts_url);
    match CLIENT.get(posts_url).send().await {
        Ok(v) => match v.status() {
            StatusCode::OK => match v.json::<CohostPostsPage>().await {
                Ok(page_data) => Ok(page_data),
                Err(e) => {
                    let err = format!(
                        "Couldn't deserialize Cohost posts page for '{}': {:?}",
                        project_id, e
                    );
                    eprintln!("{}", err);
                    return Err(ErrorResponse::InternalError(err));
                }
            },
            // TODO NORA: Handle possible redirects
            s => {
                let err = format!("Didn't receive status code 200 for posts for Cohost project '{}'; got {:?} instead.", page, s);
                eprintln!("{}", err);
                return Err(ErrorResponse::NotFound(err));
            }
        },
        Err(e) => {
            let err = format!(
                "Error making request to Cohost for posts for project '{}': {:?}",
                project_id, e
            );
            eprintln!("{}", err);
            return Err(ErrorResponse::InternalError(err));
        }
    }
}

#[cached(time = 60, result)]
async fn get_project_data(project_id: String) -> Result<CohostAccount, ErrorResponse> {
    let project_url = format!("{}{}", COHOST_ACCOUNT_API_URL, project_id);
    eprintln!("making request to {}", project_url);
    match CLIENT.get(project_url).send().await {
        Ok(v) => match v.status() {
            StatusCode::OK => match v.json::<CohostAccount>().await {
                Ok(a) => Ok(a),
                Err(e) => {
                    let err = format!(
                        "Couldn't deserialize Cohost project '{}': {:?}",
                        project_id, e
                    );
                    eprintln!("{}", err);
                    Err(ErrorResponse::InternalError(err))
                }
            },
            // TODO NORA: Handle possible redirects
            s => {
                let err = format!(
                    "Didn't receive status code 200 for Cohost project '{}'; got {:?} instead.",
                    project_id, s
                );
                eprintln!("{}", err);
                Err(ErrorResponse::NotFound(err))
            }
        },
        Err(e) => {
            let err = format!(
                "Error making request to Cohost for project '{}': {:?}",
                project_id, e
            );
            eprintln!("{}", err);
            Err(ErrorResponse::InternalError(err))
        }
    }
}

#[get("/<project>/feed.rss")]
async fn syndication_rss_route(project: String) -> Result<RssResponse, ErrorResponse> {
    let project_data = get_project_data(project.clone()).await?;
    let page_data = get_full_post_data(project.clone()).await?;
    Ok(RssResponse {
        inner: syndication::channel_for_posts_page(project.clone(), project_data, page_data)
            .to_string(),
    })
}

#[get("/<project>/<id>")]
async fn post_md_route(project: String, id: u64) -> Result<MdResponse, ErrorResponse> {
    let _project_data = get_project_data(project.clone()).await?;
    let post_data = get_post_from_page(project.clone(), id).await?;
    Ok(MdResponse {
        inner: post_data.plain_body,
    })
}

#[get("/.well-known/webfinger?<params..>")]
async fn webfinger_route(
    params: HashMap<String, String>,
) -> Result<Json<CohostWebfingerResource>, ErrorResponse> {
    if params.len() != 1 {
        let err = format!(
            "Too may or too few parameters. Expected 1, got {}",
            params.len()
        );
        eprintln!("{}", err);
        return Err(ErrorResponse::InternalError(err));
    }
    if let Some(param) = params.iter().next() {
        let _project_data = get_project_data(param.0.clone()).await?;
        Ok(Json(CohostWebfingerResource::new(
            param.0.as_str(),
            &ARGS.domain,
            &ARGS.base_url,
        )))
    } else {
        Err(ErrorResponse::NotFound("No project ID provided.".into()))
    }
}

#[rocket::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // Set up the global config
    once_cell::sync::Lazy::force(&ARGS);
    let _rocket = rocket::build()
        .mount(
            &ARGS.base_url,
            routes![index, webfinger_route, syndication_rss_route, post_md_route],
        )
        .ignite()
        .await?
        .launch()
        .await?;
    Ok(())
}