using Admin.NET.Plugin.AiDOP.Dto.S0.Manufacturing;
using Admin.NET.Plugin.AiDOP.Dto.S0.Sales;
using Admin.NET.Plugin.AiDOP.Entity.S0.Manufacturing;
using Admin.NET.Plugin.AiDOP.Infrastructure;

namespace Admin.NET.Plugin.AiDOP.Controllers.S0.Manufacturing;

[ApiController]
[Route("api/s0/manufacturing/line-materials")]
[AllowAnonymous]
[NonUnify]
public class AdoS0MfgLineMaterialsController : ControllerBase
{
    private readonly SqlSugarRepository<AdoS0ProdLineDetail> _rep;
    private readonly SqlSugarRepository<AdoS0WorkCtrMaster> _workCtrRep;
    private readonly SqlSugarRepository<AdoS0LineMaster> _lineMasterRep;

    public AdoS0MfgLineMaterialsController(
        SqlSugarRepository<AdoS0ProdLineDetail> rep,
        SqlSugarRepository<AdoS0WorkCtrMaster> workCtrRep,
        SqlSugarRepository<AdoS0LineMaster> lineMasterRep)
    {
        _rep = rep;
        _workCtrRep = workCtrRep;
        _lineMasterRep = lineMasterRep;
    }

    [HttpGet]
    public async Task<IActionResult> GetPagedAsync([FromQuery] AdoS0ProdLineDetailQueryDto q)
    {
        var page = q.EffectivePage;
        var pageSize = q.PageSize;
        (page, pageSize) = PagingGuard.Normalize(page, pageSize);

        // 源平台 where IsActive=1；这里默认仅返回启用记录
        var query = _rep.AsQueryable()
            .Where(x => x.IsActive)
            .WhereIF(!string.IsNullOrWhiteSpace(q.Domain), x => x.Domain == q.Domain)
            .WhereIF(!string.IsNullOrWhiteSpace(q.Part), x => x.Part.Contains(q.Part!))
            .WhereIF(!string.IsNullOrWhiteSpace(q.Op), x => x.Op != null && x.Op.Contains(q.Op!))
            .WhereIF(!string.IsNullOrWhiteSpace(q.Site), x => x.Site != null && x.Site.Contains(q.Site!))
            .WhereIF(!string.IsNullOrWhiteSpace(q.Line), x => x.Line != null && x.Line.Contains(q.Line!))
            .WhereIF(!string.IsNullOrWhiteSpace(q.Keyword),
                x =>
                    x.Part.Contains(q.Keyword!)
                    || (x.Op != null && x.Op.Contains(q.Keyword!))
                    || (x.Site != null && x.Site.Contains(q.Keyword!))
                    || (x.Line != null && x.Line.Contains(q.Keyword!))
                    || (x.SkillNo != null && x.SkillNo.Contains(q.Keyword!)));

        var total = await query.CountAsync();
        var list = await query.OrderByDescending(x => x.UpdateTime ?? x.CreateTime).Skip((page - 1) * pageSize).Take(pageSize).ToListAsync();

        // 补展示字段：Describe（line 描述）、SiteDisplay（site + workCtr descr）、TimeInMinutes、OpStdOp（当前阶段仅回填 Op）
        var domain = q.Domain?.Trim();
        var lineCodes = list.Select(x => x.Line).Where(x => !string.IsNullOrWhiteSpace(x)).Cast<string>().Distinct().ToList();
        var workCtrCodes = list.Select(x => x.Site).Where(x => !string.IsNullOrWhiteSpace(x)).Cast<string>().Distinct().ToList();

        var lineDescribeMap = new Dictionary<string, string>();
        if (!string.IsNullOrWhiteSpace(domain) && lineCodes.Count > 0)
        {
            var lines = await _lineMasterRep.AsQueryable()
                .Where(x => x.Domain == domain && lineCodes.Contains(x.Line))
                .ToListAsync();
            lineDescribeMap = lines.ToDictionary(x => x.Line, x => x.Describe ?? string.Empty);
        }

        var workCtrDescrMap = new Dictionary<string, string>();
        if (!string.IsNullOrWhiteSpace(domain) && workCtrCodes.Count > 0)
        {
            var ctrs = await _workCtrRep.AsQueryable()
                .Where(x => x.Domain == domain && workCtrCodes.Contains(x.WorkCtr))
                .ToListAsync();
            workCtrDescrMap = ctrs.ToDictionary(x => x.WorkCtr, x => x.Descr ?? string.Empty);
        }

        var shaped = list.Select(x =>
        {
            var line = x.Line ?? string.Empty;
            var site = x.Site ?? string.Empty;
            var describe = (!string.IsNullOrWhiteSpace(line) && lineDescribeMap.TryGetValue(line, out var d)) ? d : string.Empty;
            var siteDescr = (!string.IsNullOrWhiteSpace(site) && workCtrDescrMap.TryGetValue(site, out var sd)) ? sd : string.Empty;
            var timeInMinutes = (x.SetupTime ?? 0m) * 60m;
            return new
            {
                id = x.Id,
                part = x.Part,
                op = x.Op,
                site = x.Site,
                siteDisplay = $"{site} {siteDescr}".Trim(),
                line = x.Line,
                describe,
                rate = x.Rate,
                setupTime = x.SetupTime,
                skillNo = x.SkillNo,
                internalEquipmentTypeCode = x.InternalEquipmentTypeCode,
                moldTypeCode = x.MoldTypeCode,
                standardStaffCount = x.StandardStaffCount,
                start = x.Start,
                isActive = x.IsActive,
                isConfirm = x.IsConfirm,
                domain = x.Domain,
                createUser = x.CreateUser,
                createTime = x.CreateTime,
                updateUser = x.UpdateUser,
                updateTime = x.UpdateTime,
                timeInMinutes,
                opStdOp = x.Op == null ? "" : x.Op
            };
        }).ToList();

        return Ok(new { total, page, pageSize, list = shaped });
    }

    [HttpGet("{id:long}")]
    public async Task<IActionResult> GetAsync(long id)
    {
        var item = await _rep.GetByIdAsync(id);
        return item == null ? NotFound() : Ok(item);
    }

    [HttpPost]
    public async Task<IActionResult> CreateAsync([FromBody] AdoS0ProdLineDetailUpsertDto dto)
    {
        var now = DateTime.Now;
        var entity = new AdoS0ProdLineDetail
        {
            Part = dto.Part.Trim(),
            Op = dto.Op,
            Site = dto.Site,
            Line = dto.Line,
            Rate = dto.Rate,
            SetupTime = dto.SetupTime,
            SkillNo = dto.SkillNo,
            InternalEquipmentTypeCode = dto.InternalEquipmentTypeCode,
            MoldTypeCode = dto.MoldTypeCode,
            StandardStaffCount = dto.StandardStaffCount,
            Start = dto.Start,
            IsActive = dto.IsActive,
            IsConfirm = dto.IsConfirm,
            Domain = dto.Domain.Trim(),
            CreateUser = dto.CreateUser ?? dto.UpdateUser,
            CreateTime = dto.CreateTime ?? dto.UpdateTime ?? now,
            UpdateUser = dto.UpdateUser,
            UpdateTime = dto.UpdateTime
        };
        await _rep.AsInsertable(entity).ExecuteReturnEntityAsync();
        return Ok(entity);
    }

    [HttpPut("{id:long}")]
    public async Task<IActionResult> UpdateAsync(long id, [FromBody] AdoS0ProdLineDetailUpsertDto dto)
    {
        var entity = await _rep.GetByIdAsync(id);
        if (entity == null) return NotFound();
        entity.Part = dto.Part.Trim();
        entity.Op = dto.Op;
        entity.Site = dto.Site;
        entity.Line = dto.Line;
        entity.Rate = dto.Rate;
        entity.SetupTime = dto.SetupTime;
        entity.SkillNo = dto.SkillNo;
        entity.InternalEquipmentTypeCode = dto.InternalEquipmentTypeCode;
        entity.MoldTypeCode = dto.MoldTypeCode;
        entity.StandardStaffCount = dto.StandardStaffCount;
        entity.Start = dto.Start;
        entity.IsActive = dto.IsActive;
        entity.IsConfirm = dto.IsConfirm;
        entity.Domain = dto.Domain.Trim();
        entity.UpdateUser = dto.UpdateUser;
        entity.UpdateTime = dto.UpdateTime ?? DateTime.Now;
        await _rep.AsUpdateable(entity).ExecuteCommandAsync();
        return Ok(entity);
    }

    [HttpDelete("{id:long}")]
    public async Task<IActionResult> DeleteAsync(long id)
    {
        var item = await _rep.GetByIdAsync(id);
        if (item == null) return NotFound();
        await _rep.DeleteAsync(item);
        return Ok(new { message = "删除成功" });
    }
}