// file: kb_lib/src/db/queries/fee_event.rs

//! Queries for `k_sol_fee_events`.

/// Returns one fee event by decoded event id.
pub async fn query_fee_events_get_by_decoded_event_id(
    database: &crate::Database,
    decoded_event_id: i64,
) -> Result<std::option::Option<crate::FeeEventDto>, crate::Error> {
    match database.connection() {
        crate::DatabaseConnection::Sqlite(pool) => {
            let query_result = sqlx::query_as::<sqlx::Sqlite, crate::FeeEventEntity>(
                r#"
SELECT
    id,
    transaction_id,
    decoded_event_id,
    dex_id,
    pool_id,
    pair_id,
    signature,
    slot,
    protocol_name,
    program_id,
    event_kind,
    pool_account,
    actor_wallet,
    fee_token_mint,
    fee_amount_raw,
    payload_json,
    executed_at,
    created_at
FROM k_sol_fee_events
WHERE decoded_event_id = ?
LIMIT 1
                "#,
            )
            .bind(decoded_event_id)
            .fetch_optional(pool)
            .await;
            let entity_option = match query_result {
                Ok(entity_option) => entity_option,
                Err(error) => {
                    return Err(crate::Error::Db(format!(
                        "cannot fetch k_sol_fee_events by decoded_event_id '{}' on sqlite: {}",
                        decoded_event_id, error
                    )));
                },
            };
            match entity_option {
                Some(entity) => {
                    let dto_result = crate::FeeEventDto::try_from(entity);
                    match dto_result {
                        Ok(dto) => return Ok(Some(dto)),
                        Err(error) => return Err(error),
                    }
                },
                None => return Ok(None),
            }
        },
    }
}

/// Inserts or updates one normalized fee event row.
pub async fn query_fee_events_upsert(
    database: &crate::Database,
    dto: &crate::FeeEventDto,
) -> Result<i64, crate::Error> {
    let slot_i64 = match dto.slot {
        Some(slot) => {
            let slot_result = i64::try_from(slot);
            match slot_result {
                Ok(slot) => Some(slot),
                Err(error) => {
                    return Err(crate::Error::Db(format!(
                        "cannot convert fee event slot '{}' to i64: {}",
                        slot, error
                    )));
                },
            }
        },
        None => None,
    };
    match database.connection() {
        crate::DatabaseConnection::Sqlite(pool) => {
            let existing_id = match dto.decoded_event_id {
                Some(decoded_event_id) => {
                    let existing_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
                        r#"
SELECT id
FROM k_sol_fee_events
WHERE decoded_event_id = ?
LIMIT 1
                        "#,
                    )
                    .bind(decoded_event_id)
                    .fetch_optional(pool)
                    .await;
                    match existing_result {
                        Ok(existing_id) => existing_id,
                        Err(error) => {
                            return Err(crate::Error::Db(format!(
                                "cannot fetch k_sol_fee_events id for decoded_event_id '{}' on sqlite: {}",
                                decoded_event_id, error
                            )));
                        },
                    }
                },
                None => None,
            };
            if let Some(id) = existing_id {
                let update_result = sqlx::query(
                    r#"
UPDATE k_sol_fee_events
SET
    transaction_id = ?,
    dex_id = ?,
    pool_id = ?,
    pair_id = ?,
    signature = ?,
    slot = ?,
    protocol_name = ?,
    program_id = ?,
    event_kind = ?,
    pool_account = ?,
    actor_wallet = ?,
    fee_token_mint = ?,
    fee_amount_raw = ?,

    payload_json = ?,
    executed_at = ?
WHERE id = ?
                    "#,
                )
                .bind(dto.transaction_id)
                .bind(dto.dex_id)
                .bind(dto.pool_id)
                .bind(dto.pair_id)
                .bind(dto.signature.clone())
                .bind(slot_i64)
                .bind(dto.protocol_name.clone())
                .bind(dto.program_id.clone())
                .bind(dto.event_kind.clone())
                .bind(dto.pool_account.clone())
                .bind(dto.actor_wallet.clone())
                .bind(dto.fee_token_mint.clone())
                .bind(dto.fee_amount_raw.clone())
                .bind(dto.payload_json.clone())
                .bind(dto.executed_at.to_rfc3339())
                .bind(id)
                .execute(pool)
                .await;
                if let Err(error) = update_result {
                    return Err(crate::Error::Db(format!(
                        "cannot update k_sol_fee_events id '{}' on sqlite: {}",
                        id, error
                    )));
                }
                let leg_result = query_fee_events_replace_scalar_amount_leg(database, id, dto).await;
                if let Err(error) = leg_result {
                    return Err(error);
                }
                return Ok(id);
            }
            let insert_result = sqlx::query(
                r#"
INSERT INTO k_sol_fee_events (
    transaction_id,
    decoded_event_id,
    dex_id,
    pool_id,
    pair_id,
    signature,
    slot,
    protocol_name,
    program_id,
    event_kind,
    pool_account,
    actor_wallet,
    fee_token_mint,
    fee_amount_raw,

    payload_json,
    executed_at,
    created_at
)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                "#,
            )
            .bind(dto.transaction_id)
            .bind(dto.decoded_event_id)
            .bind(dto.dex_id)
            .bind(dto.pool_id)
            .bind(dto.pair_id)
            .bind(dto.signature.clone())
            .bind(slot_i64)
            .bind(dto.protocol_name.clone())
            .bind(dto.program_id.clone())
            .bind(dto.event_kind.clone())
            .bind(dto.pool_account.clone())
            .bind(dto.actor_wallet.clone())
            .bind(dto.fee_token_mint.clone())
            .bind(dto.fee_amount_raw.clone())
            .bind(dto.payload_json.clone())
            .bind(dto.executed_at.to_rfc3339())
            .bind(dto.created_at.to_rfc3339())
            .execute(pool)
            .await;
            if let Err(error) = insert_result {
                return Err(crate::Error::Db(format!(
                    "cannot insert k_sol_fee_events on sqlite: {}",
                    error
                )));
            }
            let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
                r#"
SELECT id
FROM k_sol_fee_events
WHERE transaction_id = ?
  AND protocol_name = ?
  AND event_kind = ?
  AND signature = ?
ORDER BY id DESC
LIMIT 1
                "#,
            )
            .bind(dto.transaction_id)
            .bind(dto.protocol_name.clone())
            .bind(dto.event_kind.clone())
            .bind(dto.signature.clone())
            .fetch_one(pool)
            .await;
            match id_result {
                Ok(id) => {
                    let leg_result = query_fee_events_replace_scalar_amount_leg(database, id, dto).await;
                    if let Err(error) = leg_result {
                        return Err(error);
                    }
                    return Ok(id);
                },
                Err(error) => {
                    return Err(crate::Error::Db(format!(
                        "cannot fetch inserted k_sol_fee_events id for signature '{}' on sqlite: {}",
                        dto.signature, error
                    )));
                },
            }
        },
    }
}

async fn query_fee_events_replace_scalar_amount_leg(
    database: &crate::Database,
    fee_event_id: i64,
    dto: &crate::FeeEventDto,
) -> Result<(), crate::Error> {
    let token_mint = match dto.fee_token_mint.as_ref() {
        Some(token_mint) => {
            if token_mint.trim().is_empty() {
                return Ok(());
            }
            token_mint.clone()
        },
        None => return Ok(()),
    };
    let amount_raw = match dto.fee_amount_raw.as_ref() {
        Some(amount_raw) => {
            if amount_raw.trim().is_empty() {
                return Ok(());
            }
            amount_raw.clone()
        },
        None => return Ok(()),
    };
    let payload_json = scalar_fee_event_amount_payload_json(dto, token_mint.as_str(), amount_raw.as_str());
    let amount_leg = crate::FeeEventAmountDto::new(
        fee_event_id,
        dto.transaction_id,
        dto.decoded_event_id,
        0,
        dto.event_kind.clone(),
        token_mint,
        amount_raw,
        None,
        None,
        "parent_fee_event_amount".to_string(),
        payload_json,
    );
    let replace_result = crate::query_fee_event_amounts_replace_for_fee_event(
        database,
        fee_event_id,
        &[amount_leg],
    )
    .await;
    match replace_result {
        Ok(_) => return Ok(()),
        Err(error) => return Err(error),
    }
}

fn scalar_fee_event_amount_payload_json(
    dto: &crate::FeeEventDto,
    token_mint: &str,
    amount_raw: &str,
) -> std::string::String {
    let mut object = serde_json::Map::new();
    object.insert(
        "decodedEventKind".to_string(),
        serde_json::Value::String(dto.event_kind.clone()),
    );
    object.insert(
        "protocolName".to_string(),
        serde_json::Value::String(dto.protocol_name.clone()),
    );
    object.insert(
        "legIndex".to_string(),
        serde_json::Value::Number(serde_json::Number::from(0_u64)),
    );
    object.insert(
        "tokenMint".to_string(),
        serde_json::Value::String(token_mint.to_string()),
    );
    object.insert(
        "amountRaw".to_string(),
        serde_json::Value::String(amount_raw.to_string()),
    );
    object.insert(
        "amountSource".to_string(),
        serde_json::Value::String("parent_fee_event_amount".to_string()),
    );
    return serde_json::Value::Object(object).to_string();
}

/// Lists recent fee events ordered from newest to oldest.
pub async fn query_fee_events_list_recent(
    database: &crate::Database,
    limit: u32,
) -> Result<std::vec::Vec<crate::FeeEventDto>, crate::Error> {
    if limit == 0 {
        return Ok(std::vec::Vec::new());
    }
    match database.connection() {
        crate::DatabaseConnection::Sqlite(pool) => {
            let query_result = sqlx::query_as::<sqlx::Sqlite, crate::FeeEventEntity>(
                r#"
SELECT
    id,
    transaction_id,
    decoded_event_id,
    dex_id,
    pool_id,
    pair_id,
    signature,
    slot,
    protocol_name,
    program_id,
    event_kind,
    pool_account,
    actor_wallet,
    fee_token_mint,
    fee_amount_raw,

    payload_json,
    executed_at,
    created_at
FROM k_sol_fee_events
ORDER BY id DESC
LIMIT ?
                "#,
            )
            .bind(i64::from(limit))
            .fetch_all(pool)
            .await;
            let entities = match query_result {
                Ok(entities) => entities,
                Err(error) => {
                    return Err(crate::Error::Db(format!(
                        "cannot list k_sol_fee_events on sqlite: {}",
                        error
                    )));
                },
            };
            let mut dtos = std::vec::Vec::with_capacity(entities.len());
            for entity in entities {
                let dto_result = crate::FeeEventDto::try_from(entity);
                match dto_result {
                    Ok(dto) => dtos.push(dto),
                    Err(error) => return Err(error),
                }
            }
            return Ok(dtos);
        },
    }
}
