using Prefab.Catalog.Domain.Entities;

namespace Prefab.Catalog.Data.SeedSupport;

/// <summary>
/// Convenience builder for constructing <see cref="OptionRuleSet"/> instances with common condition shapes.
/// </summary>
internal sealed class OptionRuleSetBuilder
{
    private readonly OptionRuleSet _ruleSet;

    private OptionRuleSetBuilder(OptionRuleSet ruleSet)
    {
        _ruleSet = ruleSet;
    }

    public static OptionRuleSetBuilder ForDefinition(
        Product product,
        OptionDefinition targetDefinition,
        RuleEffect effect,
        RuleMode mode) =>
        new(OptionRuleSet.Create(
            product,
            OptionRuleTargetKind.OptionDefinition,
            targetDefinition.Id,
            effect,
            mode));

    public static OptionRuleSetBuilder ForValue(
        Product product,
        OptionValue targetValue,
        RuleEffect effect,
        RuleMode mode) =>
        new(OptionRuleSet.Create(
            product,
            OptionRuleTargetKind.OptionValue,
            targetValue.Id,
            effect,
            mode));

    public OptionRuleSetBuilder WhenEquals(OptionDefinition leftOption, OptionValue value)
    {
        _ruleSet.AddCondition(leftOption, RuleOperator.Equal, rightOptionValueId: value.Id);
        return this;
    }

    public OptionRuleSetBuilder WhenNotEquals(OptionDefinition leftOption, OptionValue value)
    {
        _ruleSet.AddCondition(leftOption, RuleOperator.NotEqual, rightOptionValueId: value.Id);
        return this;
    }

    public OptionRuleSetBuilder WhenIn(OptionDefinition leftOption, params OptionValue[] values)
    {
        if (values == null || values.Length == 0)
        {
            throw new ArgumentException("At least one value is required for an IN comparison.", nameof(values));
        }

        var valueIds = string.Join(",", values.Select(v => v.Id));
        _ruleSet.AddCondition(leftOption, RuleOperator.InList, rightList: valueIds);
        return this;
    }

    public OptionRuleSetBuilder WhenNotIn(OptionDefinition leftOption, params OptionValue[] values)
    {
        if (values == null || values.Length == 0)
        {
            throw new ArgumentException("At least one value is required for a NOT IN comparison.", nameof(values));
        }

        var valueIds = string.Join(",", values.Select(v => v.Id));
        _ruleSet.AddCondition(leftOption, RuleOperator.NotInList, rightList: valueIds);
        return this;
    }

    public OptionRuleSetBuilder WhenGreaterThanOrEqual(OptionDefinition leftOption, decimal threshold)
    {
        _ruleSet.AddCondition(leftOption, RuleOperator.GreaterThanOrEqual, rightNumber: threshold);
        return this;
    }

    public OptionRuleSetBuilder WhenGreaterThan(OptionDefinition leftOption, decimal threshold)
    {
        _ruleSet.AddCondition(leftOption, RuleOperator.GreaterThan, rightNumber: threshold);
        return this;
    }

    public OptionRuleSetBuilder WhenLessThanOrEqual(OptionDefinition leftOption, decimal threshold)
    {
        _ruleSet.AddCondition(leftOption, RuleOperator.LessThanOrEqual, rightNumber: threshold);
        return this;
    }

    public OptionRuleSetBuilder WhenLessThan(OptionDefinition leftOption, decimal threshold)
    {
        _ruleSet.AddCondition(leftOption, RuleOperator.LessThan, rightNumber: threshold);
        return this;
    }

    public OptionRuleSetBuilder WhenBetween(OptionDefinition leftOption, decimal fromInclusive, decimal toInclusive)
    {
        _ruleSet.AddCondition(leftOption, RuleOperator.Between, rightMin: fromInclusive, rightMax: toInclusive);
        return this;
    }

    public OptionRuleSet Build() => _ruleSet;
}