using Admin.NET.Plugin.AiDOP.Entity.S0.Manufacturing;
using Admin.NET.Plugin.AiDOP.Entity.S0.Warehouse;

namespace Admin.NET.Plugin.AiDOP.Service.S8;

public class S8MasterDataAdapter : ITransient
{
    private readonly SqlSugarRepository<AdoS0DepartmentMaster> _deptRep;
    private readonly SqlSugarRepository<AdoS0EmployeeMaster> _empRep;
    private readonly SqlSugarRepository<AdoS0LineMaster> _lineRep;
    private readonly SqlSugarRepository<SysUser> _sysUserRep;

    public S8MasterDataAdapter(
        SqlSugarRepository<AdoS0DepartmentMaster> deptRep,
        SqlSugarRepository<AdoS0EmployeeMaster> empRep,
        SqlSugarRepository<AdoS0LineMaster> lineRep,
        SqlSugarRepository<SysUser> sysUserRep)
    {
        _deptRep = deptRep;
        _empRep = empRep;
        _lineRep = lineRep;
        _sysUserRep = sysUserRep;
    }

    public async Task<object> GetDepartmentsAsync(long? factoryRefId) =>
        await _deptRep.AsQueryable()
            .WhereIF(factoryRefId.HasValue, x => x.FactoryRefId == factoryRefId!.Value)
            .Take(500)
            .Select(x => new { id = x.Id, code = x.Department, name = x.Descr ?? x.Department })
            .ToListAsync();

    public async Task<object> GetEmployeesAsync(long? factoryRefId)
    {
        var emps = await _empRep.AsQueryable()
            .WhereIF(factoryRefId.HasValue, x => x.FactoryRefId == factoryRefId!.Value)
            .Take(500)
            .Select(x => new { x.Id, x.Name, x.Employee, x.SysUserId })
            .ToListAsync();

        var sysUserIds = emps.Where(e => e.SysUserId.HasValue && e.SysUserId.Value > 0)
            .Select(e => e.SysUserId!.Value).Distinct().ToList();

        Dictionary<long, (string? RealName, string? Account)> userMap = new();
        if (sysUserIds.Count > 0)
        {
            var users = await _sysUserRep.AsQueryable().ClearFilter()
                .Where(u => sysUserIds.Contains(u.Id))
                .Select(u => new { u.Id, u.RealName, u.Account })
                .ToListAsync();
            userMap = users.ToDictionary(u => u.Id, u => ((string?)u.RealName, (string?)u.Account));
        }

        return emps.Select(e =>
        {
            var bound = e.SysUserId.HasValue && e.SysUserId.Value > 0 && userMap.ContainsKey(e.SysUserId.Value);
            string? sysUserName = null;
            if (bound)
            {
                var (realName, account) = userMap[e.SysUserId!.Value];
                sysUserName = !string.IsNullOrWhiteSpace(realName) ? realName : account;
            }
            return new
            {
                id = e.Id,
                name = e.Name ?? e.Employee,
                empCode = e.Employee,
                sysUserId = e.SysUserId,
                sysUserName,
                bindStatus = bound ? "BOUND" : "UNBOUND"
            };
        }).ToList();
    }

    public async Task<object> GetLinesAsync(long? factoryRefId) =>
        await _lineRep.AsQueryable()
            .WhereIF(factoryRefId.HasValue, x => x.FactoryRefId == factoryRefId!.Value)
            .Take(500)
            .Select(x => new { id = x.Id, code = x.Line, name = x.Describe ?? x.Line })
            .ToListAsync();
}