import "Vector"

@JavaType "org.rosuda.REngine.REXP"
data RExp = 
    @JavaType "org.rosuda.REngine.REXPDouble"
    @FieldNames [payload]
    RExpDouble (Vector Double)
  | @JavaType "org.rosuda.REngine.REXPInteger"
    @FieldNames [payload]
    RExpInteger (Vector Integer)
  | @JavaType "org.rosuda.REngine.REXPString"
    @FieldNames [payload]
    RExpString (Vector String)
  | @JavaType "org.rosuda.REngine.REXPGenericVector"
    @FieldNames [payload]
    RExpGenericVector (Vector RExp)
  | @JavaType "org.rosuda.REngine.REXPNull"
    RExpNull

instance Show RExp where
    sb <+ RExpDouble v = do 
        for [0..length v-1] $ \i ->
            ignore $ (if i > 0 then sb << " " else sb) <+ v!i
        sb
    sb <+ RExpInteger v = do 
        for [0..length v-1] $ \i ->
            ignore $ (if i > 0 then sb << " " else sb) <+ v!i
        sb   
    sb <+ RExpGenericVector v = do 
        for [0..length v-1] $ \i ->
            ignore $ (if i > 0 then sb << " " else sb) <+ v!i
        sb               
    sb <+ RExpNull = sb << "NULL"
    sb <+ _ = sb << "unknown"
    
importJava "org.rosuda.REngine.REXP" where
    @JavaName dim
    dimR :: RExp -> Maybe (Vector Integer)
    
    @JavaName getAttribute
    attributeRExp :: RExp -> String -> Maybe RExp 

    @JavaName inherits
    inherits :: RExp -> String -> Boolean
    
    @private
    @JavaName asDouble
    convertRExpToDouble :: RExp -> Double
    
    @private
    @JavaName asDoubles
    convertRExpToVectorDouble :: RExp -> Vector Double

    @private
    @JavaName asInteger
    convertRExpToInteger :: RExp -> Integer
    
    @private
    @JavaName asIntegers
    convertRExpToVectorInteger :: RExp -> Vector Integer

    @private
    @JavaName asString
    convertRExpToString :: RExp -> String
    
    @private
    @JavaName asStrings
    convertRExpToVectorString :: RExp -> Vector String
    
    @private
    @JavaName createDoubleMatrix
    convertDoubleMatrixToRExp :: Vector (Vector Double) -> RExp 

    @private
    @JavaName asDoubleMatrix
    convertRExpToDoubleMatrix :: RExp -> Vector (Vector Double) 
        
    @private
    @JavaName asList
    convertRExpToList :: RExp -> [RExp]

attributeR :: RCompatible a => RExp -> String -> Maybe a
attributeR exp = map fromRExp . attributeRExp exp 
    
@private
importJava "org.rosuda.REngine.REXPDouble" where
    @JavaName "<init>"
    convertDoubleToRExp :: Double -> RExp
    
    @JavaName "<init>"
    convertVectorDoubleToRExp :: Vector Double -> RExp

@private
importJava "org.rosuda.REngine.REXPInteger" where
    @JavaName "<init>"
    convertIntegerToRExp :: Integer -> RExp
    
    @JavaName "<init>"
    convertVectorIntegerToRExp :: Vector Integer -> RExp

@private
importJava "org.rosuda.REngine.REXPString" where
    @JavaName "<init>"
    convertStringToRExp :: String -> RExp
    
    @JavaName "<init>"
    convertVectorStringToRExp :: Vector String -> RExp

@private
importJava "org.rosuda.REngine.REXPGenericVector" where
    @JavaName "<init>"
    convertRListToRExp :: RList -> RExp

@private
importJava "org.rosuda.REngine.RList" where
    data RList

    @JavaName "<init>"
    createRList :: [RExp] -> RList

class RCompatible a where
    fromRExp :: RExp -> a
    toRExp :: a -> RExp

instance RCompatible RExp where
    fromRExp = id
    toRExp = id

instance RCompatible Double where
    fromRExp = convertRExpToDouble
    toRExp = convertDoubleToRExp

instance RCompatible (Vector Double) where
    fromRExp = convertRExpToVectorDouble
    toRExp = convertVectorDoubleToRExp

instance RCompatible Integer where
    fromRExp = convertRExpToInteger
    toRExp = convertIntegerToRExp

instance RCompatible (Vector Integer) where
    fromRExp = convertRExpToVectorInteger
    toRExp = convertVectorIntegerToRExp

instance RCompatible String where
    fromRExp = convertRExpToString
    toRExp = convertStringToRExp

instance RCompatible (Vector String) where
    fromRExp = convertRExpToVectorString
    toRExp = convertVectorStringToRExp

instance RCompatible (Vector (Vector Double)) where
    fromRExp = convertRExpToDoubleMatrix
    toRExp = convertDoubleMatrixToRExp

instance (RCompatible a) => RCompatible [a] where
    fromRExp = map fromRExp . convertRExpToList
    toRExp = convertRListToRExp . createRList . map toRExp