pub async fn account_edit_page(

    Path(id): Path<Uuid>,

    State(_data): State<Arc<AppState>>,

    Extension(jwt_auth): Extension<JWTAuthMiddleware>,

) -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {

    let user = &jwt_auth.user;

    let account_result = GetAccount::new()

        .user_id(user.id)

        .account_id(id)

        .run()

        .await

        .map_err(|e| {

            let error_response = serde_json::json!({

                "status": "fail",

                "message": format!("Failed to get account: {e:?}"),

            (StatusCode::INTERNAL_SERVER_ERROR, Json(error_response))

        })?;

    let (account, name) = if let Some(CmdResult::TaggedEntities { entities, .. }) = account_result

        && let Some((FinanceEntity::Account(account), tags)) = entities.into_iter().next()

        let name = if let Some(FinanceEntity::Tag(name_tag)) = tags.get("name") {

            name_tag.tag_value.clone()

            String::new()

        (account, name)

        let error_response = serde_json::json!({

            "status": "fail",

            "message": "Account not found",

        return Err((StatusCode::NOT_FOUND, Json(error_response)));

    let server_user = server::user::User { id: user.id };

    let tags: Vec<finance::tag::Tag> = server_user

        .get_account_tags(&account)

        .await

        .unwrap_or_default()

        .into_iter()

        .filter(|t| t.tag_name != "name")

        .collect();

    let scripts: Vec<ScriptView> = server_user

        .list_scripts()

        .await

        .unwrap_or_default()

        .into_iter()

        .map(|s| ScriptView {

            id: s.id,

            name: s.name,

        })

        .collect();

    let template = AccountEditPage {

        account_id: account.id,

        account_name: name,

        tags,

        scripting_enabled: cfg!(feature = "scripting"),

        scripts,

    };

    Ok(HtmlTemplate(template))

}

pub async fn rename_account(

    State(_data): State<Arc<AppState>>,

    Extension(jwt_auth): Extension<JWTAuthMiddleware>,

    Json(form): Json<RenameForm>,

) -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {

    let user = &jwt_auth.user;

    let server_user = server::user::User { id: user.id };

    let account = Account {

        id: form.account_id,

        parent: None,

    };

    let name_tag = finance::tag::Tag {

        id: Uuid::new_v4(),

        tag_name: "name".to_string(),

        tag_value: form.name,

        description: None,

    };

    server_user

        .set_account_tag(&account, &name_tag)

        .await

        .map_err(|e| {

            let error_response = serde_json::json!({

                "status": "fail",

                "message": t!("Failed to rename account"),

            log::error!("Failed to rename account: {e:?}");

            (StatusCode::INTERNAL_SERVER_ERROR, Json(error_response))

        })?;

    Ok(t!("Account renamed").to_string())

}

pub async fn account_tags_submit(

    Path(id): Path<Uuid>,

    State(_data): State<Arc<AppState>>,

    Extension(jwt_auth): Extension<JWTAuthMiddleware>,

    Json(form): Json<AccountTagsForm>,

) -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {

    let user = &jwt_auth.user;

    let server_user = server::user::User { id: user.id };

    let account = Account { id, parent: None };

    let existing_tags = server_user

        .get_account_tags(&account)

        .await

        .unwrap_or_default();

    for tag in &existing_tags {

        if tag.tag_name != "name" {

            let _ = server_user.delete_tag(tag.id).await;

        }

    for tag_data in form.tags {

        if tag_data.name == "name" {

            continue;

        }

        server_user

            .create_account_tag(id, tag_data.name, tag_data.value, tag_data.description)

            .await

            .map_err(|e| {

                let error_response = serde_json::json!({

                    "status": "fail",

                    "message": format!("Failed to create account tag: {:?}", e),

                log::error!("Failed to create account tag: {e:?}");

                (StatusCode::INTERNAL_SERVER_ERROR, Json(error_response))

            })?;

    Ok(t!("Account tags saved").to_string())

}

pub async fn run_account_script(

    Path((account_id, script_id)): Path<(Uuid, Uuid)>,

    State(_data): State<Arc<AppState>>,

    Extension(jwt_auth): Extension<JWTAuthMiddleware>,

) -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {

    let user = &jwt_auth.user;

    let server_user = server::user::User { id: user.id };

    let script = server_user.get_script(script_id).await.map_err(|e| {

        let error_response = serde_json::json!({

            "status": "fail",

            "message": format!("Failed to get script: {e:?}"),

        (StatusCode::NOT_FOUND, Json(error_response))

    })?;

    let transaction_ids = server_user

        .list_transaction_ids_by_account(account_id)

        .await

        .map_err(|e| {

            let error_response = serde_json::json!({

                "status": "fail",

                "message": format!("Failed to fetch transactions: {e:?}"),

            (StatusCode::INTERNAL_SERVER_ERROR, Json(error_response))

        })?;

    let executor = ScriptExecutor::new();

    let mut processed = 0u64;

    for tx_id in &transaction_ids {

        let tx_result = server::command::transaction::GetTransaction::new()

            .user_id(user.id)

            .transaction_id(*tx_id)

            .run()

            .await

            .map_err(|e| {

                let error_response = serde_json::json!({

                    "status": "fail",

                    "message": format!("Failed to get transaction {tx_id}: {e:?}"),

                (StatusCode::INTERNAL_SERVER_ERROR, Json(error_response))

            })?;

        let (transaction, note) = if let Some(CmdResult::TaggedEntities { mut entities, .. }) =

            tx_result

            && let Some((FinanceEntity::Transaction(tx), tags)) = entities.pop()

            let note = tags.get("note").and_then(|entity| {

                if let FinanceEntity::Tag(tag) = entity {

                    Some(tag.tag_value.clone())

                    None

            });

            (tx, note)

            continue;

        let splits_result = server::command::split::ListSplits::new()

            .user_id(user.id)

            .transaction(*tx_id)

            .run()

            .await

            .map_err(|e| {

                let error_response = serde_json::json!({

                    "status": "fail",

                    "message": format!("Failed to get splits for {tx_id}: {e:?}"),

                (StatusCode::INTERNAL_SERVER_ERROR, Json(error_response))

            })?;

        let mut split_entities = Vec::new();

            entities: split_data,

        }) = splits_result

            for (entity, _tags) in split_data {

                split_entities.push(entity);

            }

        }

        let state = TransactionState::new(transaction)

            .with(split_entities)

            .with_note(note);

        let state = state

            .run_scripts(&executor, &[script.bytecode.clone()])

            .map_err(|e| {

                let error_response = serde_json::json!({

                    "status": "fail",

                    "message": format!("Script execution failed on {tx_id}: {e:?}"),

                (StatusCode::INTERNAL_SERVER_ERROR, Json(error_response))

            })?;

        for tag in &state.transaction_tags {

            let _ = server_user

                .create_transaction_tag(*tx_id, tag.tag_name.clone(), tag.tag_value.clone(), None)

                .await;

        for (split_id, tag) in &state.split_tags {

            let _ = server_user

                .create_split_tag(*split_id, tag.tag_name.clone(), tag.tag_value.clone(), None)

                .await;

        processed += 1;

    Ok(format!("{}: {processed}", t!("Processed transactions")))

}