arrayOrNull <- setClassUnion("array or NULL",c("array","NULL"))
listOrNull <- setClassUnion("list or NULL",c("list","NULL"))

BowtieData <- setClass("BowtieData",
                       representation(obs= "list", act = "list", Q = "list",
                                      suc = "list or NULL",est="list or NULL",
                                      successObserved="logical",
                                      cycletime="numeric"))

#Obs, act, Q, suc, est should be lists of data frames (or matrixes).

setGeneric("ncycle",function(data) standardGeneric("ncycle"))
setGeneric("nsubjects",function(data) standardGeneric("nsubjects"))
setGeneric("getCycletime",
           function(data,icycle) standardGeneric("getCycletime"))
setGeneric("lastEstimate",
           function(data) standardGeneric("lastEstimate"))
setGeneric("getObs",
           function(data,icycle) standardGeneric("getObs"))
setGeneric("getAct",
           function(data,icycle) standardGeneric("getAct"))
setGeneric("getQ",
           function(data,icycle) standardGeneric("getQ"))
setGeneric("getSuc",
           function(data,icycle) standardGeneric("getSuc"))
setGeneric("getEst",
           function(data,icycle) standardGeneric("getEst"))

setMethod("ncycle","BowtieData",
          function(data) {length(data@obs)-1})
setMethod("nsubjects","BowtieData",
          function(data) {nrow(data@obs[[1]])})

setMethod("getCycletime","BowtieData",
          function(data,icycle) {
            if (length(data@cycletime)==1) {
              cycletime
            } else {
              cycletime[icycle]
            }
          })

setMethod("lastEstimate","BowtieData",
          function(data) {length(data@est)})

setMethod("getObs","BowtieData",
           function(data,icycle) data@obs[[icycle]])
setMethod("getAct","BowtieData",
           function(data,icycle) {
             if (length(data@act)==1) data@act[[1]]
             else data@act[[icycle]]
           })
setMethod("getQ","BowtieData",
           function(data,icycle) {
             if (length(data@Q)==1) data@Q[[1]]
             else data@Q[[icycle]]
           })

setMethod("getSuc","BowtieData",
           function(data,icycle) {
             if (length(data@suc)>=icycle) data@suc[[icycle]]
             else NULL
           })

setMethod("getEst","BowtieData",
           function(data,icycle) {
             if (length(data@est)>=icycle) data@est[[icycle]]
             else NULL
           })



BowtieSimulationData <- setClass("BowtieSimulationData",
                                 representation(truth="list",
                                                params="list",
                                                paramsFollowTime = "logical"),
                                 contains="BowtieData")

setGeneric("getParamForCycle",
           function(data,icycle) standardGeneric("getParamForCycle"))

setMethod("getParamForCycle","BowtieSimulationData",
           function(data,icycle) {
             if (data@paramsFollowTime) {
               data@params[[icycle]]
             } else {
               data@param[[1]]
             }
           })

setGeneric("getTruth",
           function(data,icycle) standardGeneric("getTruth"))

setMethod("getTruth","BowtieData",
           function(data,icycle) data@truth[[icycle]])

##########
## Generic Functions for the Filter object

setGeneric("advanceParam", function(filter,param,time)
           standardGeneric("advanceParam"))

setGeneric("nparticles",function(filter) standardGeneric("nparticles"))
setGeneric("nparticles<-",function(filter,value) standardGeneric("nparticles<-"))

###############################################
## Bowtie Filter


BowtieFilter <-
setClass("BowtieFilter",
         representation (paramsFollowTime = "logical",
                         usesSuccess = "logical",
                         paramAdvances="logical",
                         nparticles="integer"),
         prototype=c(paramsFollowTime=FALSE,
                     usesSuccess=FALSE,
                     paramAdvances=FALSE,
                     nparticles=as.integer(1000)))


setMethod("advanceParam", "BowtieFilter",
           function(filter,param,time) {
             if (filter@paramAdvances) {
               stop("No parameter advancement method supplied.")
             } else {
               param
             }
           })


setMethod("nparticles","BowtieFilter",
          function(filter) as.numeric(filter@nparticles))

setMethod("nparticles<-","BowtieFilter",
          function(filter,value) {
            n <- as.integer(value)
            if (length(n) !=1 || n!=value) {
              stop("nparticles value must be a single integer")
o            }
            filter@nparticles <- n
            filter
          })


################################
## Binary Success

BinarySuccessBowtieFilter <-
setClass("BinarySuccessBowtieFilter",contains="BowtieFilter",
         prototype=c(paramsFollowTime=FALSE,
                     usesSuccess=TRUE,
                     paramAdvances=FALSE,
                     nparticles=1000))


setMethod("drawSuccess", "BinarySuccessBowtieFilter",
          function(pm,param,latent,action=NA,background=NA) {
            sucP <- successProb(filter,param,latent,action)
            array(runif(length(sucP)) < sucP,dim(sucP))
          })

## setMethod("evalSuccess", "BowtieFilter",
##            function(filter,param,latent,action,success) {
##             sucP <- successProb(filter,param,latent,action)
##             success <- array(success,dim(sucP))
##             sv <- ifelse(success,sucP,1-sucP)
##             apply(sv,c(1,2),prod)
##            })




################################
## Filter Output Object

BowtieFilterOutput <-
setClass("BowtieFilterOutput",
         representation(param="list",est="list",weight="list",
                        map="list",suc="list",data="BowtieData",
                        filter="BowtieFilter"))

setMethod("ncycle","BowtieFilterOutput",
          function(data) {length(data@param)-1})