using Microsoft.Extensions.Logging;

using Microsoft.Extensions.DependencyInjection;

using PhiZoneApi.Models;

using PhiZoneApi.Interfaces;

using System;

using System.Linq;

using System.Globalization;

var target = (ValueTuple<EventResource, int>)Target;

var resource = target.Item1;

const int reviewerCount = 20;

await using (var scope = ServiceProvider.CreateAsyncScope())

{

    var eventTeamRepository = scope.ServiceProvider.GetRequiredService<IEventTeamRepository>();

    var eventResourceRepository = scope.ServiceProvider.GetRequiredService<IEventResourceRepository>();

    var leaderboardService = scope.ServiceProvider.GetRequiredService<ILeaderboardService>();

    var eventTeam = await eventTeamRepository.GetEventTeamAsync(resource.TeamId!.Value);

    var entries = await eventResourceRepository.GetEventResourcesAsync(predicate: e => e.TeamId == resource.TeamId);

    foreach (var entry in entries)

    {

        while (entry.Reserved.Count < 14 + reviewerCount)

        {

            entry.Reserved.Add(string.Empty);

        }

        var reviewerScores = Enumerable.Range(14, reviewerCount)

            .Select(i => entry.Reserved[i])

            .Where(e => !string.IsNullOrWhiteSpace(e) && double.TryParse(e, out var f) && f > 0)

            .Select(e => e!)

            .ToList();

        var reviewerAverage = reviewerScores.Count > 0 ? Math.Round(reviewerScores.Average(double.Parse), 2) : 0;

        entry.Reserved[1] = reviewerAverage.ToString(CultureInfo.InvariantCulture);

        var scores = Enumerable.Range(1, 3)

            .Select(i => entry.Reserved[i])

            .Select(e =>

            {

                if (!string.IsNullOrWhiteSpace(e) && double.TryParse(e, out var result)) return (double?)result;

                return null;

            })

            .ToList();

        var total = Math.Round((scores[0] ?? 0) * ((scores[2] ?? 0) + 100) / 100 + (scores[1] ?? 2.5) * 3, 2);

        entry.Reserved[0] = total.ToString(CultureInfo.InvariantCulture);

        if (eventTeam.IsUnveiled)

        {

            entry.Score = total;

        }

        await eventResourceRepository.UpdateEventResourceAsync(entry);

    }

    while (eventTeam.Reserved.Count < 14 + reviewerCount)

    {

        eventTeam.Reserved.Add(string.Empty);

    }

    for (var i = 0; i < reviewerCount; i++)

    {

        var index = i + 14;

        var scores = entries.Select(e => e.Reserved[index])

            .Where(e => !string.IsNullOrWhiteSpace(e) && double.TryParse(e, out var f) && f > 0)

            .Select(e => e!)

            .ToList();

        eventTeam.Reserved[index] =

            scores.Count > 0 ? Math.Round(scores.Average(double.Parse), 2).ToString(CultureInfo.InvariantCulture) : "0";

    }

    for (var i = 1; i <= 3; i++)

    {

        var entryScores = entries.Select(e => e.Reserved[i])

            .Where(e => !string.IsNullOrWhiteSpace(e) && double.TryParse(e, out _))

            .Select(e => e!)

            .ToList();

        eventTeam.Reserved[i] = entryScores.Count > 0

            ? Math.Round(entryScores.Average(double.Parse), 2).ToString(CultureInfo.InvariantCulture)

            : "0";

    }

    var teamScores = Enumerable.Range(1, 3)

        .Select(i => eventTeam.Reserved[i])

        .Select(e =>

        {

            if (!string.IsNullOrWhiteSpace(e) && double.TryParse(e, out var result)) return (double?)result;

            return null;

        })

        .ToList();

    var teamTotal = Math.Round((teamScores[0] ?? 0) * ((teamScores[2] ?? 0) + 100) / 100 + (teamScores[1] ?? 2.5) * 3, 2);

    eventTeam.Reserved[0] = teamTotal.ToString(CultureInfo.InvariantCulture);

    if (eventTeam.IsUnveiled)

    {

        eventTeam.Score = teamTotal;

    }

    await eventTeamRepository.UpdateEventTeamAsync(eventTeam);

    if (eventTeam.IsUnveiled)

    {

        leaderboardService.Add(eventTeam);

    }

}