prog-intro/java/expression/common/NodeRendererBuilder.java

package expression.common;

import base.ExtendedRandom;
import base.Functional;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Supplier;

/**
 * @author Georgiy Korneev (kgeorgiy@kgeorgiy.info)
 */
@SuppressWarnings("StaticMethodOnlyUsedInOneClass")
public class NodeRendererBuilder<C> {

    private final Renderer.Builder<
        C,
        NodeRenderer.Settings,
        Node<C>
    > nodeRenderer = Renderer.builder(Node::constant);
    private final Map<String, Priority> priorities = new HashMap<>();
    private final Map<String, String> brackets = new HashMap<>();
    private final ExtendedRandom random;

    public NodeRendererBuilder(final ExtendedRandom random) {
        this.random = random;
        nodeRenderer.unary(NodeRenderer.PAREN, (mode, arg) ->
            NodeRenderer.paren(true, arg)
        );
    }

    public void unary(final String name, final int priority) {
        final String space =
            name.equals("-") || Character.isLetter(name.charAt(0)) ? " " : "";
        nodeRenderer.unary(name, (settings, arg) ->
            settings.extra(
                Node.op(name, priority, inner(settings, priority, arg, space)),
                random
            )
        );
    }

    public void unary(final String left, final String right) {
        brackets.put(left, right);
        nodeRenderer.unary(left, (settings, arg) ->
            settings.extra(Node.op(left, Integer.MAX_VALUE, arg), random)
        );
    }

    private Node<C> inner(
        final NodeRenderer.Settings settings,
        final int priority,
        final Node<C> arg,
        final String space
    ) {
        if (settings.mode() == NodeRenderer.Mode.FULL) {
            return NodeRenderer.paren(true, arg);
        } else {
            final String op = arg.get(
                c -> space,
                n -> space,
                (n, p, a) ->
                    priority > unaryPriority(arg)
                        ? NodeRenderer.PAREN
                        : NodeRenderer.PAREN.equals(n)
                            ? ""
                            : space,
                (n, a, b) -> NodeRenderer.PAREN
            );
            return op.isEmpty()
                ? arg
                : Node.op(op, Priority.MAX.priority | 1, arg);
        }
    }

    private static <C> Integer unaryPriority(final Node<C> node) {
        return node.get(
            c -> Integer.MAX_VALUE,
            n -> Integer.MAX_VALUE,
            (n, p, a) -> p,
            (n, a, b) -> Integer.MIN_VALUE
        );
    }

    public void binary(final String name, final int priority) {
        final Priority mp = new Priority(name, priority);
        priorities.put(name, mp);

        nodeRenderer.binary(name, (settings, l, r) ->
            settings.extra(process(settings, mp, l, r), random)
        );
    }

    private Node<C> process(
        final NodeRenderer.Settings settings,
        final Priority mp,
        final Node<C> l,
        final Node<C> r
    ) {
        if (settings.mode() == NodeRenderer.Mode.FULL) {
            return NodeRenderer.paren(true, op(mp, l, r));
        }

        final Priority lp = priority(l);
        final Priority rp = priority(r);

        final int rc = rp.compareLevels(mp);

        // :NOTE: Especially ugly code, do not replicate
        final boolean advanced =
            settings.mode() == NodeRenderer.Mode.SAME ||
            mp.has(2) ||
            (mp.has(1) &&
                (mp != rp ||
                    (settings.mode() == NodeRenderer.Mode.TRUE_MINI &&
                        hasOther(r, rp))));

        final Node<C> al = NodeRenderer.paren(lp.compareLevels(mp) < 0, l);
        if (rc == 0 && !advanced) {
            return get(r, null, (n, a, b) -> rp.op(mp.op(al, a), b));
        } else {
            return mp.op(
                al,
                NodeRenderer.paren((rc == 0 && advanced) || rc < 0, r)
            );
        }
    }

    private boolean hasOther(final Node<C> node, final Priority priority) {
        return get(
            node,
            () -> false,
            (name, l, r) -> {
                final Priority p = Functional.get(priorities, name);
                if (p.compareLevels(priority) != 0) {
                    return false;
                }
                return p != priority || hasOther(l, priority);
            }
        );
    }

    private Node<C> op(final Priority mp, final Node<C> l, final Node<C> r) {
        return mp.op(l, r);
    }

    private Priority priority(final Node<C> node) {
        return get(
            node,
            () -> Priority.MAX,
            (n, a, b) -> Functional.get(priorities, n)
        );
    }

    private <R> R get(
        final Node<C> node,
        final Supplier<R> common,
        final Node.Binary<Node<C>, R> binary
    ) {
        return node.get(
            c -> common.get(),
            n -> common.get(),
            (n, p, a) -> common.get(),
            binary
        );
    }

    public NodeRenderer<C> build() {
        return new NodeRenderer<>(nodeRenderer.build(), brackets, random);
    }

    // :NOTE: Especially ugly bit-fiddling, do not replicate
    private record Priority(String op, int priority) {
        private static final int Q = 3;
        private static final Priority MAX = new Priority(
            "MAX",
            Integer.MAX_VALUE - Q
        );

        private int compareLevels(final Priority that) {
            return (priority | Q) - (that.priority | Q);
        }

        @Override
        public String toString() {
            return String.format(
                "Priority(%s, %d, %d)",
                op,
                priority | Q,
                priority & Q
            );
        }

        public <C> Node<C> op(final Node<C> l, final Node<C> r) {
            return Node.op(op, l, r);
        }

        private boolean has(final int value) {
            return (priority & Q) == value;
        }
    }
}