-- * Testing purposes
    , withChild
    , isColor
    , withoutChildAndBlack

import qualified Control.Arrow as Arrow
import Control.Arrow ((&&&), (>>>))
import qualified Control.Category as Cat

upMost :: TreeZipper a -> TreeZipper a
upMost ([], node) = ([], node)
upMost z = upMost $ up z

fromZipper = go
    where
        go ([], node) = node
        go z          = go $ up z

fromZipper = snd . upMost

remove x node = maybe node remove' $ search x node

remove x node = maybe node removeSimple $ search x node

remove' :: forall a. (Ord a) => TreeZipper a -> RedBlackTree a

removeSimple :: forall a. (Ord a) => TreeZipper a -> RedBlackTree a
removeSimple = fromZipper . go
    where
        go :: TreeZipper a -> TreeZipper a
        go zip@([], Node c node@(Node {}) v r@(Node {})) = undefined
            -- let leftMost = min $ toZipper r
            --     leftMod = modify (const Leaf) leftMost
            --     rootSubTree = fromZipper leftMod
            --     switch = modify (const (Node lc node left rootSubTree)) zip
            --     in upMost leftMost
        go z = remove' z
        min :: TreeZipper a -> TreeZipper a
        min (path, node@(Node _ Leaf _ _)) = (path, node)
        min zipper = min $ left zipper
withChild :: RedBlackTree a -> Bool
withChild (Node _ (Node {}) _ _) = True
withChild (Node _ _ _ (Node {})) = True
withChild _ = False
isColor :: Color -> RedBlackTree a -> Bool
isColor color (Node c _ _ _) = c == color
isColor color Leaf = color == Black
withoutChildAndBlack :: RedBlackTree a -> Bool
withoutChildAndBlack = (isColor Black &&& (not . withChild)) >>> Arrow.arr (uncurry (&&))
remove' :: forall a. (Ord a) => TreeZipper a -> TreeZipper a

        go :: Case -> RedBlackTree a

        go :: Case -> TreeZipper a

                in fromZipper zipper'

                in zipper'

        , AlBhed.Tree

        , red-black-tree