http::{Cookie, CookieJar},

    http::{Cookie, CookieJar, Status},
    request,
    request::{FromRequest, Outcome},

    Route, State,

    Request, Route, State,

use rocket::outcome::try_outcome;

#[get("/new")]

// TODO decide if this routing file is the place for this guard to be at?
#[rocket::async_trait]
impl<'r> FromRequest<'r> for User {
    type Error = ();
    async fn from_request(request: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
        let db = try_outcome!(request.guard::<&State<Database>>().await);
        //            &State<Database>>().await);
        let cookies = request.cookies();
        let some_id = match get_user_id_from_cookie(cookies) {
            Some(id) => id,
            None => return Outcome::Failure((Status::Unauthorized, ())),
        };
        match User::find(db, some_id).await {
            Ok(u) => Outcome::Success(u),
            Err(_e) => Outcome::Failure((Status::Unauthorized, ())),
        }
    }
}
#[get("/new", rank = 2)]

#[get("/new", rank = 1)]
fn new_already_user(_user: User) -> Redirect {
    Redirect::to("/")
}

}
fn get_user_id_from_cookie(jar: &CookieJar) -> Option<i32> {
    match jar.get_private(COOKIE_USER_ID_KEY) {
        Some(id) => Some(id.value().parse::<i32>().ok()?),
        None => None,
    }

    routes![new, create, get_sign_in, sign_in, sign_out]

    routes![
        new,
        new_already_user,
        create,
        get_sign_in,
        sign_in,
        sign_out
    ]

use crate::models::users::User;

fn new() -> Template {

fn new(_user: User) -> Template {

    user: User,

    match projects::create(db, 1, project.name.clone()).await {

    match projects::create(db, user.id, project.name.clone()).await {

#[derive(FromForm)]
struct ChangelistReq {

/// Because of the overlap with other routes in parameters, this route has
/// rank 2. This way the changelist matches first, and if it doesn't, this route
/// will respond. Note that in the push flow this order is reversed.
#[get("/<org_path>/<proj_path>/.pijul?<channel>&<id>", rank = 2)]
async fn remote_id(
    db: &State<Database>,
    repoman: &State<RepoMan>,
    org_path: String,
    proj_path: String,

) -> Option<String> {
    let p = match projects::find(db, org_path, proj_path).await {
        Some(p) => p,
        None => return None,
    };
    match p.repository(&repoman.storage_root) {
        Ok(r) => r.channel_remote_id(channel, id),
        Err(e) => {
            println!("{}", e);
            None
        }
    }

// TODO is this for push and/or pull???
#[get("/<org_path>/<proj_path>/.pijul?<cl_req..>")]

#[get("/<org_path>/<proj_path>/.pijul?<changelist>&<channel>")]

    cl_req: ChangelistReq,

    channel: String, // TODO check if this breaks non-UTF-8 channels
    changelist: u64,

        Ok(r) => r.channel_remote_id(cl_req.channel),

        Ok(r) => r.changelist(channel, changelist).ok(),

            println!("{}", e);

            println!("error getting changelist: {}", e);

    // - Reverse engineer the rest of Push

    routes![changelist]

    routes![remote_id, changelist]

    pub async fn find(db: &State<Database>, id: i32) -> Result<Self, sqlx::Error> {
        query_as!(User, "SELECT * FROM users WHERE id = $1", id)
            .fetch_one(&**db)
            .await
    }

use libpijul::Base32;

use libpijul::TxnTExt;

    pub fn channel_remote_id(&self, channel: String) -> Option<String> {

    pub fn channel_remote_id(&self, channel: String, _id: Option<String>) -> Option<String> {

        //

    // TODO figure out how to stream the response, instead of allocating all now
    pub fn changelist(&self, channel: String, from: u64) -> Result<String, anyhow::Error> {
        let txn = self.pristine()?.mut_txn_begin()?;
        // TODO validate the txn needs closing?
        // TODO validate the txn needs closing?
        //
        // Or does the drop function do that?
        let chan = match txn.load_channel(&channel)? {
            Some(c) => c,
            None => bail!("failed to read channel transaction"),
        };
        let mut out: String = "".to_string();
        for change in txn.log(&chan.read(), from)? {
            let (offset, (hash, merkle)) = change?;
            let h: libpijul::Hash = hash.into();
            let m: libpijul::Merkle = merkle.into();
            out.push_str(format!("{}.{}.{}", offset, h.to_base32(), m.to_base32()).as_str());
        }
        Ok(out)
    }