using Dpz.Core.Auth.Models;
using Dpz.Core.EnumLibrary;
using Dpz.Core.MongodbAccess;
using Dpz.Core.Public.Entity;
using Dpz.Core.Public.Entity.Auth;
using Dpz.Core.Service;
using Dpz.Core.Service.RepositoryService;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using MongoDB.Bson;
using MongoDB.Driver;
using MongoDB.Driver.Linq;

namespace Dpz.Core.Auth.Controllers;

[Authorize(nameof(Permissions.System))]
public class AccessRequestController(
    IRepository<ApplicationAccessRequest> accessRequestRepository,
    IRepository<AllowedClient> allowedClientRepository,
    IRepository<DpzApplication> applicationRepository,
    IAccountService accountService
) : Controller
{
    [HttpGet]
    public async Task<IActionResult> Index()
    {
        var applications = await applicationRepository
            .SearchFor(x => true)
            .Select(x => new AuthApplicationModel(x.Id.ToString(), x.ClientId, x.DisplayName))
            .ToListAsync();

        return View(applications);
    }

    [HttpGet]
    public async Task<IActionResult> Page(
        string? account = null,
        string? clientId = null,
        DateTime? startDate = null,
        DateTime? endDate = null,
        int page = 1,
        int limit = 20
    )
    {
        var query = accessRequestRepository.SearchFor(x => true);

        if (!string.IsNullOrWhiteSpace(account))
        {
            query = query.Where(x => x.UserId == account);
        }

        if (!string.IsNullOrWhiteSpace(clientId))
        {
            query = query.Where(x => x.ClientId == clientId);
        }

        if (startDate.HasValue)
        {
            query = query.Where(x => x.RequestTime >= startDate.Value);
        }

        if (endDate.HasValue)
        {
            // End of the day
            var end = endDate.Value.Date.AddDays(1).AddTicks(-1);
            query = query.Where(x => x.RequestTime <= end);
        }

        var pagedList = await query
            .OrderByDescending(x => x.RequestTime)
            .ToPagedListAsync(page, limit);

        return Json(new LayuiPageWarp<ApplicationAccessRequest>(pagedList));
    }

    [HttpPost]
    public async Task<IActionResult> Handle(string id, AccessRequestStatus status, string remark)
    {
        var request = await accessRequestRepository.TryGetAsync(id);
        if (request == null)
        {
            return NotFound("Request not found");
        }

        var handler = await accountService.GetOneUserAsync(User.NameIdentifier);
        if (handler == null)
        {
            return BadRequest("Handler not found");
        }

        if (!ObjectId.TryParse(id, out var oid))
        {
            return BadRequest("Invalid request id");
        }

        // If restoring to pending
        if (status == AccessRequestStatus.Pending)
        {
            // Revoke access if it was approved
            if (request.Status == AccessRequestStatus.Approved)
            {
                await allowedClientRepository.DeleteAsync(x =>
                    x.Account == request.UserId && x.ApplicationId == request.ClientId
                );
            }

            request.Status = AccessRequestStatus.Pending;
            request.HandleTime = null;
            request.HandlerId = null;
            request.HandlerName = null;
            request.HandleRemark = null;

            await accessRequestRepository.UpdateAsync(
                x => x.Id == oid,
                Builders<ApplicationAccessRequest>
                    .Update.Set(x => x.Status, AccessRequestStatus.Pending)
                    .Set(x => x.HandleTime, null)
                    .Set(x => x.HandlerId, null)
                    .Set(x => x.HandlerName, null)
                    .Set(x => x.HandleRemark, null)
            );

            return RedirectToAction("Index");
        }
        
        if (
            request.Status == AccessRequestStatus.Approved
            && status != AccessRequestStatus.Approved
        )
        {
            await allowedClientRepository.DeleteAsync(x =>
                x.Account == request.UserId && x.ApplicationId == request.ClientId
            );
        }

        request.Status = status;
        request.HandleTime = DateTime.Now;
        request.HandlerId = handler.Id;
        request.HandlerName = handler.Name;
        request.HandleRemark = remark;

        await accessRequestRepository.UpdateAsync(
            x => x.Id == oid,
            Builders<ApplicationAccessRequest>
                .Update.Set(x => x.Status, status)
                .Set(x => x.HandleTime, request.HandleTime)
                .Set(x => x.HandlerId, request.HandlerId)
                .Set(x => x.HandlerName, request.HandlerName)
                .Set(x => x.HandleRemark, request.HandleRemark)
        );

        if (status != AccessRequestStatus.Approved)
        {
            return RedirectToAction("Index");
        }

        var exists = await allowedClientRepository
            .SearchFor(x => x.Account == request.UserId && x.ApplicationId == request.ClientId)
            .AnyAsync();
        if (!exists)
        {
            await allowedClientRepository.InsertAsync(
                new AllowedClient
                {
                    Account = request.UserId,
                    ApplicationId = request.ClientId,
                    ApplicationName = request.ClientDisplayName,
                    AllowedTime = DateTime.Now,
                }
            );
        }

        return RedirectToAction("Index");
    }
}