using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Sys.Entities;
using Kurisu.AspNetCore.Authentication.Options;
using Kurisu.Core.DataAccess.Entity;
using Kurisu.SqlSugar.Services;
using Microsoft.AspNetCore.Identity;
using Microsoft.Extensions.Options;

namespace Dlhis.ScheduledTask.CommonJobs
{
    public class TempCreateUserJob
    {
        private readonly IDbContext _dbContext;
        private readonly ILogger<TempCreateUserJob> _logger;
        private readonly IdentityServerOptions _identityServerOptions;
        private readonly IHttpClientFactory _httpClientFactory;

        public TempCreateUserJob(
            IDbContext dbContext,
            ILogger<TempCreateUserJob> logger,
            IOptions<IdentityServerOptions> options,
            IHttpClientFactory httpClientFactory)
        {
            _dbContext = dbContext;
            _logger = logger;
            _httpClientFactory = httpClientFactory;
            _identityServerOptions = options.Value;
        }

        public async Task RunAsync()
        {
            _dbContext.Client.QueryFilter.ClearAndBackup<ITenantId>();
            try
            {
                var identityDbContext = _dbContext.ChangeDb("identity");

                var userNames = await identityDbContext.Queryable<UserEntity>().Select(x => x.UserName).ToListAsync();
                var newUser = await _dbContext.Queryable<GainfoEntity>()
                    .Where(x => !string.IsNullOrEmpty(x.Code))
                    .Where(x => !userNames.Contains(x.Code))
                    .Select(x => new
                    {
                        x.Code,
                        x.Factory,
                        x.Name,
                    })
                    .ToListAsync();

                var httpClient = _httpClientFactory.CreateClient();
                httpClient.BaseAddress = new Uri(_identityServerOptions.Authority);

                var hasher = new PasswordHasher<UserEntity>();
                foreach (var item in newUser)
                {
                    var userName = item.Code;
                    var password = item.Code;
                    var factory = item.Factory;

                    if (password.Length > 6)
                    {
                        password = string.Join("", password.TakeLast(6));
                    }
                    else
                    {
                        password = password.PadLeft(6, '0');
                    }
                    var user = new UserEntity
                    {
                        UserName = userName,
                        NormalizedUserName = userName.ToUpper(),
                        ConcurrencyStamp = Guid.NewGuid().ToString(),
                        SecurityStamp = Guid.NewGuid().ToString(),
                    };

                    password = hasher.HashPassword(user, password);
                    user.PasswordHash = password;
                    var id = (int)await identityDbContext.InsertReturnIdentityAsync(user);

                    await identityDbContext.InsertAsync(new UserTenantEntity() { UserId = id, TenantCode = factory });
                    await identityDbContext.InsertAsync(new List<UserClaimEntity>
                    {
                        new UserClaimEntity{ UserId = id , ClaimType ="preferred_username", ClaimValue = item.Name},
                        new UserClaimEntity{ UserId = id , ClaimType ="jinko-code", ClaimValue = item.Code},
                    });
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "创建用户失败:{message}", ex.Message);
            }
            finally
            {
                _dbContext.Client.QueryFilter.Restore();
            }
        }
    }


}