{-# OPTIONS_GHC -fglasgow-exts -fparr #-}

module MO.Run (
    module MO.Run,
    module MO.Base
) where

-- FIXME: systematize a nice order for imports (steal Pugs')
import MO.Util
import MO.Base
import MO.Compile as C
import StringTable.AtomMap as M
import Data.Typeable hiding (cast)
import GHC.PArr
import qualified Data.Typeable as Typeable

-- Little overview.
--
-- Suppose someone is calling a method, like: $foo.moose(1,2,3). Usually, we
-- create a MethodInvocation containing "moose" as the name of the method and
-- some Arguments thing, contaning the "1,2,3".
--
-- The "$foo" object is _represented_ by an Invocant datatype, which has a
-- pointer to "$foo" itself and an ResponderInterface (usually provided by the
-- Class that $foo was instantiated), which knows how to answer for a method
-- call, this is called 'dispatch' in the ResponderInterface class.
--
-- One example of ResponderInterface is the MethodTable, it has a Map of
-- MethodCompileds (identified by MethodName). Its 'dispatch' takes an Invocant
-- and a MethodInvocation, add the Invocant to the MInv Arguments,
-- lookup the MInv method name in it's on table, if found, run the compiled method
-- with the augmented Arguments.
--
-- The function ivDispatch does almost same as 'dispatch', but it gets the RI
-- that the Invocant has inside it (given by the Class, for example). So you can
-- think of "$foo.moose(1,2,3)" as a call to
-- "ivDispatch (Invocant_of_$foo) (Arguments_containing_(1,2,3))"


-- FIXME: At first we thought of having these two abstractions, but now
-- seem unnecessary, but I may be forgetting something :P
-- class Invocation a
-- class Responder a


data MethodInvocation m
    = MkMethodInvocation
        { mi_name      :: !MethodName  
        , mi_arguments :: !(Arguments m)
        }


class Monad m => ResponderInterface m a | a -> m where
    fromMethodList :: [(MethodName, MethodCompiled m)] -> m a
    dispatch :: a -> Invocant m -> MethodInvocation m -> m (Invocant m)
    -- here for debugging purposes.
    -- toNameList :: a -> [MethodName]

{-
instance ResponderInterface m a => Show a where
    show = show . toNameList
-}


data Monad m => NoResponse m = NoResponse

instance Monad m => ResponderInterface m (NoResponse m) where
    dispatch _ _ _      = fail "Dispatch failed - NO CARRIER"
    fromMethodList _    = return NoResponse
    -- toNameList _        = []

emptyResponder :: (Typeable1 m, Monad m) => AnyResponder m
emptyResponder = MkResponder (return NoResponse)



-- | This is a static method table.
data MethodTable m
    = MkMethodTable
        { mt_methods :: !(M.AtomMap (MethodCompiled m))
        }

instance (Typeable1 m, Monad m) => ResponderInterface m (MethodTable m) where
    fromMethodList = return . MkMethodTable . M.fromList
    dispatch mt responder inv@(MkMethodInvocation n args) = case M.lookup n (mt_methods mt) of
        Just method_compiled -> do
            runMC method_compiled (withInvocant args responder)
        _ -> fail $ "Can't locate object method " ++ show n ++ " of invocant: " ++ show responder
            
    -- toNameList = M.keys . mt_methods


data AnyResponder m = forall c. ResponderInterface m c => MkResponder !(m c)

instance (Typeable1 m, Monad m) => Typeable (AnyResponder m) where
    typeOf _ = mkTyConApp (mkTyCon "AnyResponder") [typeOf1 (undefined :: m ())]



-- Invocant represent an object aggregated with an ResponderInterface

fromInvocant :: forall m b. (Typeable1 m, Monad m, Typeable b) => Arguments m -> m b
fromInvocant CaptSub{}                  = fail "No invocant"
fromInvocant CaptMeth{ c_invocant = MkInvocant x _ } = case Typeable.cast x of
    Just y -> return y
    _      -> fail $ "Could not coerce from " ++ (show $ typeOf x) ++ " to " ++ (show $ typeOf (undefined :: b))


instance (Typeable1 m, Monad m) => Typeable (Invocant m) where
    typeOf _ = mkTyConApp (mkTyCon "Invocant") [typeOf1 (undefined :: m ())]

ivDispatch :: (Typeable1 m, Monad m) => Invocant m -> MethodInvocation m -> m (Invocant m)
ivDispatch i@(MkInvocant _ (MkResponder ri)) mi = do
    table   <- ri
    dispatch table i mi

instance (Typeable1 m, Monad m) => Show (Invocant m) where
    show (MkInvocant x _) = show x
instance (Typeable1 m, Monad m) => Eq (Invocant m) where
    MkInvocant a _ == MkInvocant b _ = a ?==? b
instance (Typeable1 m, Monad m) => Ord (Invocant m) where
    MkInvocant a _ `compare` MkInvocant b _ = a ?<=>? b

-- Helpers to create simple/empty invocants.
__ :: (Typeable1 m, Monad m, Ord a, Show a, Typeable a) => a -> Invocant m
__ = (`MkInvocant` emptyResponder)

-- Helper to create a Arguments based on a list of Invocants
mkArgs :: (Typeable1 m, Monad m) => [Invocant m] -> Arguments m
mkArgs x = CaptSub{ c_feeds = [: MkFeed { f_positionals = toP x, f_nameds = M.empty } :] }