package generischer_binaerbaum;

public class InnerNode<E extends Comparable<E>> extends Node<E> {
	protected Node<E> left, right;
	
	public InnerNode(E elem, Node<E> l, Node<E> r) {
		super(elem);
		left = l;
		right = r;
	}

	@Override
	public boolean contains(E e) {
		if (super.contains(e)) // e = elem
			return true;
		else if (elem.compareTo(e) > 0) // e < elem
			return (left != null) ? left.contains(e) : false;
		else // e > elem
			return (right != null) ? right.contains(e) : false;
	}

	@Override
	public Node<E> append(E e) {
		if (elem.compareTo(e) > 0) // e < elem
            left = (left == null) ? new Leaf<>(e) : left.append(e);
        else // e >= elem (-> rechts einfügen)
            right = (right == null) ? new Leaf<>(e) : right.append(e);
        return this;
	}

	@Override
	public boolean equals(Object o) {
		if (o == null || !(o instanceof InnerNode))
			return false;
		
		InnerNode<E> casted = (InnerNode<E>) o;
		
		if (!elem.equals(casted.elem))
			return false;
		
		if (this.left != null)
			if (!left.equals(casted.left))
				return false; // left <> casted.left
		else if (casted.left != null)
			return false; // left == null != casted.left

		if (this.right != null)
			if (!right.equals(casted.right))
				return false; // right <> casted.right
		else if (casted.right != null)
			return false; // right == null != casted.right
		
		return true;
	}

	@Override
	public String toString() {
        String result = "";
        if (left != null)
            result += left; // automatisch left.toString()
        result += super.toString();
        if (right != null)
            result += right; // - " - (wegen Stringkonkat.)
        return result;
	}
}