public interface ICharacterBuilder<out T> where T : ICharacter
    {
        IDictionary<string, object> Properties { get; }

        T Character { get; }
    }

    class CharacterBuilder<T> : ICharacterBuilder<T> where T : Character, new()
    {
        public CharacterBuilder(HashSet<NameBlueprint> names, HashSet<IOrigin> origins)
        {
            this.Properties["names"] = names;
            this.Properties["origins"] = origins;
        }

        public IDictionary<string, object> Properties { get; } = new Dictionary<string, object>();

        public T Character { get; } = new T();
    }

    public class NameBlueprint
    {
        public string Name { get; set; }

        public Gender[] Genders { get; set; }
    }

    public abstract class BaseCulture<T> where T : ICharacter
    {
        private struct Rule
        {
            public Func<ICharacterBuilder<T>, bool> IsMatch;

            public Action<ICharacterBuilder<T>> Execute;
        }

        private readonly List<Rule> rules = null;

        protected void MakeRule(Action<ICharacterBuilder<T>> rule) =>
            MakeRule(c => true, rule);

        protected void MakeRule(Func<ICharacterBuilder<T>, bool> predicate, Action<ICharacterBuilder<T>> rule) 
        {
            var r = new Rule()
            {
                IsMatch = predicate,
                Execute = rule
            };

            rules.Add(r);
        }

        protected abstract void MakeRules();

        public T MakeCharacter(ICharacterBuilder<T> builder)
        {
            if (rules == null)
                MakeRules();

            foreach (var rule in rules)
            {
                if (rule.IsMatch(builder))
                    rule.Execute(builder);
            }

            return builder.Character;
        }
    }

    class FighterCulture : DefaultCulture<IFighter>
    {
        protected override void MakeRules()
        {
            MakeRule(c => c.Character.Origin = c.GetOrigins().PickRandomUsing(random));
            base.MakeRules();
        }
    }

    public class DefaultCulture<T> : BaseCulture<T> where T : class, ICharacter
    {
        protected Random random;

        public DefaultCulture(Random random)
        {
            this.random = random;
        }

        public DefaultCulture() : this(new Random())
        {

        }

        protected override void MakeRules()
        {
            MakeRule(c => c.Character.Gender = AllGenders().PickRandomUsing(random));
            
            foreach (var gender in AllGenders())
            {
                MakeRule(c => c.Character.Gender != gender, x => x.GetNames().RemoveWhere(t => !t.Genders.Contains(gender)));
            }

            MakeRule(x => x.Character.Name == null, x => x.Character.Name = x.GetNames().PickRandomUsing(random).Name);
        }

        private IEnumerable<Gender> AllGenders() => Enum.GetValues(typeof(Gender)).Cast<Gender>();
    }