module Misc where

import Prelude hiding (null, foldr, lookup, concatMap, concat, and, all, drop, take, reverse, filter)

import Control.Monad
import Data.ByteString (ByteString)
import Data.Char
import Data.Collections
import Data.Collections.Properties
import Data.List (intersperse,nub,nubBy)
import Data.Map.List
import Data.Maybe
import Data.Monoid
import Data.Set.List
import Data.Trie (Trie)
import Data.Typeable
import Data.Word
import Presentation
import System.Environment
import System.Exit
import System.Random
import Test.QuickCheck
import Test.QuickCheck.Batch hiding (runTests)
import Text.Regex.Posix
import qualified Data.Collections as C
import qualified Data.List as List
import qualified Data.Set.Enum as Enum
import qualified Data.Map as M
import qualified Data.Trie as Trie

type T = Trie [Char] Char Int
-- type T = StdMap [Char] Int

-- l = [("",-2),("acbba",5),("b",-2),("acbbc",2),("b",0),("dbddb",2)]
l = [("",-2),("ab",5),("b",-2),("ac",2),("b",0)]


l' = [-2,0]


c :: T
c = fromList []


-- insertMany l c == Foldable.foldr insert c l

fromListWith f l = do putStrLn "-------------"
                      print l
                      
                      print (reduce values)
                      Control.Monad.mapM_ (Misc.fromListWith f) $ M.elems subMap
    where (values,l') = List.partition (C.null . fst) l
          mkVal (k, val) = (C.head k, [(C.tail k, val)]) 
          subMap = M.fromListWith (flip (++)) $ fmap mkVal l'
          reduce [] = Nothing
          reduce l = Just (List.foldr1 f . fmap snd $ l)


main = 
    do print c
       print $ List.foldr1 (\x _ -> x) l'
       print $ foldr insert c l
       print $ insertMany l c
       print $ (fromList l :: T)
       print $ (fromFoldable l :: T)
       print $ (flip insertMany empty l :: T)
       Misc.fromListWith const l