using Microsoft.EntityFrameworkCore;
using MiGu.Server.Persistence;

namespace MiGu.Server.Wms;

public sealed class WmsTransportRuleService
{
    private readonly PlatformDbContext _db;

    public WmsTransportRuleService(PlatformDbContext db) => _db = db;

    public Task<List<WmsTransportRule>> ListAsync(string? triggerType = null, string? q = null)
    {
        var query = _db.WmsTransportRules.AsNoTracking().OrderByDescending(x => x.Priority).ThenBy(x => x.Code).AsQueryable();
        if (!string.IsNullOrWhiteSpace(triggerType))
            query = query.Where(x => x.TriggerType == triggerType);
        if (!string.IsNullOrWhiteSpace(q))
        {
            var s = q.Trim();
            query = query.Where(x => x.Code.Contains(s) || x.Name.Contains(s));
        }
        return query.ToListAsync();
    }

    public async Task<WmsTransportRule> SaveAsync(TransportRuleRequest req, string actor)
    {
        if (!WmsTransportTriggerTypes.All.Contains(req.TriggerType))
            throw new InvalidOperationException("触发类型无效");

        WmsTransportRule entity;
        if (req.Id.HasValue)
            entity = await FindEditable(req.Id.Value, req.Version);
        else
        {
            entity = new WmsTransportRule();
            StampCreate(entity, actor);
            _db.WmsTransportRules.Add(entity);
        }

        await EnsureUniqueCode(req.Code, entity.Id);
        entity.Code = req.Code.Trim();
        entity.Name = req.Name.Trim();
        entity.TriggerType = req.TriggerType.Trim();
        entity.Enabled = req.Enabled;
        entity.Priority = req.Priority;
        entity.SourceSelectorJson = TransportSelectorParser.NormalizeSelectorJson(req.SourceSelectorJson);
        entity.TargetSelectorJson = TransportSelectorParser.NormalizeSelectorJson(req.TargetSelectorJson);
        entity.TaskOptionsJson = TransportSelectorParser.NormalizeTaskOptionsJson(req.TaskOptionsJson);
        ApplyCommon(entity, req, actor);
        await _db.SaveChangesAsync();
        return entity;
    }

    public async Task DeleteAsync(Guid id, long? version, string actor)
    {
        var entity = await FindEditable(id, version);
        entity.IsDeleted = true;
        entity.DeletedAt = DateTimeOffset.UtcNow;
        entity.DeletedBy = actor;
        entity.UpdatedBy = actor;
        await _db.SaveChangesAsync();
    }

    private async Task<WmsTransportRule> FindEditable(Guid id, long? version)
    {
        var entity = await _db.WmsTransportRules.FirstOrDefaultAsync(x => x.Id == id)
            ?? throw new InvalidOperationException("规则不存在");
        if (version.HasValue && entity.Version != version.Value)
            throw new InvalidOperationException("数据已被其他用户修改，请刷新后重试");
        if (entity.IsLock) throw new InvalidOperationException("规则已锁定，不能修改");
        return entity;
    }

    private async Task EnsureUniqueCode(string code, Guid id)
    {
        if (await _db.WmsTransportRules.AnyAsync(x => x.Code == code.Trim() && x.Id != id))
            throw new InvalidOperationException("规则编码已存在");
    }

    private static void StampCreate(EntityBase entity, string actor)
    {
        entity.CreatedBy = actor;
        entity.UpdatedBy = actor;
    }

    private static void ApplyCommon(EntityBase entity, CommonRequest req, string actor)
    {
        entity.IsLock = req.IsLock;
        entity.Remark = req.Remark.TrimOr("");
        entity.Extend = NormalizeExtend(req.Extend);
        entity.UpdatedBy = actor;
    }

    private static string NormalizeExtend(string? extend)
    {
        if (string.IsNullOrWhiteSpace(extend)) return "{}";
        if (extend.Length > 4000) throw new InvalidOperationException("扩展字段过长");
        return extend;
    }
}

public sealed record TransportRuleRequest(
    Guid? Id,
    long? Version,
    string Code,
    string Name,
    string TriggerType,
    bool Enabled,
    int Priority,
    string SourceSelectorJson,
    string TargetSelectorJson,
    string TaskOptionsJson,
    bool IsLock,
    string Remark,
    string Extend) : CommonRequest(Id, Version, IsLock, Remark, Extend);