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.Entity.S0.Sales;
using Admin.NET.Plugin.AiDOP.Infrastructure;

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

[ApiController]
[Route("api/s0/manufacturing/preprocess-elements")]
[AllowAnonymous]
[NonUnify]
public class AdoS0MfgPreprocessElementsController : ControllerBase
{
    private readonly SqlSugarRepository<AdoS0ItemOpCondition> _rep;
    private readonly SqlSugarRepository<AdoS0ItemMaster> _itemRep;
    private readonly SqlSugarRepository<AdoS0GeneralizedCodeMaster> _codeRep;

    public AdoS0MfgPreprocessElementsController(
        SqlSugarRepository<AdoS0ItemOpCondition> rep,
        SqlSugarRepository<AdoS0ItemMaster> itemRep,
        SqlSugarRepository<AdoS0GeneralizedCodeMaster> codeRep)
    {
        _rep = rep;
        _itemRep = itemRep;
        _codeRep = codeRep;
    }

    [HttpGet]
    public async Task<IActionResult> GetPagedAsync([FromQuery] AdoS0MfgPreprocessElementQueryDto q)
    {
        // 物料前处理要素：收敛到 ItemOpCondition，并固定 CodeType='PrevProcess'
        var page = q.EffectivePage;
        var pageSize = q.PageSize;
        (page, pageSize) = PagingGuard.Normalize(page, pageSize);

        // 兼容旧 QueryDto 字段：materialCode/materialName/elementCode/keyword/companyRefId... → 仅用作过滤
        var domain = (q.FactoryRefId?.ToString() ?? "").Trim(); // 旧 DTO 无 Domain，临时占位；前端已改为传 domain（见页面改造）
        // 若前端按方案传 domain，则会落在 q.Keyword 或其它字段里；这里允许从 querystring 直接读取 domain
        var qsDomain = HttpContext.Request.Query["domain"].ToString();
        if (!string.IsNullOrWhiteSpace(qsDomain)) domain = qsDomain.Trim();
        if (string.IsNullOrWhiteSpace(domain))
            return Ok(new { total = 0, page, pageSize, list = Array.Empty<object>() });

        var itemNums = new List<string>();
        if (!string.IsNullOrWhiteSpace(q.MaterialCode))
            itemNums.Add(q.MaterialCode.Trim());

        var query = _rep.AsQueryable()
            .Where(x => x.Domain == domain && x.CodeType == "PrevProcess")
            .WhereIF(!string.IsNullOrWhiteSpace(q.MaterialCode), x => x.ItemNum.Contains(q.MaterialCode!))
            .WhereIF(!string.IsNullOrWhiteSpace(q.ElementCode), x => x.ItemCode != null && x.ItemCode.Contains(q.ElementCode!))
            .WhereIF(!string.IsNullOrWhiteSpace(q.Keyword),
                x => x.ItemNum.Contains(q.Keyword!)
                    || (x.Op != null && x.Op.Contains(q.Keyword!))
                    || (x.ItemCode != null && x.ItemCode.Contains(q.Keyword!))
                    || (x.Descr != null && x.Descr.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();

        var distinctItemNums = list.Select(x => x.ItemNum).Distinct().ToList();
        var items = await _itemRep.AsQueryable()
            .Where(m => m.DomainCode == domain && distinctItemNums.Contains(m.ItemNum))
            .Select(m => new { m.ItemNum, m.Descr })
            .ToListAsync();
        var itemDescrMap = items.ToDictionary(x => x.ItemNum, x => x.Descr);

        var opVals = list.Select(x => x.Op).Where(x => !string.IsNullOrWhiteSpace(x)).Cast<string>().Distinct().ToList();
        var opCodes = await _codeRep.AsQueryable()
            .Where(x => x.Domain == domain && x.FldName == "PrevProcessOp" && opVals.Contains(x.Val))
            .Select(x => new { x.Val, x.Comments })
            .ToListAsync();
        var opDescrMap = opCodes.ToDictionary(x => x.Val, x => x.Comments ?? "");

        var shaped = list.Select(x => new
        {
            id = x.Id,
            itemNum = x.ItemNum,
            itemDescr = itemDescrMap.TryGetValue(x.ItemNum, out var desc) ? desc : "",
            op = x.Op,
            opDescr = x.Op != null && opDescrMap.TryGetValue(x.Op, out var odesc) ? odesc : "",
            itemCode = x.ItemCode,
            descr = x.Descr,
            isMain = x.IsMain,
            codeType = x.CodeType,
            domain = x.Domain,
            createUser = x.CreateUser,
            createTime = x.CreateTime,
            updateUser = x.UpdateUser,
            updateTime = x.UpdateTime,
        }).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] AdoS0ItemOpConditionUpsertDto dto)
    {
        var now = DateTime.Now;
        var entity = new AdoS0ItemOpCondition
        {
            Domain = dto.Domain.Trim(),
            CodeType = "PrevProcess",
            ItemNum = dto.ItemNum.Trim(),
            Op = dto.Op,
            Line = dto.Line,
            Typed = dto.Typed,
            ItemCode = dto.ItemCode,
            Descr = dto.Descr,
            IsMain = dto.IsMain,
            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] AdoS0ItemOpConditionUpsertDto dto)
    {
        var entity = await _rep.GetByIdAsync(id);
        if (entity == null) return NotFound();

        entity.Domain = dto.Domain.Trim();
        entity.CodeType = "PrevProcess";
        entity.ItemNum = dto.ItemNum.Trim();
        entity.Op = dto.Op;
        entity.Line = dto.Line;
        entity.Typed = dto.Typed;
        entity.ItemCode = dto.ItemCode;
        entity.Descr = dto.Descr;
        entity.IsMain = dto.IsMain;
        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 = "删除成功" });
    }
}