using System;

using System.Collections.Generic;

using System.Linq;

using System.Net.Http;

using System.Threading.Tasks;

using Newtonsoft.Json;

​

class Result

{

    private const string BaseUrl = "https://jsonmock.hackerrank.com/api/tvseries";

    private static readonly HttpClient HttpClient = new();

    private static readonly BestTvSeriesComparer BestTvSeriesComparer = new();

​

    /*

     * Complete the 'bestInGenre' function below.

     *

     * The function is expected to return a STRING.

     * The function accepts STRING genre as parameter.

     *

     * Base URL: https://jsonmock.hackerrank.com/api/tvseries?page=

     */

    public static string? bestInGenre(string genre)

    {

        return FindBestTvSeriesAsync(genre).GetAwaiter().GetResult();

    }

    /*

        Solution:

           The simplest version is obviously to aggregate all tvSeries into IEnumerable and apply LINQ operators to find the right one.

​

           We can also simplify the logic by streamlining tvSeries data with IAsyncEnumerable and use LINQ operators to find the best one,

           but it will require to add System.Linq.Async package. The result code will be concise and clean, I'll put this version after the current solution.

​

           As we don't have any constraints for total amount of tvSeries, we might have a problem as there might be millions of them and the execution env limits is not defined.

           So to avoid memory issues we can find the best tvSeries across the batches and compare them to each other, reusing the same logic with comparator.

        Notes:

        1. I tried to change the signature of bestInGenre method to async, but it's not allowed, so used GetAWaiter().GetResult() as a solution.

           Giving .NET 8 and restricting usage of async is torture :)

        2. I omitted genre and response validation as rules are not defined.

    */

    private static async Task<string?> FindBestTvSeriesAsync(string genre) 

    {

        int currentPage = 1, totalPages = default;

        TvSeries? bestSeries = null;

        do 

        {

            var response = await GetTvSeriesPerPageAsync(currentPage);

            // retry with polly?

            if (response is null) break;

​

            totalPages = response.TotalPages;

​

            var seriesWithHighestScore = FindBestSeries(genre, response.Data);

            if (bestSeries is null) 

            {

                bestSeries = seriesWithHighestScore;

            }

            else if (seriesWithHighestScore is not null)

            {

                bestSeries = BestTvSeriesComparer.Compare(bestSeries, seriesWithHighestScore) > 0

                    ? bestSeries

                    : seriesWithHighestScore;

            }

            currentPage++;

        }

        while(currentPage <= totalPages);

        return bestSeries?.Name;

    }

    private static async Task<Response?> GetTvSeriesPerPageAsync(int page) 

    {

        var response = await HttpClient.GetAsync($"{BaseUrl}?page={page}");

        response.EnsureSuccessStatusCode();

        var jsonResponse = await response.Content.ReadAsStringAsync();

        var pageResult = JsonConvert.DeserializeObject<Response>(jsonResponse);

        return pageResult;

    }

    private static TvSeries? FindBestSeries(string genre, IReadOnlyCollection<TvSeries> tvSeries) 

    {

        return tvSeries?

            .Where(c => c.Genre.Split(",", StringSplitOptions.TrimEntries).Contains(genre))

            .Order(BestTvSeriesComparer)

            .FirstOrDefault();

    }

    /*

     * Alternative version if we are allowed to use System.Linq.Async package

     private static async Task<string?> GetBestTvSeriesAsync(string genre)

     {

         return await GetTvSeriesStreamAsync()

             .Where(c => c.Genre.Split(',', StringSplitOptions.TrimEntries).Contains(genre))

             .OrderByDescending(c => c.ImdbRating)

             .ThenBy(c => c.Name, StringComparer.Ordinal)

             .Select(c => c.Name)

             .FirstOrDefaultAsync();

     }

​

     private static async IAsyncEnumerable<TvSeries> GetTvSeriesStreamAsync([EnumeratorCancellation] CancellationToken cancellationToken = default)

     {

         int currentPage = 1, totalPages = int.MaxValue;

         while (currentPage <= totalPages)

         {

             var response = await _httpClient.GetAsync($"{BaseUrl}?page={currentPage}", cancellationToken);

             response.EnsureSuccessStatusCode();

​

             var jsonResponse = await response.Content.ReadAsStringAsync(cancellationToken);

             var pageResult = JsonSerializer.Deserialize<Response>(jsonResponse, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

​

             if (pageResult == null) yield break;

             totalPages = pageResult.TotalPages;

​

             foreach (var series in pageResult.Data)

             {

                 yield return series;

             }

             currentPage++;

         }

     }

     */

}

​

internal sealed class BestTvSeriesComparer : IComparer<TvSeries>

{

    public int Compare(TvSeries x, TvSeries y)

    {

        var result = x.ImdbRating.CompareTo(y.ImdbRating);

        if (result == 0)

        {

            result = string.Compare(x.Name, y.Name, StringComparison.Ordinal);

        }

​

        return result;

    }

}

​

internal sealed record Response

{

    [JsonProperty("total_pages")]

    public required int TotalPages { get; init; }

    public required IReadOnlyCollection<TvSeries> Data { get; init; }

};

​

public sealed record TvSeries

{    

    public required string Name { get; init; }

    public required string Genre { get; init; }

    [JsonProperty("imdb_rating")] 

    public required double ImdbRating { get; init; }

};

​

class Solution

{

    public static void Main(string[] args)

    {

        string result = Result.bestInGenre("Action");

        result.Dump();

    }

}