@namespace Oqtane.Modules.Admin.RecycleBin
@inherits ModuleBase
@inject NavigationManager NavigationManager
@inject IPageModuleService PageModuleService
@inject IModuleService ModuleService
@inject IPageService PageService

<div class="container-fluid">
    <div class="form-group">

        <ul class="nav nav-tabs" role="tablist">
            <li class="nav-item">
                <a class="nav-link active" data-toggle="tab" href="#Pages" role="tab">
                    Pages
                </a>
            </li>
            <li class="nav-item">
                <a class="nav-link" data-toggle="tab" href="#Modules" role="tab">
                    Modules
                </a>
            </li>
        </ul>

        <div class="tab-content">
            <div id="Pages" class="tab-pane fade show active" role="tabpanel">
                @if (pages == null)
                {
                    <br />
                    <p>No Deleted Pages</p>
                }
                else
                {
                    <Pager Items="@pages">
                        <Header>
                            <th>&nbsp;</th>
                            <th>&nbsp;</th>
                            <th>Name</th>
                            <th>Deleted By</th>
                            <th>Deleted On</th>
                        </Header>
                        <Row>
                            <td><button @onclick="@(() => RestorePage(context))" class="btn btn-info" title="Restore">Restore</button></td>
                            <td><ActionDialog Header="Delete Page" Message="@("Are You Sure You Wish To Permanently Delete The " + context.Name + " Page?")" Action="Delete" Security="SecurityAccessLevel.Admin" Class="btn btn-danger" OnClick="@(async () => await DeletePage(context))" /></td>
                            <td>@context.Name</td>
                            <td>@context.DeletedBy</td>
                            <td>@context.DeletedOn</td>
                        </Row>
                    </Pager>
                }
            </div>
            <div id="Modules" class="tab-pane fade" role="tabpanel">
                @if (modules == null)
                {
                    <br />
                    <p>No Deleted Modules</p>
                }
                else
                {
                    <Pager Items="@modules">
                        <Header>
                            <th>&nbsp;</th>
                            <th>&nbsp;</th>
                            <th>Page</th>
                            <th>Module</th>
                            <th>Deleted By</th>
                            <th>Deleted On</th>
                        </Header>
                        <Row>
                            <td><button @onclick="@(() => RestoreModule(context))" class="btn btn-info" title="Restore">Restore</button></td>
                            <td><ActionDialog Header="Delete Module" Message="@("Are You Sure You Wish To Permanently Delete The " + context.Title + " Module?")" Action="Delete" Security="SecurityAccessLevel.Admin" Class="btn btn-danger" OnClick="@(async () => await DeleteModule(context))" /></td>
                            <td>@PageState.Pages.Find(item => item.PageId == context.PageId).Name</td>
                            <td>@context.Title</td>
                            <td>@context.DeletedBy</td>
                            <td>@context.DeletedOn</td>
                        </Row>
                    </Pager>
                }
            </div>
        </div>
    </div>
</div>

@code {
    public override SecurityAccessLevel SecurityAccessLevel { get { return SecurityAccessLevel.Admin; } }

    List<Page> pages;
    List<Module> modules;

    protected override async Task OnInitializedAsync()
    {
        try
        {
            await Load();
        }
        catch (Exception ex)
        {
            await logger.LogError(ex, "Error Loading Deleted Pages Or Modules {Error}", ex.Message);
            AddModuleMessage("Error Loading Deleted Pages Or Modules", MessageType.Error);
        }
    }

    private async Task Load()
    {
        pages = await PageService.GetPagesAsync(PageState.Site.SiteId);
        pages = pages.Where(item => item.IsDeleted).ToList();

        modules = await ModuleService.GetModulesAsync(PageState.Site.SiteId);
        modules = modules.Where(item => item.IsDeleted).ToList();
    }

    private async Task RestorePage(Page Page)
    {
        try
        {
            Page.IsDeleted = false;
            await PageService.UpdatePageAsync(Page);
            await logger.LogInformation("Page Restored {Page}", Page);
            await Load();
            StateHasChanged();
            NavigationManager.NavigateTo(NavigateUrl(Reload.Site));
        }
        catch (Exception ex)
        {
            await logger.LogError(ex, "Error Restoring Deleted Page {Page} {Error}", Page, ex.Message);
            AddModuleMessage("Error Restoring Deleted Page", MessageType.Error);
        }
    }

    private async Task DeletePage(Page Page)
    {
        try
        {
            await PageService.DeletePageAsync(Page.PageId);
            await logger.LogInformation("Page Permanently Deleted {Page}", Page);
            await Load();
            StateHasChanged();
            NavigationManager.NavigateTo(NavigateUrl(Reload.Site));
        }
        catch (Exception ex)
        {
            await logger.LogError(ex, "Error Permanently Deleting Page {Page} {Error}", Page, ex.Message);
            AddModuleMessage(ex.Message, MessageType.Error);
        }
    }

    private async Task RestoreModule(Module Module)
    {
        try
        {
            PageModule pagemodule = await PageModuleService.GetPageModuleAsync(Module.PageModuleId);
            pagemodule.IsDeleted = false;
            await PageModuleService.UpdatePageModuleAsync(pagemodule);
            await logger.LogInformation("Module Restored {Module}", Module);
            await Load();
            StateHasChanged();
        }
        catch (Exception ex)
        {
            await logger.LogError(ex, "Error Restoring Deleted Module {Module} {Error}", Module, ex.Message);
            AddModuleMessage("Error Restoring Deleted Module", MessageType.Error);
        }
    }

    private async Task DeleteModule(Module Module)
    {
        try
        {
            await PageModuleService.DeletePageModuleAsync(Module.PageModuleId);
            // check if there are any remaining module instances in the site
            modules = await ModuleService.GetModulesAsync(PageState.Site.SiteId);
            if (!modules.Exists(item => item.ModuleId == Module.ModuleId))
            {
                await ModuleService.DeleteModuleAsync(Module.ModuleId);
            }
            await logger.LogInformation("Module Permanently Deleted {Module}", Module);
            await Load();
            StateHasChanged();
        }
        catch (Exception ex)
        {
            await logger.LogError(ex, "Error Permanently Deleting Module {Module} {Error}", Module, ex.Message);
            AddModuleMessage("Error Permanently Deleting Module", MessageType.Error);
        }
    }
}