module Test.Sound.Synthesizer.Plain.Filter (tests) where

import qualified Synthesizer.Plain.Filter.Recursive.MovingAverage as MA
import qualified Synthesizer.Plain.Filter.NonRecursive as FiltNR
import qualified Synthesizer.Plain.Signal as Sig
import qualified Synthesizer.Generic.Filter.NonRecursive as FiltNRG
import qualified Synthesizer.Generic.Signal as SigG
import qualified Synthesizer.Storable.Filter.NonRecursive as FiltNRSt
import qualified Synthesizer.Storable.Signal as SigSt
import qualified Synthesizer.Frame.Stereo as Stereo

import qualified Data.StorableVector.Lazy.Pattern as VP

import Foreign.Storable.Tuple ()

import Test.QuickCheck (test, {- Property, (==>) -})
import Test.Utility (equalList, {- approxEqualListAbs, approxEqualListRel, -} )

-- import qualified Algebra.Module                as Module
-- import qualified Algebra.RealField             as RealField
-- import qualified Algebra.Ring                  as Ring
-- import qualified Algebra.Additive              as Additive

import qualified Number.GaloisField2p32m5 as GF
import qualified Number.NonNegative       as NonNeg

import qualified Numeric.NonNegative.Chunky as Chunky

import Data.Tuple.HT (mapPair, )

-- import Debug.Trace (trace, )

import NumericPrelude
import PreludeBase
import Prelude ()


sums :: NonNeg.Int -> Rational -> Sig.T Rational -> Bool
sums nn x0 xs0 =
   let n = min (length xs) (1 + NonNeg.toNumber nn)
       xs = x0:xs0
       naive   =              FiltNR.sums        n xs
       pyramid =              FiltNR.sumsPyramid n xs
       rec     = drop (n-1) $ MA.sumsStaticInt   n xs
   in  -- this checks only for equal prefixes and can easily go wrong,
       -- if one list is empty
       and $ zipWith3 (\x y z -> x==y && y==z) naive rec pyramid
       -- equalList $ naive : pyramid : rec : []

sumRange :: NonNeg.Int -> (NonNeg.Int, NonNeg.Int) -> Sig.T Int -> Bool
sumRange nheight (nl,nr) xs =
   let wrap n = mod (NonNeg.toNumber n) (length xs + 1)
       height = 1 + NonNeg.toNumber nheight
       rng = (wrap nl, wrap nr)
   in  equalList $
       FiltNR.sumRange xs rng :
       FiltNR.sumRangeFromPyramid (take height (FiltNR.pyramid xs)) rng :
       FiltNR.sumRangeFromPyramidRec (take height (FiltNR.pyramid xs)) rng :
       FiltNRSt.sumRangeFromPyramid
          (FiltNRSt.pyramid height
             (SigSt.fromList SigSt.defaultChunkSize xs)) rng :
       []

sumsPosModulated ::
   NonNeg.Int -> Sig.T (NonNeg.Int,NonNeg.Int) -> (Int, Sig.T Int) -> Bool
sumsPosModulated nheight nctrl xsc =
   let ctrl = map (mapPair (NonNeg.toNumber, NonNeg.toNumber)) nctrl
       xs = cycle $ uncurry (:) xsc
       height = min 10 $ NonNeg.toNumber nheight
   in  -- trace (show (height, ctrl, xsc)) $
       equalList $
       FiltNR.sumsPosModulated ctrl xs :
       FiltNR.sumsPosModulatedPyramid height ctrl xs :
       FiltNRG.sumsPosModulatedPyramid height ctrl xs :
       SigSt.toList
          (FiltNRG.sumsPosModulatedPyramid
             height
             (SigSt.fromList SigSt.defaultChunkSize ctrl)
             (SigSt.fromList SigSt.defaultChunkSize xs)) :
       SigSt.toList
          (FiltNRSt.sumsPosModulatedPyramid
             height
             (SigSt.fromList SigSt.defaultChunkSize ctrl)
             (SigSt.fromList SigSt.defaultChunkSize xs)) :
       []

downSample2 ::
   [Int] -> (Int, Sig.T Int) -> Bool
downSample2 lazySize xsc =
   let len = Chunky.fromChunks $ map (VP.chunkSize . succ . abs) lazySize
       xs = VP.pack len $ cycle $ uncurry (:) xsc
   in  equalList $
       FiltNRG.downsample2 SigG.defaultLazySize xs :
       FiltNRSt.downsample2 xs :
       []

sumsDownSample2 ::
   [Int] -> (Int, Sig.T Int) -> Bool
sumsDownSample2 lazySize xsc =
   let len = Chunky.fromChunks $ map (VP.chunkSize . succ . abs) lazySize
       xs = VP.pack len $ cycle $ uncurry (:) xsc
   in  equalList $
       FiltNRG.sumsDownsample2 SigG.defaultLazySize xs :
       FiltNRSt.sumsDownsample2 xs :
       FiltNRSt.sumsDownsample2Alt xs :
       []

{-
sumsDownSample2 ::
   [VP.ChunkSize] -> (Int, Sig.T Int) -> Bool
sumsDownSample2 lazySize xsc =
   let len = Chunky.fromChunks $ filter (0/=) lazySize
       xs = VP.pack len $ cycle $ uncurry (:) xsc
   in  equalList $
       FiltNRG.sumsDownsample2 SigG.defaultLazySize xs :
       FiltNRSt.sumsDownsample2 xs :
       FiltNRSt.sumsDownsample2Alt xs :
       []
-}

movingAverageModulatedPyramid ::
   NonNeg.Int -> Sig.T NonNeg.Int ->
   (Stereo.T GF.T, Sig.T (Stereo.T GF.T)) -> Bool
movingAverageModulatedPyramid nheight nctrl xsc =
   let ctrl = map NonNeg.toNumber nctrl
       xs = uncurry (:) xsc
       pack ys = SigSt.fromList SigSt.defaultChunkSize ys
       maxC = maximum ctrl
       height = min 10 $ NonNeg.toNumber nheight
       onegf :: GF.T
       onegf = one
   in  -- trace (show (height, ctrl, xsc)) $
       equalList $
       pack (FiltNR.movingAverageModulatedPyramid onegf
          height maxC ctrl (cycle xs)) :
       FiltNRG.movingAverageModulatedPyramid onegf
          height maxC (pack ctrl) (SigG.cycle $ pack xs) :
       FiltNRSt.movingAverageModulatedPyramid onegf
          height maxC (pack ctrl) (SigG.cycle $ pack xs) :
       []


tests :: [(String, IO ())]
tests =
   ("sums", test sums) :
   ("sumRange", test sumRange) :
   ("sumsPosModulated", test sumsPosModulated) :
   ("downSample2", test downSample2) :
   ("sumsDownSample2", test sumsDownSample2) :
   ("movingAverageModulatedPyramid", test movingAverageModulatedPyramid) :
   []