using Abp.Application.Services.Dto;
using Abp.Auditing;
using Abp.Authorization;
using Abp.Domain.Repositories;
using Abp.Extensions;
using Abp.Linq.Extensions;
using Abp.Runtime.Security;

using VberZero.AppService.Base;
using VberZero.AppService.Base.Dto;
using VberZero.AppService.MultiTenancy.Dto;
using VberZero.Auditing;
using VberZero.Authorization.Roles;
using VberZero.Authorization.Users;
using VberZero.BaseSystem.MultiTenancy;
using VberZero.BaseSystem.Users;
using VberZero.MultiTenancy;
using VberZero.Tools.StringModel;

namespace VberZero.AppService.MultiTenancy;

[AbpAuthorize, AuditLog("租户管理", "租户")]
public class TenantAppServiceBase : VzCrudAppServiceBase<Tenant, TenantDto, int, VzPagedRequestDto, CreateTenantDto, TenantDto>, ITenantAppServiceBase
{
    private readonly VzTenantManager _tenantManager;

    //private readonly EditionManager _editionManager;
    private readonly VzUserManager _userManager;

    private readonly VzRoleManager _roleManager;
    private readonly IVzDbMigrator _vzDbMigrator;

    public TenantAppServiceBase(
        IRepository<Tenant, int> repository,
        VzTenantManager tenantManager,
        VzUserManager userManager,
        VzRoleManager roleManager, IVzDbMigrator vzDbMigrator)
        : base(repository)
    {
        _tenantManager = tenantManager;
        _userManager = userManager;
        _roleManager = roleManager;
        _vzDbMigrator = vzDbMigrator;
    }

    public override async Task Create(CreateTenantDto input)
    {
        CheckCreatePermission();

        // Create tenant
        var tenant = ObjectMapper.Map<Tenant>(input);
        tenant.ConnectionString = input.ConnectionString.IsNullOrEmpty()
            ? null
            : SimpleStringCipher.Instance.Encrypt(input.ConnectionString);

        //var defaultEdition = await _editionManager.FindByNameAsync(EditionManager.DefaultEditionName);
        //if (defaultEdition != null)
        //{
        //    tenant.EditionId = defaultEdition.Id;
        //}

        await _tenantManager.CreateAsync(tenant);
        await CurrentUnitOfWork.SaveChangesAsync(); // To get new tenant's id.

        // Create tenant database
        _vzDbMigrator.CreateOrMigrateForTenant(tenant);

        // We are working entities of new tenant, so changing tenant filter
        using (CurrentUnitOfWork.SetTenantId(tenant.Id))
        {
            // Create static roles for new tenant
            CheckErrors(await _roleManager.CreateStaticRoles(tenant.Id));

            await CurrentUnitOfWork.SaveChangesAsync(); // To get static role ids

            // Grant all permissions to admin role
            var adminRole = _roleManager.Roles.Single(r => r.Name == VzStaticRoleNames.Tenants.Admin);
            await _roleManager.GrantAllPermissionsAsync(adminRole);

            // Create admin user for the tenant
            var adminUser = User.CreateTenantAdminUser(tenant.Id, input.AdminEmailAddress);
            await _userManager.InitializeOptionsAsync(tenant.Id);
            CheckErrors(await _userManager.CreateAsync(adminUser, User.DefaultPassword));
            await CurrentUnitOfWork.SaveChangesAsync(); // To get admin user's id

            // Assign admin user to role!
            CheckErrors(await _userManager.AddToRoleAsync(adminUser, adminRole.Name));
            await CurrentUnitOfWork.SaveChangesAsync();
        }
    }

    protected override void MapToEntity(TenantDto updateInput, Tenant entity)
    {
        // Manually mapped since TenantDto contains non-editable properties too.
        entity.Name = updateInput.Name;
        entity.TenancyName = updateInput.TenancyName;
        entity.IsActive = updateInput.IsActive;
    }

    public override async Task Delete(VzEntityDto<int> input)
    {
        CheckDeletePermission();

        var tenant = await _tenantManager.GetByIdAsync(input.Id);
        await _tenantManager.DeleteAsync(tenant);
    }

    [DisableAuditing]
    public override async Task<PagedResultDto<TenantDto>> GetAll(VzPagedRequestDto input)
    {
        var query = CreateFilteredQuery(input);

        var totalCount = await AsyncQueryableExecuter.CountAsync(query);
        query = ApplySorting(query, input);
        query = ApplyPaging(query, input);
        var entities = await AsyncQueryableExecuter.ToListAsync(query);
        return new PagedResultDto<TenantDto>(totalCount, entities.Select(MapToEntityDto).ToList());
    }

    protected override IQueryable<T> SelfSorting<T>(IQueryable<T> query, VzPagedRequestDto input)
    {
        if (query is IQueryable<Tenant> queryable)
            return (IQueryable<T>)queryable.OrderBy(r => r.CreationTime);
        return query;
    }

    protected override IQueryable<T> KeyWordFilter<T>(IQueryable<T> query, string keyword)
    {
        if (query is IQueryable<Tenant> queryable)
            return (IQueryable<T>)queryable.WhereIf(keyword.NotEmpty(), a =>
                a.Name.Contains(keyword) || a.TenancyName.Contains(keyword));
        return query;
    }
}