using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public sealed class BriskLeaderboardModule
    : BriskModuleBase
{
    public async Task<IReadOnlyList<BriskLeaderboardEntry>> GetTopAsync(string rankKey, int limit = 20)
    {
        ValidateRankKey(rankKey);

        return await ExecuteAsync(async context =>
        {
            var data = await context.HttpClient.GetRawDataAsync(
                $"/ranks/{rankKey}/top",
                CreateLimitQuery(limit),
                true);
            return (IReadOnlyList<BriskLeaderboardEntry>)BriskModelMapper.ToLeaderboardEntries(data);
        });
    }

    public async Task<BriskLeaderboardPlayerRank> GetMeAsync(string rankKey)
    {
        ValidateRankKey(rankKey);

        return await ExecuteAsync(async context =>
        {
            var data = await context.HttpClient.GetRawDataAsync($"/ranks/{rankKey}/me", null, true);
            return BriskModelMapper.ToLeaderboardPlayerRank(BriskModelMapper.ExtractObject(data));
        });
    }

    public async Task<IReadOnlyList<BriskLeaderboardEntry>> GetAroundMeAsync(string rankKey, int range = 10)
    {
        ValidateRankKey(rankKey);

        return await ExecuteAsync(async context =>
        {
            var data = await context.HttpClient.GetRawDataAsync(
                $"/ranks/{rankKey}/around-me",
                CreateRangeQuery(range),
                true);
            return (IReadOnlyList<BriskLeaderboardEntry>)BriskModelMapper.ToLeaderboardEntries(data);
        });
    }

    public async Task SubmitScoreAsync(string rankKey, long score)
    {
        ValidateRankKey(rankKey);

        await ExecuteAsync(async context =>
        {
            await context.HttpClient.PostJsonRawAsync(
                $"/ranks/{rankKey}/score",
                new Dictionary<string, object> { { "score", score } },
                true);
        });
    }

    public async Task<BriskRankSeasonInfo> GetCurrentSeasonAsync(string rankKey)
    {
        ValidateRankKey(rankKey);

        return await ExecuteAsync(async context =>
        {
            var data = await context.HttpClient.GetRawDataAsync($"/ranks/{rankKey}/season/current", null, true);
            return BriskModelMapper.ToRankSeasonInfo(BriskModelMapper.ExtractObject(data));
        });
    }

    public async Task<IReadOnlyList<BriskRankSeasonInfo>> GetSeasonHistoryAsync(string rankKey, int limit = 20)
    {
        ValidateRankKey(rankKey);

        return await ExecuteAsync(async context =>
        {
            var data = await context.HttpClient.GetRawDataAsync(
                $"/ranks/{rankKey}/history",
                CreateLimitQuery(limit),
                true);
            return (IReadOnlyList<BriskRankSeasonInfo>)BriskModelMapper.ToRankSeasonInfos(data);
        });
    }

    public async Task<IReadOnlyList<BriskLeaderboardEntry>> GetSeasonHistoryDetailAsync(string rankKey, string seasonId, int limit = 20)
    {
        ValidateRankKey(rankKey);
        RequireNotEmpty(seasonId, nameof(seasonId));

        return await ExecuteAsync(async context =>
        {
            var data = await context.HttpClient.GetRawDataAsync(
                $"/ranks/{rankKey}/history/{seasonId}",
                CreateLimitQuery(limit),
                true);
            return (IReadOnlyList<BriskLeaderboardEntry>)BriskModelMapper.ToLeaderboardEntries(data);
        });
    }

    private static Dictionary<string, string> CreateLimitQuery(int limit)
    {
        return limit > 0
            ? new Dictionary<string, string> { { "limit", limit.ToString() } }
            : null;
    }

    private static Dictionary<string, string> CreateRangeQuery(int range)
    {
        return range > 0
            ? new Dictionary<string, string> { { "range", range.ToString() } }
            : null;
    }

    private static void ValidateRankKey(string rankKey)
    {
        RequireNotEmpty(rankKey, nameof(rankKey));
    }
}