</form>   

                </form>

            <span class="pending">{{delegate}}</span>

                <form id="delegate-{{ delegate.csrf }}" action="delegate.do" method="post">
                <fieldset>
                    <label for="submit">{{delegate.name}}</label>
                    <input name="csrf" type="hidden" value="{{ delegate.csrf }}">
                    {{#if delegate.accept}}
                    <input name="submit" type="submit" value="Accept Delegate">
                    {{/if}}
                    <input name="submit" type="submit" value="Reject Delegate">
                </fieldset>
                </form>

#[derive(serde_derive::Serialize)]
struct PendingDelegateInfo {
    csrf: Uuid,
    name: String,
    accept: bool,
}

    pending_delegates: Option<Vec<String>>,

    pending_delegates: Option<Vec<PendingDelegateInfo>>,

}
#[derive(serde_derive::Deserialize)]
pub struct DelegationData {
    csrf: Uuid,
    submit: String,

                let mut cache = data.cache_delegation_game.lock().await;

                        .map(std::string::String::clone)

                        .map(|x| {
                            let csrf = Uuid::new_v4();
                            cache.insert(
                                csrf,
                                (gameuid.clone(), user.to_lowercase(), x.to_lowercase()),
                                std::time::Duration::from_secs(data.cache_duration_sec),
                            );
                            PendingDelegateInfo {
                                csrf,
                                name: x.clone(),
                                accept: false,
                            }
                        })

                Some([user].into_iter().map(std::string::String::clone).collect())

                let csrf = Uuid::new_v4();
                let mut cache = data.cache_delegation_game.lock().await;
                cache.insert(
                    csrf,
                    (
                        gameuid.clone(),
                        player_name.to_lowercase(),
                        user.to_lowercase(),
                    ),
                    std::time::Duration::from_secs(data.cache_duration_sec),
                );
                Some(
                    [PendingDelegateInfo {
                        csrf,
                        name: user.clone(),
                        accept: true,
                    }]
                    .into_iter()
                    .collect(),
                )

pub async fn post_delegate(
    request: HttpRequest,
    form: web::Form<DelegationData>,
    data: web::Data<WebData<'_>>,
    data_rw: web::Data<DataBaseRw>,
) -> HttpResponse {
    let cached_data = {
        let mut cache = data.cache_delegation_game.lock().await;
        cache.remove(&form.csrf)
    };
    let cached_data = if let Some(cd) = cached_data {
        cd
    } else {
        log::warn!("Unknown data for CSRF: {}", form.csrf);
        return HttpResponse::BadRequest().body("Incorrect");
    };
    let jar = request_to_jar(request);
    let user = if let Some(u) = jar
        .private(&data.cookies_key)
        .get("auth")
        .map(|x| x.value().to_lowercase())
    {
        u
    } else {
        log::warn!("Incorrect user");
        return HttpResponse::BadRequest().body("Incorrect");
    };
    if form.submit == "Accept Delegate" && user == cached_data.2 {
        let dbclient_rw = match data_rw.0.get().await {
            Ok(c) => c,
            Err(e) => {
                log::error!("Pool RW error {}", e);
                return HttpResponse::ServiceUnavailable().body(actix_web::body::None::new());
            }
        };
        match dbclient_rw
            .execute(
                "delete from games.query_delegation where game_uid = $1 and player_name = $2;",
                &[&cached_data.0, &cached_data.1],
            )
            .await
        {
            Ok(_) => (),
            Err(e) => {
                log::error!("Pool RW statement error {}", e);
                return HttpResponse::ServiceUnavailable().body(actix_web::body::None::new());
            }
        };
        match dbclient_rw
            .execute("update games.players set delegate_name = $3 where game_uid = $1 and player_name = $2;", &[&cached_data.0, &cached_data.1, &cached_data.2])
            .await
        {
            Ok(_) => (),
            Err(e) => {
                log::error!("Pool RW statement error {}", e);
                return HttpResponse::ServiceUnavailable().body(actix_web::body::None::new());
            }
        };
    } else if form.submit == "Reject Delegate" && (user == cached_data.1 || user == cached_data.2) {
        let dbclient_rw = match data_rw.0.get().await {
            Ok(c) => c,
            Err(e) => {
                log::error!("Pool RW error {}", e);
                return HttpResponse::ServiceUnavailable().body(actix_web::body::None::new());
            }
        };
        let stmt = match dbclient_rw
            .prepare("delete from games.query_delegation where game_uid = $1 and player_name = $2 and delegate_name = $3;")
            .await
        {
            Ok(stmt) => stmt,
            Err(e) => {
                log::error!("Pool RW statement error {}", e);
                return HttpResponse::ServiceUnavailable().body(actix_web::body::None::new());
            }
        };
        match dbclient_rw
            .execute(&stmt, &[&cached_data.0, &cached_data.1, &cached_data.2])
            .await
        {
            Ok(_) => (),
            Err(e) => {
                log::error!("Pool RW execute insert error {}", e);
                return HttpResponse::ServiceUnavailable().body(actix_web::body::None::new());
            }
        };
    } else {
        log::warn!("Incorrect user submit {}", form.submit);
        return HttpResponse::BadRequest().body("Incorrect");
    }
    HttpResponse::Found()
        .append_header((
            header::LOCATION,
            format!("slow-game-{}.html", cached_data.0),
        ))
        .finish()
}

    pub cache_delegation_game: Mutex<TtlCache<Uuid, (String, String, String)>>,

    post_join_game, post_leave_game, post_query_delegate, post_revoke_delegate, slow_game,

    post_delegate, post_join_game, post_leave_game, post_query_delegate, post_revoke_delegate,
    slow_game,

        cache_delegation_game: tokio::sync::Mutex::new(ttl_cache::TtlCache::new(cache_capacity)),

            .route("/delegate.do", web::post().to(post_delegate))