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

namespace Dpz.Core.Auth.Controllers;

[Authorize(nameof(Permissions.System))]
public class AuthorizationManageController(
    OpenIddictAuthorizationManager<DpzAuthorization> openIddictAuthorizationManager,
    IRepository<DpzAuthorization> authorizationRepository,
    IRepository<DpzApplication> dpzApplicationRepository,
    IPinCodeValidator pinCodeValidator
) : Controller
{
    public async Task<IActionResult> Index()
    {
        var account = User.NameIdentifier;
        if (string.IsNullOrWhiteSpace(account))
        {
            return View(new List<AuthApplicationModel>());
        }

        var subjectFilter = Builders<DpzAuthorization>.Filter.Eq(x => x.Subject, account);
        var applicationIds = await authorizationRepository
            .SearchFor(subjectFilter)
            .Project(x => x.ApplicationId)
            .ToListAsync();

        var applications = await dpzApplicationRepository
            .SearchFor(Builders<DpzApplication>.Filter.In(x => x.Id, applicationIds))
            .ToListAsync();

        var result = applications
            .Select(x => new AuthApplicationModel(x.Id.ToString(), x.ClientId, x.DisplayName))
            .OrderBy(x => x.DisplayName, StringComparer.OrdinalIgnoreCase)
            .ToList();

        return View(result);
    }

    [HttpGet]
    public async Task<IActionResult> Page(
        string? applicationId = null,
        string? status = null,
        string? type = null,
        string? keyword = null,
        int page = 1,
        int limit = 10
    )
    {
        if (page < 1)
        {
            page = 1;
        }
        if (limit < 1)
        {
            limit = 1;
        }

        var account = User.NameIdentifier;
        if (string.IsNullOrWhiteSpace(account))
        {
            return Json(new LayuiPageWarp<PageAuthorizationModel>());
        }

        var query = authorizationRepository.SearchFor(x => x.Subject == account);

        if (
            !string.IsNullOrWhiteSpace(applicationId)
            && ObjectId.TryParse(applicationId, out var appId)
        )
        {
            query = query.Where(x => x.ApplicationId == appId);
        }

        if (!string.IsNullOrWhiteSpace(status))
        {
            query = query.Where(x => x.Status == status);
        }

        if (!string.IsNullOrWhiteSpace(type))
        {
            query = query.Where(x => x.Type == type);
        }

        if (!string.IsNullOrWhiteSpace(keyword))
        {
            keyword = keyword.Trim();
            query = query.Where(x =>
                (x.Status != null && x.Status.Contains(keyword))
                || (x.Type != null && x.Type.Contains(keyword))
                || (x.Scopes != null && x.Scopes.Any(scope => scope.Contains(keyword)))
            );
        }

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

        var pageAppIds = pagedList.Select(x => x.ApplicationId).ToHashSet();
        var applications = await dpzApplicationRepository
            .SearchFor(Builders<DpzApplication>.Filter.In(x => x.Id, pageAppIds))
            .Project(x => new { x.Id, x.DisplayName })
            .ToListAsync();

        var data = pagedList
            .Select(x =>
            {
                var app = applications.FirstOrDefault(y => y.Id == x.ApplicationId);
                return new PageAuthorizationModel
                {
                    Id = x.Id.ToString(),
                    ApplicationId = x.ApplicationId.ToString(),
                    ApplicationName = app?.DisplayName ?? string.Empty,
                    Status = x.Status,
                    StatusName = AuthHelper.GetAuthorizationDescription(x.Status),
                    Type = x.Type,
                    TypeName = AuthHelper.GetAuthorizationDescription(x.Type),
                    CreationDate = x.CreationDate,
                    Scopes = x.Scopes?.ToList() ?? [],
                };
            })
            .ToList();

        return Json(new LayuiPageWarp<PageAuthorizationModel>(data, pagedList.TotalItemCount));
    }

    [HttpPost]
    public async Task<IActionResult> Revoke(RevokeAuthorizationModel model)
    {
        var account = User.NameIdentifier;
        if (string.IsNullOrWhiteSpace(account))
        {
            return Json(ResponseResult.ToFail("用户未登录"));
        }

        var (success, message) = await pinCodeValidator.ValidateAsync(account, model.PinCode);
        if (!success)
        {
            return Json(ResponseResult.ToFail(message));
        }

        await openIddictAuthorizationManager.RevokeAsync(
            account,
            model.ApplicationId,
            model.Status,
            model.Type
        );
        return Json(ResponseResult.ToSuccess("撤销授权成功"));
    }
}