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<AdoS0MfgPreprocessElement> _headRep;
    private readonly SqlSugarRepository<AdoS0MfgPreprocessElementParam> _paramRep;
    private readonly SqlSugarRepository<AdoS0Material> _materialRep;
    private readonly SqlSugarRepository<AdoS0MfgElementParam> _elementParamRep;

    public AdoS0MfgPreprocessElementsController(
        SqlSugarRepository<AdoS0MfgPreprocessElement> headRep,
        SqlSugarRepository<AdoS0MfgPreprocessElementParam> paramRep,
        SqlSugarRepository<AdoS0Material> materialRep,
        SqlSugarRepository<AdoS0MfgElementParam> elementParamRep)
    {
        _headRep = headRep;
        _paramRep = paramRep;
        _materialRep = materialRep;
        _elementParamRep = elementParamRep;
    }

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

        List<long>? materialFilterIds = null;
        if (!string.IsNullOrWhiteSpace(q.MaterialCode) || !string.IsNullOrWhiteSpace(q.MaterialName))
        {
            var mq = _headRep.Context.Queryable<AdoS0Material>()
                .WhereIF(q.CompanyRefId.HasValue, m => m.CompanyRefId == q.CompanyRefId!.Value)
                .WhereIF(q.FactoryRefId.HasValue, m => m.FactoryRefId == q.FactoryRefId!.Value)
                .WhereIF(!string.IsNullOrWhiteSpace(q.MaterialCode), m => m.Code.Contains(q.MaterialCode!))
                .WhereIF(!string.IsNullOrWhiteSpace(q.MaterialName), m => m.Name.Contains(q.MaterialName!))
                .Select(m => m.Id);
            materialFilterIds = await mq.ToListAsync();
            if (materialFilterIds.Count == 0)
                return Ok(new { total = 0, page, pageSize, list = Array.Empty<AdoS0MfgPreprocessElement>() });
        }

        var query = _headRep.AsQueryable()
            .WhereIF(q.CompanyRefId.HasValue, x => x.CompanyRefId == q.CompanyRefId!.Value)
            .WhereIF(q.FactoryRefId.HasValue, x => x.FactoryRefId == q.FactoryRefId!.Value)
            .WhereIF(materialFilterIds != null, x => x.MaterialId != null && materialFilterIds!.Contains(x.MaterialId.Value))
            .WhereIF(!string.IsNullOrWhiteSpace(q.Keyword),
                x => x.Code.Contains(q.Keyword!) || x.Name.Contains(q.Keyword!))
            .WhereIF(!string.IsNullOrWhiteSpace(q.ElementCode), x => x.Code.Contains(q.ElementCode!))
            .WhereIF(q.IsEnabled.HasValue, x => x.IsEnabled == q.IsEnabled!.Value);

        var total = await query.CountAsync();
        var list = await query.OrderByDescending(x => x.CreatedAt).Skip((page - 1) * pageSize).Take(pageSize).ToListAsync();
        return Ok(new { total, page, pageSize, list });
    }

    [HttpGet("{id:long}")]
    public async Task<IActionResult> GetDetailAsync(long id)
    {
        var header = await _headRep.GetByIdAsync(id);
        if (header == null) return NotFound();
        var @params = await _paramRep.AsQueryable()
            .Where(x => x.PreprocessElementId == id)
            .OrderBy(x => x.SortNo)
            .ToListAsync();
        return Ok(new { header, @params });
    }

    [HttpPost]
    public async Task<IActionResult> CreateAsync([FromBody] AdoS0MfgPreprocessElementUpsertDto dto)
    {
        var fkErr = await ValidatePreprocessFksAsync(dto);
        if (fkErr != null) return BadRequest(new { message = fkErr });

        var db = _headRep.Context;
        await db.Ado.BeginTranAsync();
        try
        {
            var head = new AdoS0MfgPreprocessElement
            {
                CompanyRefId = dto.CompanyRefId,
                FactoryRefId = dto.FactoryRefId,
                Code = dto.Code,
                Name = dto.Name,
                MaterialId = dto.MaterialId,
                OperationId = dto.OperationId,
                IsKeyElement = dto.IsKeyElement,
                Remark = dto.Remark,
                IsEnabled = dto.IsEnabled,
                CreatedAt = DateTime.Now
            };
            head = await _headRep.AsInsertable(head).ExecuteReturnEntityAsync();

            foreach (var p in dto.Params)
            {
                var row = MapParam(head.Id, dto.CompanyRefId, dto.FactoryRefId, p);
                await _paramRep.AsInsertable(row).ExecuteCommandAsync();
            }

            await db.Ado.CommitTranAsync();
            return await GetDetailAsync(head.Id);
        }
        catch
        {
            await db.Ado.RollbackTranAsync();
            throw;
        }
    }

    [HttpPut("{id:long}")]
    public async Task<IActionResult> UpdateAsync(long id, [FromBody] AdoS0MfgPreprocessElementUpsertDto dto)
    {
        var header = await _headRep.GetByIdAsync(id);
        if (header == null) return NotFound();

        var fkErr = await ValidatePreprocessFksAsync(dto);
        if (fkErr != null) return BadRequest(new { message = fkErr });

        var db = _headRep.Context;
        await db.Ado.BeginTranAsync();
        try
        {
            header.CompanyRefId = dto.CompanyRefId;
            header.FactoryRefId = dto.FactoryRefId;
            header.Code = dto.Code;
            header.Name = dto.Name;
            header.MaterialId = dto.MaterialId;
            header.OperationId = dto.OperationId;
            header.IsKeyElement = dto.IsKeyElement;
            header.Remark = dto.Remark;
            header.IsEnabled = dto.IsEnabled;
            header.UpdatedAt = DateTime.Now;
            await _headRep.AsUpdateable(header).ExecuteCommandAsync();

            await _paramRep.AsDeleteable().Where(x => x.PreprocessElementId == id).ExecuteCommandAsync();
            foreach (var p in dto.Params)
            {
                var row = MapParam(id, dto.CompanyRefId, dto.FactoryRefId, p);
                await _paramRep.AsInsertable(row).ExecuteCommandAsync();
            }

            await db.Ado.CommitTranAsync();
            return await GetDetailAsync(id);
        }
        catch
        {
            await db.Ado.RollbackTranAsync();
            throw;
        }
    }

    [HttpPatch("{id:long}/toggle-enabled")]
    public async Task<IActionResult> ToggleEnabledAsync(long id, [FromBody] AdoS0ToggleEnabledDto dto)
    {
        var entity = await _headRep.GetByIdAsync(id);
        if (entity == null) return NotFound();
        entity.IsEnabled = dto.IsEnabled;
        entity.UpdatedAt = DateTime.Now;
        await _headRep.AsUpdateable(entity).ExecuteCommandAsync();
        return Ok(entity);
    }

    [HttpDelete("{id:long}")]
    public async Task<IActionResult> DeleteAsync(long id)
    {
        var header = await _headRep.GetByIdAsync(id);
        if (header == null) return NotFound();

        var db = _headRep.Context;
        await db.Ado.BeginTranAsync();
        try
        {
            await _paramRep.AsDeleteable().Where(x => x.PreprocessElementId == id).ExecuteCommandAsync();
            await _headRep.DeleteAsync(header);
            await db.Ado.CommitTranAsync();
            return Ok(new { message = "删除成功" });
        }
        catch
        {
            await db.Ado.RollbackTranAsync();
            throw;
        }
    }

    private async Task<string?> ValidatePreprocessFksAsync(AdoS0MfgPreprocessElementUpsertDto dto)
    {
        if (dto.MaterialId.HasValue)
        {
            var ok = await _materialRep.IsAnyAsync(m =>
                m.Id == dto.MaterialId!.Value && m.CompanyRefId == dto.CompanyRefId && m.FactoryRefId == dto.FactoryRefId);
            if (!ok) return "物料主数据引用无效";
        }

        if (dto.Params == null || dto.Params.Count == 0)
            return null;

        var epIds = dto.Params.Select(p => p.ElementParamId).Distinct().ToList();
        var cnt = await _elementParamRep.AsQueryable()
            .Where(e => epIds.Contains(e.Id) && e.CompanyRefId == dto.CompanyRefId && e.FactoryRefId == dto.FactoryRefId)
            .CountAsync();
        return cnt == epIds.Count ? null : "存在无效的生产要素参数引用";
    }

    private static AdoS0MfgPreprocessElementParam MapParam(long preprocessElementId, long companyRefId, long factoryRefId, AdoS0MfgPreprocessElementParamLineUpsertDto p)
    {
        return new AdoS0MfgPreprocessElementParam
        {
            CompanyRefId = companyRefId,
            FactoryRefId = factoryRefId,
            PreprocessElementId = preprocessElementId,
            ElementParamId = p.ElementParamId,
            ParamValue = p.ParamValue,
            SortNo = p.SortNo,
            Remark = p.Remark,
            IsEnabled = p.IsEnabled,
            CreatedAt = DateTime.Now
        };
    }
}