import java.util.*;

enum State {
    error(0),
    warning(1),
    normal(2);

    private int severity;

    State(int severity) {
        this.severity = severity;
    }

    public int getSeverity() {
        return severity;
    }

    public static State initial() {
        return normal;
    }
}

class Marker {

    private State state;
    private Node container;

    Marker() {
        this.state = State.initial();
    }

    public State getState() {
        return state;
    }

    public void setState(State newState) {
        if (state == null) {
            throw new IllegalArgumentException("state == null");
        }
        State previousState = state;
        state = newState;
        if (container != null) {
            container.onMarkerRemovedOrStateChanged(this, previousState);
        }
    }

    public void setContainer(Node container) {
        if (container == null) {
            throw new IllegalArgumentException("container == null");
        }
        this.container = container;
    }
}

interface Node {
    State getCommonState();

    Collection<Node> getChildren();

    Node addChild(Node childNode);

    void setParent(Node node);

    Collection<Marker> getMarkers();

    Node addMarker(Marker marker);

    Node removeMarker(Marker marker);

    void onMarkerRemovedOrStateChanged(Marker marker, State previousState);
}

class SimpleNode implements Node {
    // todo override equals&hashCode
    private final Set<Node> children = new HashSet<>();
    // todo override equals&hashCode
    private final Set<Marker> markers = new HashSet<>();
    private final TreeMap<State, Integer> states = new TreeMap<>(new Comparator<State>() {
        @Override
        public int compare(State left, State right) {
            return Integer.compare(left.getSeverity(), right.getSeverity());
        }
    });

    private Node parent = null;
    private State commonState = State.initial();

    @Override
    public State getCommonState() {
        return commonState;
    }

    @Override
    public Collection<Node> getChildren() {
        return Collections.unmodifiableSet(children);
    }

    @Override
    public Node addChild(Node childNode) {
        children.add(childNode);
        childNode.setParent(this);
        return this;
    }

    @Override
    public void setParent(Node node) {
        this.parent = node;
    }

    @Override
    public Collection<Marker> getMarkers() {
        return markers;
    }

    @Override
    public Node addMarker(Marker marker) {
        markers.add(marker);
        marker.setContainer(this);
        incStates(marker.getState());
        return this;
    }

    @Override
    public Node removeMarker(Marker marker) {
        markers.remove(marker);
        onMarkerRemovedOrStateChanged(null, marker.getState());
        return this;
    }

    private void incStates(State state) {
        if (!states.containsKey(state)) {
            states.put(state, 1);
        } else {
            states.put(state, states.get(state) + 1);
        }
    }

    private void decStates(State state) {
        if (!states.containsKey(state)) {
            states.put(state, 0);
        } else {
            final Integer counter = states.get(state);
            if (counter > 0) {
                states.put(state, counter - 1);
            }
        }
    }

    @Override
    public void onMarkerRemovedOrStateChanged(/* Optional<> or @Nullable */ Marker marker, State previousState) {
        if (marker != null) {
            incStates(marker.getState());
        }
        decStates(previousState);
        this.commonState = State.initial();
        for (Map.Entry<State, Integer> stateCounter : states.entrySet()) {
            if (stateCounter.getValue() > 0) {
                this.commonState = stateCounter.getKey();
                break;
            }
        }
        if (parent != null) {
            parent.onMarkerRemovedOrStateChanged(marker, previousState);
        }
    }
}

interface Visitor {
    void visit(Node node, int depth);
}

class PrettyPrinter implements Visitor {
    private String padding(int depth) {
        StringBuilder sb = new StringBuilder();
        if (depth > 0) {
            for (int i = 0; i < depth; i++) {
                sb.append("\t");
            }
        }
        return sb.toString();
    }

    @Override
    public void visit(Node node, int depth) {
        System.out.println(padding(depth) + "commonState = " + node.getCommonState());
        for (Marker m : node.getMarkers()) {
            System.out.println(padding(depth + 1) + "markerState = " + m.getState());
        }
    }
}

public class Main {
    private static void traverseNode(Node root, Visitor visitor) {
        traverseNode(root, visitor, 0);
    }

    private static void traverseNode(Node root, Visitor visitor, int depth) {
        visitor.visit(root, depth);
        traverseChildren(root.getChildren(), visitor, depth + 1);
    }

    private static void traverseChildren(Collection<Node> children, Visitor visitor, int depth) {
        for (Node node : children) {
            traverseNode(node, visitor, depth);
        }
    }

    public static void main(String[] args) {
        Node root = new SimpleNode();
        Marker testMarker = new Marker();
        Node testNode = new SimpleNode()
                .addMarker(new Marker())
                .addMarker(testMarker)
                .addMarker(new Marker());
        root.addChild(
                new SimpleNode()
                        .addMarker(new Marker())
                        .addMarker(new Marker())
                        .addMarker(new Marker())
                        .addChild(testNode)
                        .addChild(
                                new SimpleNode()
                                        .addMarker(new Marker())
                                        .addMarker(new Marker())
                        )
        ).addChild(
                new SimpleNode()
                        .addMarker(new Marker())
                        .addMarker(new Marker())
        );

        traverseNode(root, new PrettyPrinter());
        System.out.println("--------------------------------------------------------------");
        testMarker.setState(State.error);
        traverseNode(root, new PrettyPrinter());
        System.out.println("--------------------------------------------------------------");
        testMarker.setState(State.warning);
        traverseNode(root, new PrettyPrinter());
        System.out.println("--------------------------------------------------------------");
        testNode.removeMarker(testMarker);
        traverseNode(root, new PrettyPrinter());
    }
}