hypercall_api/handlers/

competition.rs

use super::AppState;
use crate::error::ApiError;
use crate::models::{
    CompetitionLeaderboardResponse, CompetitionResponse, CompetitionSortByValue,
    CompetitionSortOrderValue, CompetitionStateValue, CompetitionsResponse, ConnectedUserRank,
    LeaderboardRow, Pagination, ProfileCompetitionRankSummary, ProfileData, ProfileMarginStats,
    ProfileMetricMedals, ProfilePnlStats, ProfileResponse, ProfileTradesResponse,
    RealizedPnlResponse, RealizedPnlRow,
};
use axum::{
    extract::{Path, Query, State},
    http::StatusCode,
    Json,
};
use chrono::Utc;
use hypercall_competition::{
    competition_state, CompetitionState, LeaderboardQuery, LeaderboardSortBy, SortOrder,
};
// The admin write handlers (create/update/delete competition) live in
// `hypercall-admin`; the business logic and these shared helpers live in the
// `hypercall-competition` crate so both HTTP crates use one copy.
use hypercall_competition::{clamp_limit, competition_to_api};
use hypercall_types::WalletAddress;
use serde::Deserialize;
use utoipa::IntoParams;

#[derive(Debug, Deserialize, IntoParams)]
pub struct CompetitionListQuery {
    pub state: Option<CompetitionStateValue>,
    pub from_ts_ms: Option<i64>,
    pub to_ts_ms: Option<i64>,
    pub limit: Option<usize>,
    pub offset: Option<usize>,
}

#[derive(Debug, Deserialize, IntoParams)]
pub struct CompetitionLeaderboardQuery {
    pub competition_id: i64,
    pub sort_by: Option<CompetitionSortByValue>,
    pub sort_order: Option<CompetitionSortOrderValue>,
    pub limit: Option<usize>,
    pub offset: Option<usize>,
    pub wallet: Option<WalletAddress>,
}

#[derive(Debug, Deserialize, IntoParams)]
pub struct ProfileQuery {
    pub wallet: WalletAddress,
}

#[derive(Debug, Deserialize, IntoParams)]
pub struct ProfileTradesQuery {
    pub wallet: WalletAddress,
    pub limit: Option<usize>,
    pub offset: Option<usize>,
    pub competition_id: Option<i64>,
    pub from_ts_ms: Option<i64>,
    pub to_ts_ms: Option<i64>,
    pub symbol: Option<String>,
}

#[derive(Debug, Deserialize, IntoParams)]
pub struct RealizedPnlQuery {
    pub wallet: WalletAddress,
    pub competition_id: Option<i64>,
}

/// List competitions.
#[utoipa::path(
    get,
    path = "/competitions",
    params(CompetitionListQuery),
    responses((status = 200, body = CompetitionsResponse)),
    tag = "Competition"
)]
pub async fn list_competitions(
    State(state): State<AppState>,
    Query(query): Query<CompetitionListQuery>,
) -> Result<Json<CompetitionsResponse>, ApiError> {
    let now_ts_ms = Utc::now().timestamp_millis();
    let limit = clamp_limit(query.limit);
    let offset = query.offset.unwrap_or(0);

    let state_filter = query.state.map(|state| match state {
        CompetitionStateValue::Pre => CompetitionState::Pre,
        CompetitionStateValue::Active => CompetitionState::Active,
        CompetitionStateValue::Post => CompetitionState::Post,
    });

    let rows = state
        .competition_service
        .list_competitions(
            state_filter,
            query.from_ts_ms,
            query.to_ts_ms,
            limit,
            offset,
            now_ts_ms,
        )
        .await
        .map_err(ApiError::from)?;

    let data = rows
        .into_iter()
        .map(|row| competition_to_api(row, now_ts_ms))
        .collect::<Vec<_>>();

    Ok(Json(CompetitionsResponse {
        success: true,
        pagination: Pagination {
            limit,
            offset,
            count: data.len(),
        },
        data,
    }))
}

/// Get competition by id.
#[utoipa::path(
    get,
    path = "/competitions/{id}",
    params(("id" = i64, Path, description = "Competition id")),
    responses((status = 200, body = CompetitionResponse)),
    tag = "Competition"
)]
pub async fn get_competition(
    State(state): State<AppState>,
    Path(id): Path<i64>,
) -> Result<Json<CompetitionResponse>, ApiError> {
    let now_ts_ms = Utc::now().timestamp_millis();
    let row = state
        .competition_service
        .get_competition(id)
        .await
        .map_err(ApiError::from)?;

    Ok(Json(CompetitionResponse {
        success: true,
        data: competition_to_api(row, now_ts_ms),
    }))
}

/// Get competition leaderboard.
#[utoipa::path(
    get,
    path = "/competitions/leaderboard",
    params(CompetitionLeaderboardQuery),
    responses((status = 200, body = CompetitionLeaderboardResponse)),
    tag = "Competition"
)]
pub async fn get_competition_leaderboard(
    State(state): State<AppState>,
    Query(query): Query<CompetitionLeaderboardQuery>,
) -> Result<Json<CompetitionLeaderboardResponse>, ApiError> {
    let now_ts_ms = Utc::now().timestamp_millis();
    let limit = clamp_limit(query.limit);
    let offset = query.offset.unwrap_or(0);
    let sort_by = match query.sort_by.unwrap_or(CompetitionSortByValue::Pnl) {
        CompetitionSortByValue::Pnl => LeaderboardSortBy::Pnl,
        CompetitionSortByValue::Volume => LeaderboardSortBy::Volume,
        CompetitionSortByValue::Efficiency => LeaderboardSortBy::Efficiency,
    };
    let sort_order = match query.sort_order.unwrap_or(CompetitionSortOrderValue::Desc) {
        CompetitionSortOrderValue::Asc => SortOrder::Asc,
        CompetitionSortOrderValue::Desc => SortOrder::Desc,
    };

    let result = state
        .competition_service
        .get_leaderboard(
            LeaderboardQuery {
                competition_id: query.competition_id,
                sort_by,
                sort_order,
                limit,
                offset,
                wallet: query.wallet,
            },
            now_ts_ms,
        )
        .await
        .map_err(ApiError::from)?;

    let data = result
        .rows
        .into_iter()
        .map(|entry| LeaderboardRow {
            rank: entry.rank,
            wallet: entry.wallet,
            username: entry.username,
            pnl: entry.pnl,
            volume: entry.volume,
            efficiency: entry.efficiency,
            medal: entry.medal,
        })
        .collect::<Vec<_>>();

    let connected_user = match query.wallet {
        Some(wallet) => {
            if let Some(me) = result.connected_user {
                Some(ConnectedUserRank {
                    wallet: me.wallet,
                    username: me.username,
                    rank: Some(me.rank),
                    pnl: Some(me.pnl),
                    volume: Some(me.volume),
                    efficiency: Some(me.efficiency),
                    medal: me.medal,
                })
            } else {
                let username = state
                    .competition_service
                    .get_display_username(wallet)
                    .await
                    .map_err(ApiError::from)?;
                Some(ConnectedUserRank {
                    wallet,
                    username,
                    rank: None,
                    pnl: None,
                    volume: None,
                    efficiency: None,
                    medal: None,
                })
            }
        }
        None => None,
    };

    let count = data.len();

    Ok(Json(CompetitionLeaderboardResponse {
        success: true,
        competition_id: query.competition_id,
        sort_by: match query.sort_by.unwrap_or(CompetitionSortByValue::Pnl) {
            CompetitionSortByValue::Pnl => "pnl".to_string(),
            CompetitionSortByValue::Volume => "volume".to_string(),
            CompetitionSortByValue::Efficiency => "efficiency".to_string(),
        },
        sort_order: match query.sort_order.unwrap_or(CompetitionSortOrderValue::Desc) {
            CompetitionSortOrderValue::Asc => "asc".to_string(),
            CompetitionSortOrderValue::Desc => "desc".to_string(),
        },
        data,
        connected_user,
        pagination: Pagination {
            limit,
            offset,
            count,
        },
    }))
}

/// Get profile stats.
#[utoipa::path(
    get,
    path = "/profile",
    params(ProfileQuery),
    responses((status = 200, body = ProfileResponse)),
    security(("wallet_query" = [])),
    tag = "Portfolio"
)]
pub async fn get_profile(
    State(state): State<AppState>,
    Query(query): Query<ProfileQuery>,
) -> Result<Json<ProfileResponse>, ApiError> {
    let now_ts_ms = Utc::now().timestamp_millis();
    let wallet = query.wallet;

    let username = state
        .competition_service
        .get_display_username(wallet)
        .await
        .map_err(ApiError::from)?;
    let profile_image_url = state
        .competition_service
        .get_profile_image_url(wallet)
        .await
        .map_err(ApiError::from)?;

    let margin_snapshot = state
        .portfolio_cache
        .compute_wallet_margin_snapshot(&wallet)
        .await
        .map_err(|e| {
            ApiError::new(
                StatusCode::SERVICE_UNAVAILABLE,
                "service_unavailable",
                format!("margin snapshot unavailable: {}", e),
            )
        })?;

    let cash_balance = state
        .balance_provider
        .get_balance(&wallet)
        .await
        .map_err(|e| {
            ApiError::internal_error(format!(
                "failed to read engine balance for {}: {}",
                wallet, e
            ))
        })?;

    let unrealized = margin_snapshot.margin_summary.equity - cash_balance;
    let (deposits, withdraws, lifetime_realized, pnl_24h) = state
        .competition_service
        .compute_ledger_profile_stats(wallet, now_ts_ms)
        .await
        .map_err(ApiError::from)?;
    let account_first_seen_ts_ms = state
        .competition_service
        .get_account_first_seen_ts_ms(wallet)
        .await
        .map_err(ApiError::from)?;
    let account_age_days =
        account_first_seen_ts_ms.map(|first_seen| (now_ts_ms - first_seen) / (24 * 60 * 60 * 1000));
    let platform_medals = state
        .competition_service
        .get_platform_metric_medals(wallet)
        .await
        .map_err(ApiError::from)?;

    let active_competition = state
        .competition_service
        .get_active_competition(now_ts_ms)
        .await
        .map_err(ApiError::from)?;

    let mut medal = None;
    let mut active_competition_rank = None;

    if let Some(active) = &active_competition {
        let active_sort_by = sort_by_from_primary_win_condition(&active.primary_win_condition);
        let leaderboard = state
            .competition_service
            .get_leaderboard(
                LeaderboardQuery {
                    competition_id: active.id,
                    sort_by: active_sort_by,
                    sort_order: SortOrder::Desc,
                    limit: 1,
                    offset: 0,
                    wallet: Some(wallet),
                },
                now_ts_ms,
            )
            .await
            .map_err(ApiError::from)?;

        if let Some(me) = leaderboard.connected_user {
            medal = me.medal;
            active_competition_rank = Some(ProfileCompetitionRankSummary {
                competition_id: active.id,
                competition_name: active.name.clone(),
                competition_state: competition_state(&active, now_ts_ms).as_str().to_string(),
                rank: me.rank,
                pnl: me.pnl,
                volume: me.volume,
                efficiency: me.efficiency,
                medal: me.medal,
            });
        }
    } else if let Some(completed) = state
        .competition_service
        .get_latest_completed_competition(now_ts_ms)
        .await
        .map_err(ApiError::from)?
    {
        let completed_sort_by =
            sort_by_from_primary_win_condition(&completed.primary_win_condition);
        let leaderboard = state
            .competition_service
            .get_leaderboard(
                LeaderboardQuery {
                    competition_id: completed.id,
                    sort_by: completed_sort_by,
                    sort_order: SortOrder::Desc,
                    limit: 1,
                    offset: 0,
                    wallet: Some(wallet),
                },
                now_ts_ms,
            )
            .await
            .map_err(ApiError::from)?;
        medal = leaderboard.connected_user.and_then(|me| me.medal);
    }

    Ok(Json(ProfileResponse {
        success: true,
        data: ProfileData {
            wallet,
            username,
            profile_image_url,
            account_first_seen_ts_ms,
            account_age_days,
            margin: ProfileMarginStats {
                in_use: margin_snapshot.total_margin_used,
                available: margin_snapshot.available_balance,
                total: margin_snapshot.margin_summary.equity,
                deposits,
                withdraws,
            },
            pnl: ProfilePnlStats {
                unrealized,
                pnl_24h,
                lifetime_realized,
            },
            medal,
            platform_medals: ProfileMetricMedals {
                pnl: platform_medals.pnl,
                volume: platform_medals.volume,
                efficiency: platform_medals.efficiency,
            },
            active_competition_rank,
        },
    }))
}

/// Get profile trade history.
#[utoipa::path(
    get,
    path = "/profile/trades",
    params(ProfileTradesQuery),
    responses((status = 200, body = ProfileTradesResponse)),
    security(("wallet_query" = [])),
    tag = "Portfolio"
)]
pub async fn get_profile_trades(
    State(state): State<AppState>,
    Query(query): Query<ProfileTradesQuery>,
) -> Result<Json<ProfileTradesResponse>, ApiError> {
    let limit = clamp_limit(query.limit);
    let offset = query.offset.unwrap_or(0);

    let fills = state
        .competition_service
        .get_profile_trade_history(
            query.wallet,
            query.competition_id,
            query.from_ts_ms,
            query.to_ts_ms,
            query.symbol.as_deref(),
            limit,
            offset,
        )
        .await
        .map_err(ApiError::from)?;

    let data = fills
        .into_iter()
        .map(|fill| {
            let mut row = fill.to_api_response();
            row.explorer_url = trade_explorer_url(&state, fill.trade_id);
            row
        })
        .collect::<Vec<_>>();

    Ok(Json(ProfileTradesResponse {
        success: true,
        pagination: Pagination {
            limit,
            offset,
            count: data.len(),
        },
        data,
    }))
}

/// Get realized PnL breakdown by symbol for a wallet.
#[utoipa::path(
    get,
    path = "/profile/realized-pnl",
    params(RealizedPnlQuery),
    responses((status = 200, body = RealizedPnlResponse)),
    tag = "Portfolio"
)]
pub async fn get_realized_pnl(
    State(state): State<AppState>,
    Query(query): Query<RealizedPnlQuery>,
) -> Result<Json<RealizedPnlResponse>, ApiError> {
    let entries = state
        .competition_service
        .get_realized_pnl_by_symbol(query.wallet, query.competition_id)
        .await
        .map_err(ApiError::from)?;

    let data = entries
        .into_iter()
        .map(|e| RealizedPnlRow {
            symbol: e.symbol,
            realized_pnl: e.realized_pnl,
            event_count: e.event_count,
        })
        .collect();

    Ok(Json(RealizedPnlResponse {
        success: true,
        data,
    }))
}

fn trade_explorer_url(app_state: &crate::handlers::AppState, trade_id: i64) -> Option<String> {
    let template = app_state
        .runtime_config
        .trade_explorer_url_template
        .clone()?;
    if template.is_empty() {
        return None;
    }
    Some(template.replace("{trade_id}", &trade_id.to_string()))
}

fn sort_by_from_primary_win_condition(primary_win_condition: &str) -> LeaderboardSortBy {
    match primary_win_condition {
        "volume" => LeaderboardSortBy::Volume,
        "efficiency" => LeaderboardSortBy::Efficiency,
        _ => LeaderboardSortBy::Pnl,
    }
}