use super::guards::APIProviderRequest;
use crate::api::guards;
use crate::errors::AutoDecryptError;
use crate::main;
use crate::orm::structures::{ProviderRecord};
use crate::orm::types::{AuthMethod, RecordStates};
use crate::services::providers::{ConsentMethode, ProviderAction, Providers, ActionType};
use crate::app_config::CONFIG;
use crate::orm::DbConn;
use diesel::expression::is_aggregate::No;
use rocket::get;
use rocket::http::Status;
use rocket::State;
use super::HttpResult;

async fn execute_action(action: &Providers, key: Option<&str>) -> Result<String, AutoDecryptError> {

    let exec_action = match &action.execution_action {
        ActionType::ForigneAction(forigne_action) => {
            &forigne_action.to_executable_action(key)? as &dyn ProviderAction
        },
        _ => &action.execution_action as &dyn ProviderAction,
    };

    exec_action.execute().await
}


#[get("/<_>", rank = 1)]
pub(super) async fn request_handler(guard: Result<APIProviderRequest<'_>, HttpResult>, db_conn: &State<DbConn>) -> (Status, HttpResult) {
    // We assume the request guard verified th access_key against the service_name
    if let Err(err) = guard {
        // This wrapper is nessesary to avoid needing to write catchers, and recompute the error
        // See: https://github.com/rwf2/Rocket/issues/749
        return err.into();
    }
    let guard = guard.expect("A rejected request guard was able to perseed!");
    let mut expires_at = None;
    let auth_methode: AuthMethod = AuthMethod::from(&guard.share.consent_methode);
    let result: HttpResult = match guard.share.consent_methode { 
        ConsentMethode::None => {
            // We do not wait for constent, direct feedback is impleied
            match execute_action(guard.share, None).await {
                Ok(response) => HttpResult::UnlockingSucceeded(response),
                Err(err) => HttpResult::UnlockingFailed(err.to_string()),
            }
        },
        _ => {
            expires_at = Some(CONFIG.wait().user_confirmation_expiration);
            HttpResult::AckAuthReq("An auth request has been sent.".to_string())
        },
    };
    let record_state = match &result {
        HttpResult::UnlockingSucceeded(_) => RecordStates::Accepted,
        HttpResult::AckAuthReq(_) => RecordStates::Pending,
        HttpResult::TimelimitExceeded(_) => RecordStates::Expired,
        _ => RecordStates::Rejected,
    };

    db_conn.add_provider_record(&ProviderRecord {
        service_name: guard.name.to_string(),
        expires_at: expires_at, // Convert to sql timestamp + add used auth methode to record in db
        auth_methode: auth_methode,
        state: record_state,
        awnsered_by: None,
    });
    return result.into();

}