@page "/raidtemplateedit"
@page "/raidtemplateedit/{raidId}"
@page "/raidtemplateedit/{raidId}/{editType}"
@using Lieb.Data
@using Lieb.Models
@using Lieb.Models.GuildWars2.Raid
@using System.ComponentModel.DataAnnotations
@using System.Security.Claims
@using SharedClasses.SharedModels
@inject RaidTemplateService RaidTemplateService
@inject RaidService RaidService
@inject UserService UserService
@inject DiscordService DiscordService
@inject TimeZoneService TimeZoneService
@inject NavigationManager NavigationManager
@inject AuthenticationStateProvider AuthenticationStateProvider
@inject IJSRuntime JsRuntime


<h3>Create or edit Template</h3>

<AuthorizeView Policy="@Constants.Roles.RaidLead.Name" Context="authorizationContext">
<EditForm Model="@_template" OnValidSubmit="@HandleValidSubmit">
    <DataAnnotationsValidator />
    @{
        bool _isEdit = _template.RaidTemplateId != 0;
    }
    <p>
        <label>
            Title:
            <InputText @bind-Value="_template.Title" />
        </label>
    </p>
    <p>
        <label>
            Description:
            <InputTextArea @bind-Value="_template.Description" />
        </label>
    </p>
    <p>
        <label>
            Raid Type:
            <InputSelect @bind-Value="_template.RaidType" disabled="@(!_editType && _isEdit)">
                <option value="@RaidType.Planned">Planned</option>
                <option value="@RaidType.RandomWithBoons">Random with boons covered</option>
                <option value="@RaidType.RandomClasses">Random classes</option>
                <option value="@RaidType.RandomEliteSpecialization">Random elite specializations</option>
            </InputSelect>
        </label>
    </p>
    @if(_template.RaidType != RaidType.Planned)
    {
        <p>
            <label>
                Random Spots:
                <InputNumber @bind-Value="_randomSpots"/>
            </label>
        </p>
    }
    <p>
        <label>
            Event Type:
            <InputSelect @bind-Value="_template.EventType">
                @foreach (EventType eventType in (EventType[]) Enum.GetValues(typeof(EventType)))
                {
                    <option value="@eventType">@eventType.ToString()</option>
                }
            </InputSelect>
        </label>
    </p>
    
    <p>
        <label>
            <InputCheckbox @bind-Value="_isMultiDay" />
            Multi day raid
        </label>
    </p>
    
    @if(_isMultiDay)
    {
        <p>
            <label>
                Start date:
                <InputDate @bind-Value="_raidDate" />
            </label>
        </p>
        <p>
            <label>
                End date:
                <InputDate @bind-Value="_endDate" />
            </label>
        </p>
    }
    else
    {
        <p>
            <label>
                Date:
                <InputDate @bind-Value="_raidDate" />
            </label>
        </p>
    }

    <p>
        <label>
            Start Time:
            <input type="time" @bind="_startTime" />
        </label>
    </p>
    <p>
        <label>
            End Time:
            <input type="time" @bind="_endTime" />
        </label>
    </p>
    <p>
        <label>
            Time Zone:
            <InputSelect @bind-Value="_template.TimeZone">
                <option value="@_template.TimeZone">@_template.TimeZone</option>
                @if(_userTimeZone != @_template.TimeZone)
                {
                    <option value="@_userTimeZone">@_userTimeZone</option>
                }
            </InputSelect>
        </label>
    </p>
    
    
    <p>
        <label>
            Required Role:
            <InputSelect @bind-Value="_template.RequiredRole">
                <option value="">Not Locked</option>
                @foreach(LiebRole role in UserService.GetLiebRoles())
                {
                        if (role.Type != RoleType.SystemRole)
                        {
                            <option value="@role.RoleName">@role.RoleName</option>
                        }
                }
            </InputSelect>
        </label>
    </p>
    <p>
        <label>
            Free for all date:
            <InputDate @bind-Value="_freeForAllDate" />
        </label>
    </p>

    <p>
        <label>
            Free for all time:
            <input type="time" @bind="_freeForAllTime" />
        </label>
    </p>
    <p>
        <label>
            Minimal required users:
                <InputNumber @bind-Value="_template.MinUsers" />
        </label>
    </p>
    <p>
        <label>
            Minimal user deadline date:
                <InputDate @bind-Value="_minUserDeadlineDate" />
        </label>
    </p>

    <p>
        <label>
            Minimal user deadline time:
                <input type="time" @bind="_minUserDeadlineTime" />
        </label>
    </p>

    <p>
        <label>
            Organizer:
            <InputText @bind-Value="_template.Organizer" />
        </label>
    </p>

    <p>
        <label>
            Guild:
            <InputText @bind-Value="_template.Guild" />
        </label>
    </p>
    <p>
        <label>
            Voice chat:
            <InputText @bind-Value="_template.VoiceChat" />
        </label>
    </p>
    <p>
        <label>
            Interval in Days:
            <InputNumber @bind-Value="_template.Interval" />
        </label>
    </p>
    <p>
        <label>
            Create Days Before:
            <InputNumber @bind-Value="_template.CreateDaysBefore" />
        </label>
    </p>

    @if(_template.RaidType == RaidType.Planned)
    {
        <p>
            <label>
                Roles:
            </label>
            <button type=button @onclick="() => AddRoleClicked()">Add role</button>
            <table>
                <tr>
                    <th>Spots</th>
                    <th>Role name</th>
                    <th>Description</th>
                </tr>
                @foreach( RaidRole role in _template.Roles)
                {
                    <tr>
                        <td><InputNumber @bind-Value="role.Spots" /></td>
                        <td><InputText @bind-Value="role.Name" /></td>
                        <td><InputText @bind-Value="role.Description" /></td>
                        <td><button type=button @onclick="() => DeleteRoleClicked(role)">Delete</button></td>
                    </tr>
                }
            </table> 
        </p>
    }
    
    <DiscordMessageEdit _raid=@_template _discordServers=@_discordServers _messagesToDelete=@_messagesToDelete ></DiscordMessageEdit>
    <StaticReminderEdit _raidReminders=@_staticReminders _discordServers=@_discordServers _remindersToDelete=@_remindersToDelete  _availableRoles=@_availabeGroups></StaticReminderEdit>
    <DynamicReminderEdit _raidReminders=@_dynamicReminders _discordServers=@_discordServers _remindersToDelete=@_remindersToDelete  _availableRoles=@_availabeGroups></DynamicReminderEdit>
    
    <ValidationSummary />
    <label class="validation-message" >@_errorMessage</label>
    <button type="submit">Submit</button>

</EditForm>
        <br/>
<button type="delete" @onclick="() => DeleteRaidClicked()">Delete Template</button>
<button type="copy" @onclick="() => CopyTemplate()">Copy Template</button>
</AuthorizeView>

@code {

    [Parameter]
    public string raidId { get; set; }

    [Parameter]
    public string editType { get; set; }

    public RaidTemplate _template;
    private LiebUser _user;
    private bool _editType = false;

    private string _errorMessage = string.Empty;

    private int _randomSpots = 10;
    private bool _isMultiDay = false;
    private DateTimeOffset _raidDate = DateTime.Now.Date;
    private DateTimeOffset _endDate = DateTime.Now.Date;
    private DateTimeOffset _startTime;
    private DateTimeOffset _endTime;
    private DateTimeOffset _freeForAllDate = DateTime.Now.Date;
    private DateTimeOffset _freeForAllTime;
    private DateTimeOffset _minUserDeadlineDate = DateTime.Now.Date;
    private DateTimeOffset _minUserDeadlineTime;
    private string _userTimeZone = string.Empty;

    private List<RaidRole> _rolesToDelete = new List<RaidRole>();
    private List<RaidReminder> _remindersToDelete = new List<RaidReminder>();
    private List<DiscordRaidMessage> _messagesToDelete = new List<DiscordRaidMessage>();

    private List<StaticRaidReminder> _staticReminders = new List<StaticRaidReminder>();
    private List<DynamicRaidReminder> _dynamicReminders = new List<DynamicRaidReminder>();

    private List<DiscordServer> _discordServers = new List<DiscordServer>();
    private List<LiebRole> _availabeGroups = new List<LiebRole>();


    protected override async Task OnInitializedAsync()
    {
        var authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
        if (authState != null)
        {
            ulong discordId = ulong.Parse(authState.User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier).Value);
            _user = UserService.GetLiebUser(discordId);
        }
        if(_user == null)
        {
            NavigationManager.NavigateTo("");
        }

        if(!string.IsNullOrEmpty(editType) && bool.TryParse(editType, out bool allowEdit))
        {
            _editType = allowEdit;
        }

        if(!string.IsNullOrEmpty(raidId) && int.TryParse(raidId, out int parsedId))
        {
            _template = RaidTemplateService.GetTemplate(parsedId);

            if (_template != null && (_template.RaidOwnerId == _user.Id 
                || _user.RoleAssignments.Max(a => a.LiebRole.Level) >= Constants.RaidEditPowerLevel))
            {
                if(_template.RaidType != RaidType.Planned)
                {
                    if(_template.Roles.Where(r => r.IsRandomSignUpRole).Any())
                    {
                        RaidRole role = _template.Roles.FirstOrDefault(r => r.IsRandomSignUpRole);
                        _randomSpots = role != null ? role.Spots : 10;
                    }
                }

                _startTime = _template.StartTime;
                _endTime = _template.EndTime;
                _raidDate = _startTime.Date;
                _endDate = _endTime.Date;
                _freeForAllTime = _template.FreeForAllTime;
                _freeForAllDate = _freeForAllTime.Date;
                _minUserDeadlineTime = _template.MinUserDeadLine;
                _minUserDeadlineDate = _minUserDeadlineTime.Date;
                _isMultiDay = _endTime - _startTime > new TimeSpan(24,0,0);
                foreach(RaidReminder reminder in _template.Reminders)
                {
                    if(reminder.TimeType == RaidReminder.ReminderTimeType.Static)
                    {
                        DateTimeOffset reminderTime = await TimeZoneService.GetLocalDateTime(reminder.ReminderTimeUTC);
                        DateTimeOffset reminderDate = (await TimeZoneService.GetLocalDateTime(reminder.ReminderTimeUTC)).Date;
                        _staticReminders.Add(new StaticRaidReminder(reminder, reminderDate, reminderTime));
                    }
                    else
                    {
                        _dynamicReminders.Add(new DynamicRaidReminder(reminder, _template.StartTime));
                    }
                }
            }
            else
            {
                _template = new RaidTemplate();
                _dynamicReminders.Add(DynamicRaidReminder.Create30MinReminder());
            }
        }
        else
        {
            _template = new RaidTemplate();
            _dynamicReminders.Add(DynamicRaidReminder.Create30MinReminder());
        }
        _userTimeZone = await TimeZoneService.GetUserTimeZone();
        _discordServers = await DiscordService.GetServers();
        _availabeGroups = UserService.GetUserRoles(_user.Id).Where(u => u.Type == RoleType.UserDefinedRole).ToList();
    }

    async Task AddRoleClicked()
    {
        _template.Roles.Add(new RaidRole());
    }


    async Task DeleteRoleClicked(RaidRole role)
    {
        if(role.RaidRoleId != 0)
        {
            _rolesToDelete.Add(role);
        }
        _template.Roles.Remove(role);
    }

    async Task DeleteRaidClicked()
    {
        bool confirmed = await JsRuntime.InvokeAsync<bool>("confirm", "Are you sure you want to delete the raid?");
        if (confirmed)
        {
            await RaidTemplateService.DeleteTemplate(_template.RaidTemplateId, _user.Id);
            NavigationManager.NavigateTo("raidtemplateoverview");
        }
    }

    private async Task HandleValidSubmit()
    {
        if(_template.RaidType != RaidType.Planned)
        {
            if(!_template.Roles.Where(r => r.IsRandomSignUpRole).Any())
            {
                _template.Roles.Add(RaidService.CreateRandomSignUpRole(_template.RaidType, _randomSpots));
            }
            else
            {
                _template.Roles.First(r => r.IsRandomSignUpRole).Spots = _randomSpots;
            }

            foreach(RaidRole role in _template.Roles.Where(r => !r.IsRandomSignUpRole))
            {
                _rolesToDelete.Add(role);
            }
        }

        if(_template.Roles.Count == 0)
        {
            _errorMessage = "Roles are needed for a raid.";
            return;
        }

        if(_isMultiDay && _endDate <= _raidDate)
        {
            _errorMessage = "The end date has to be after the start date.";
            return;
        }

        _template.TimeZone = await TimeZoneService.GetUserTimeZone();

        _template.StartTime =_raidDate.Date + _startTime.TimeOfDay;
        if(_isMultiDay)
        {
            _template.EndTime = _endDate.Date + _endTime.TimeOfDay;
        }
        else if(_startTime.TimeOfDay <= _endTime.TimeOfDay)
        {
            _template.EndTime = _raidDate.Date + _endTime.TimeOfDay;
        }
        else
        {
            _template.EndTime = _raidDate.Date.AddDays(1) + _endTime.TimeOfDay;
        }
        _template.FreeForAllTime = _freeForAllDate.Date + _freeForAllTime.TimeOfDay;
        _template.MinUserDeadLine = _minUserDeadlineDate.Date + _minUserDeadlineTime.TimeOfDay;

        if (!_template.RaidOwnerId.HasValue)
        {
            _template.RaidOwnerId = _user.Id;
        }

        _template.Reminders.Clear();
        foreach(DynamicRaidReminder reminder in _dynamicReminders)
        {
            reminder.ReminderTimeUTC = _template.StartTime - new TimeSpan(reminder.DaysBeforeRaid, reminder.HoursBeforeRaid, reminder.MinutesBeforeRaid, 0);
            reminder.Sent = true;
            _template.Reminders.Add(reminder);
        }
        foreach(StaticRaidReminder reminder in _staticReminders)
        {
            reminder.ReminderTimeUTC = reminder.ReminderDate.Date + reminder.ReminderTime.TimeOfDay;
            reminder.Sent = true;
            _template.Reminders.Add(reminder);
        }

        await RaidTemplateService.AddOrEditTemplate(_template, _rolesToDelete, _remindersToDelete, _messagesToDelete, _user.Id);
        NavigationManager.NavigateTo("raidtemplateoverview");
    }

    private async Task CopyTemplate()
    {
        RaidTemplate newTemplate = new RaidTemplate(_template);
        await RaidTemplateService.AddOrEditTemplate(newTemplate, new List<RaidRole>(), new List<RaidReminder>(), new List<DiscordRaidMessage>(), _user.Id);

        NavigationManager.NavigateTo($"/raidtemplateedit/{newTemplate.RaidTemplateId}/true", true);
    }
}