{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE LambdaCase #-}

module PPL.Internal
  ( uniform,
    Prob (..),
    Meas,
    score,
    scoreLog,
    sample,
    samples,
    newTree,
    HashMap,
    Tree(..),
  )
where

import Control.Monad
import Control.Monad.IO.Class
import Control.Monad.Trans.Class
import Control.Monad.Trans.Writer
import Data.Bifunctor
import Data.Monoid
import qualified Language.Haskell.TH.Syntax as TH
import Numeric.Log
import System.Random hiding (split, uniform)
import qualified System.Random as R
import Data.IORef
import System.IO.Unsafe
import qualified Data.Vector.Mutable as VM
import qualified Data.Vector.Unboxed.Mutable as UM
import qualified Data.Vector.Hashtables as H

type HashMap k v = H.Dictionary (H.PrimState IO) VM.MVector k UM.MVector v

-- Reimplementation of the LazyPPL monads to avoid some dependencies

data Tree = Tree
  { draw :: !Double,
    split :: (Tree, Tree)
  }

{-# INLINE newTree #-}
newTree :: IORef (HashMap [Bool] Double, StdGen) -> Tree
newTree s = go []
  where
    go id = Tree (unsafePerformIO $ do
      (m, g) <- readIORef s
      H.lookup m id >>= \case
        Nothing -> do
          let (x, g') = R.random g
          H.insert m id x
          writeIORef s (m, g')
          pure x
        Just x -> pure x) (go (False : id), go (True : id))

newtype Prob a = Prob {runProb :: Tree -> a}

instance Monad Prob where
  Prob f >>= g = Prob $ \t ->
    let (t1, t2) = split t
        (Prob g') = g (f t1)
     in g' t2

instance Functor Prob where fmap = liftM

instance Applicative Prob where pure = Prob . const; (<*>) = ap

uniform = Prob $ \(Tree r _) -> r

newtype Meas a = Meas (WriterT (Product (Log Double)) Prob a)
  deriving (Functor, Applicative, Monad)

{-# INLINE score #-}
score :: Double -> Meas ()
score = scoreLog . Exp . log . max eps
  where
    eps = $(TH.lift (2 * until ((== 1) . (1 +)) (/ 2) (1 :: Double))) -- machine epsilon, force compile time eval

{-# INLINE scoreLog #-}
scoreLog :: Log Double -> Meas ()
scoreLog = Meas . tell . Product

{-# INLINE sample #-}
sample :: Prob a -> Meas a
sample = Meas . lift

{-# INLINE samples #-}
samples :: forall a. Meas a -> Tree -> [(a, Log Double)]
samples (Meas m) = map (second getProduct) . runProb f
  where
    f = runWriterT m >>= \x -> (x :) <$> f