@using Core.Calculation
@using Microsoft.EntityFrameworkCore
@page "/teams/scheduler"
@inject IConfiguration Configuration
@inject AppDbContext Context

<PageTitle>@Configuration["ChapterSettings:Shortname"] TSA Schedule @Configuration["ChapterSettings:CompetitionYear"]</PageTitle>

<MudText Typo="Typo.h3">@Configuration["ChapterSettings:Shortname"] TSA Schedule @Configuration["ChapterSettings:CompetitionYear"]</MudText>

<MudItem xs="12" lg="4">
<MudText Typo="Typo.h4">Time Slots</MudText>
    <MudTable T="Team[]" ServerData="SolveSchedule" @ref="_solutionData">
        <HeaderContent>

        </HeaderContent>
        <RowTemplate>
            <MudTd>
                @foreach (var t in context)
                {
                    <MudItem>
                        @t.ToString() - 
                        @string.Join(", ", t.Students)
                    </MudItem>
                }
                @foreach (var overlap in TeamSchedulerSolution.GetStudentTeamOverlaps(context))
                {
                    <MudItem>
                        @string.Join(", ", overlap.Item1)
                    </MudItem>
                }
            </MudTd>
        </RowTemplate>
</MudTable>
</MudItem>

@code {
    private Team[]? _teams;
    private Student[]? _students;
    MudTable<Team[]> _solutionData;
    private TeamSchedulerSolution _solution;

    protected override async Task OnInitializedAsync()
    {
        _teams
                = await Context.Teams
                    .Include(e => e.Event)
                    .Include(e => e.Students)
                    .OrderBy(e => e.Event.Name)
                    .ThenBy(e => e.Number)
                    .ToArrayAsync();

        _students = 
            await Context.Students
                .Include(e => e.Teams)
                .ThenInclude(e => e.Captain)
                .Include(e => e.EventRankings)
                .ThenInclude(e => e.EventDefinition)
                .OrderBy(e => e.FirstName).ToArrayAsync();
    }

    private async Task<TableData<Team[]>> SolveSchedule(TableState arg1, CancellationToken arg2)
    {
        //_isSolving = true;

        var scheduleOptions =
            new TeamSchedulerOptions(
                timeSlots: 4,
                mustIncludeEvents:
                [
                // "Medical Technology", "Electrical Applications"  , "RegionalTeam",
                // ,"Dragster", "Flight"
                ],
                extended:
                [
                // "Invention", "Construction Challenge",  "Mechanical", "Mass", "Micro"
                //"STEM"
                //"Community", "Vlogging"// "Microcontroller"
                ],
                omittedEvents:
                [
                // "Vlogging", "Junior", "Community Service Video", "Digital Photography",
                // "STEM"

                //"Leadership",// "Electrical", //"Construction"
                // "Forensic",
                //"CAD"
                //"I&I Team 1", "I&I Team 2"//, "Website Design",
                ],
                absentStudents:
                [
                ]
                );

        var mustIncludeTeams = _teams;
        mustIncludeTeams = mustIncludeTeams.Where(t => t.Event.EventFormat == EventFormat.Team).ToArray();

        var teamScheduler = new TeamScheduler(mustIncludeTeams, scheduleOptions.TimeSlots);

        // teamScheduler
        //     .ScheduleSeparate(
        //         _teams.First(e => e.Event.Name.Contains("Data Science")),
        //         _teams.First(e => e.Event.Name.Contains("Microcontroller Design"))
        //         );

        _solution = teamScheduler.Solve();

        await InvokeAsync(StateHasChanged); // let the UI know that the solution has been found

        return new TableData<Team[]> { Items = _solution.TimeSlots};
    }
}