import "Prelude" as Prelude
import "JavaBuiltin" as Java
import "MSet" as MSet
import "MList" as MList
import "Iterator" as Iterator

importJava "java.util.Map$Entry" where
    data Entry a b
    
    @JavaName getKey
    keyOf :: Entry a b -> a
    @JavaName getValue
    valueOf :: Entry a b -> b
    
importJava "java.util.Map" where
    data T a b
    
    containsKey :: T a b -> a -> <Proc> Boolean
    containsValue :: T a b -> b -> <Proc> Boolean
    size :: T a b -> <Proc> Integer
    isEmpty :: T a b -> <Proc> Boolean
    entrySet :: T a b -> <Proc> MSet.T (Entry a b)
    get :: T a b -> a -> <Proc> Maybe b
    @JavaName get
    unsafeGet :: T a b -> a -> <Proc> b
    
    // needs no <Proc>, because this is a view
    keySet :: T a b -> MSet.T a
    
    @private
    @JavaName values
    values_ :: T a b -> Iterator.Iterable b
    
    put :: T a b -> a -> b -> <Proc> (Maybe b)
    remove :: T a b -> a -> <Proc> (Maybe b)
    clear :: T a b -> <Proc> ()

@inline
getOrCreate :: T a b -> (a -> <e> b) ->  a -> <Proc,e> b
getOrCreate m f k = match get m k with
    Just v -> v
    Nothing -> do
        v = f k
        put m k v
        v  

@inline
iter :: (a -> b -> <e> ()) -> T a b -> <e,Proc> ()
iter f m = MSet.iter (\entry -> f (keyOf entry) (valueOf entry)) (entrySet m)

@inline
iterB :: (a -> b -> <e> Boolean) -> T a b -> <e,Proc> Boolean
iterB f m = MSet.iterB (\entry -> f (keyOf entry) (valueOf entry)) (entrySet m)

@inline
fold :: (a -> b -> c -> <e> a) -> a -> T b c -> <Proc,e> a
fold f init m = MSet.fold (\cur entry -> f cur (keyOf entry) (valueOf entry)) init (entrySet m)

importJava "gnu.trove.map.hash.THashMap" where
    @JavaName "<init>"
    create :: () -> <Proc> T a b
    @JavaName "<init>"
    createC :: Integer -> <Proc> T a b

    @JavaName "<init>"
    clone :: T a b -> <Proc> T a b

fromEntryList :: [(a,b)] -> <Proc> T a b
fromEntryList l = do
    result = createC (Prelude.length l)
    Prelude.iter (\(k,v) -> Prelude.ignore (put result k v)) l
    result
    
putM ::  (b -> b -> b) -> T a b -> a -> b -> <Proc> ()
putM merge m k v = match get m k with
    Just v2 -> Prelude.ignore (put m k (merge v v2))
    Nothing -> Prelude.ignore (put m k v)

@inline
map :: (b -> <e> c) -> T a b -> <Proc,e> T a c
map f m = do
    result = createC (size m)
    iter (\k v -> Prelude.ignore (put result k (f v))) m
    result

keys :: T a b -> <Proc> [a]
keys m = MSet.toList (keySet m)

values :: T a b -> <Proc> [b]
values m = do
    result = MList.createC (size m)
    Iterator.iter (MList.add result) (Iterator.iterator (values_ m))
    MList.freeze result

entries :: T a b -> <Proc> [(a,b)]
entries m = do
    result = MList.createC (size m)
    iter (Prelude.curry (MList.add result)) m
    MList.freeze result