module Synthesizer.FusionList.Storable where

import qualified Synthesizer.FusionList.Signal as SigFL
import qualified Synthesizer.Storable.Signal as SigSt

import Synthesizer.Storable.Signal (ChunkSize, )

import Foreign.Storable (Storable, )

import Data.Tuple.HT (mapFst, )
import Data.Maybe (fromMaybe, )



{-# NOINLINE [0] crochetFusionListL #-}
crochetFusionListL :: (Storable y) =>
      ChunkSize
   -> (x -> acc -> Maybe (y, acc))
   -> acc
   -> SigFL.T x
   -> SigSt.T y
crochetFusionListL size f =
   curry (SigSt.unfoldr size (\(acc,xt) ->
      do (x,xs) <- SigFL.viewL xt
         (y,acc') <- f x acc
         return (y, (acc',xs))))


{-# NOINLINE [0] fromFusionList #-}
fromFusionList :: (Storable a) => ChunkSize -> SigFL.T a -> SigSt.T a
fromFusionList size = SigSt.fromList size . SigFL.toList
   -- fromFusionListCrochetL

{-
{-# INLINE fromFusionListCrochetL #-}
fromFusionListCrochetL :: (Storable a) => ChunkSize -> SigFL.T a -> T a
fromFusionListCrochetL size =
   crochetFusionListL size (\x _ -> Just (x, ())) ()

fromFusionListUnfoldr :: (Storable a) => ChunkSize -> SigFL.T a -> T a
fromFusionListUnfoldr size =
   SigSt.unfoldr size SigFL.viewL


{-# NOINLINE [0] toFusionList #-}
toFusionList :: (Storable a) => T a -> SigFL.T a
toFusionList = SigFL.Cons . List.concatMap SigSt.toList . decons


{- |
Converts from and to 'SigFL.T'
in order to speedup computation,
especially because it tells the optimizer about the 'Storable' constraint
and thus allows for more fusion,
where fusion would break otherwise.
-}
{-# INLINE chop #-}
chop :: (Storable a) => ChunkSize -> SigFL.T a -> SigFL.T a
chop size = toFusionList . fromFusionList size
-}


{-# INLINE appendFromFusionList #-}
appendFromFusionList :: Storable a =>
   ChunkSize -> SigFL.T a -> SigFL.T a -> SigSt.T a
appendFromFusionList size xs ys  =
   SigSt.append (SigFL.toStorableSignal size xs) (SigFL.toStorableSignal size ys)

{- |
Like 'appendFromFusionList' but returns a 'SigFL.T'
for more flexible following processing.
-}
{-# INLINE appendFusionList #-}
appendFusionList :: Storable a =>
   ChunkSize -> SigFL.T a -> SigFL.T a -> SigFL.T a
appendFusionList size xs ys  =
   SigFL.fromStorableSignal (appendFromFusionList size xs ys)



{-
crochetFusionListLGenerate size g b f a =
        SigSt.unfoldr size (\(a0,b0) ->
            do (y0,a1) <- f a0
               (z0,b1) <- g y0 b0
               Just (z0, (a1,b1))) (a,b) ;

-}


{-# RULES
  "Storable.crochetFusionListL/crochetL" forall size f g a b x.
     crochetFusionListL size g b (SigFL.crochetL f a x) =
        crochetFusionListL size (\x0 (a0,b0) ->
            do (y0,a1) <- f x0 a0
               (z0,b1) <- g y0 b0
               Just (z0, (a1,b1))) (a,b) x ;

  "Storable.crochetFusionListL/generate" forall size f g a b.
     crochetFusionListL size g b (SigFL.generate f a) =
        SigSt.unfoldr size (\(a0,b0) ->
            do (y0,a1) <- f a0
               (z0,b1) <- g y0 b0
               Just (z0, (a1,b1))) (a,b) ;

{-
  "Storable.fromFusionList/crochetL"
     forall size f a (x :: Storable a => SigFL.T a) .
     fromFusionList size (SigFL.crochetL f a x) =
        crochetL f a (fromFusionList size x) ;
-}

  "Storable.fromFusionList/generate" forall size f a.
     fromFusionList size (SigFL.generate f a) =
        SigSt.unfoldr size f a ;

  "Storable.fromFusionList/cons" forall size x xs.
     fromFusionList size (SigFL.cons x xs) =
        SigSt.cons x (fromFusionList size xs) ;

  "Storable.fromFusionList/empty" forall size.
     fromFusionList size (SigFL.empty) =
        SigSt.empty ;

  "Storable.fromFusionList/append" forall size xs ys.
     fromFusionList size (SigFL.append xs ys) =
        SigSt.append (fromFusionList size xs) (fromFusionList size ys) ;

  "Storable.fromFusionList/maybe" forall size f x y.
     fromFusionList size (maybe x f y) =
        maybe (fromFusionList size x)
           (fromFusionList size . f) y ;

  "Storable.fromFusionList/fromMaybe" forall size x y.
     fromFusionList size (fromMaybe x y) =
        maybe (fromFusionList size x) (fromFusionList size) y ;
  #-}


fromMapFusionList :: (Storable y) =>
   ChunkSize -> (x -> y) -> SigFL.T x -> SigSt.T y
fromMapFusionList size f =
   SigSt.unfoldr size (fmap (mapFst f) . SigFL.viewL)

{-# RULES
  "Storable.fromFusionList/map" forall size f xs.
     fromFusionList size (SigFL.map f xs) = fromMapFusionList size f xs ;

  "Storable.fromFusionList/replicate" forall size n x.
     fromFusionList size (SigFL.replicate n x) = SigSt.replicate size n x ;
  #-}