{-# LANGUAGE DataKinds #-}
{-# LANGUAGE OverloadedStrings #-}

{-# LANGUAGE NoIncoherentInstances #-}
{-# LANGUAGE NoMonomorphismRestriction #-}
{-# LANGUAGE NoUndecidableInstances #-}

module Vivid.UGens.FFT (

   -- * Pre and Post

     fft
   , ifft

     -- In Vivid.UGens.Analysis:
   -- , beatTrack
   -- , beatTrack2
     -- In Vivid.UGens.Convolution:
   -- , convolution
   -- , convolution2
   -- , convolution2L
---   , fftTrigger
---   , packFFT
     -- In Vivid.UGens.Convolution:
   -- , partConv
---   , specCentroid
---   , specFlatness
---   , specPcile
     -- In Vivid.UGens.Convolution:
   -- , stereoConvolution2L
---   , unpack1FFT
---   , unpackFFT

   -- * FFT functions

---   , pv_add
   , pv_binScramble
   , pv_binShift
---   , pv_binWipe
   , pv_brickWall
---   , pv_chainUGen
   , pv_conformalMap
   , pv_conj
---   , pv_copy
---   , pv_copyPhase
   , pv_diffuser
---   , pv_div
---   , pv_hainsworthFoote
---   , pv_jensenAndersen
   , pv_localMax
   , pv_magAbove
   , pv_magBelow
   , pv_magClip
---   , pv_magDiv
   , pv_magFreeze
---   , pv_magMul
   , pv_magNoise
   , pv_magShift
   , pv_magSmear
   , pv_magSquared
---   , pv_max
---   , pv_min
---   , pv_mul
   , pv_phaseShift
   , pv_phaseShift270
   , pv_phaseShift90
   , pv_randComb
---   , pv_randWipe
   , pv_rectComb
---   , pv_rectComb2
   ) where

import Vivid.SC.SynthDef.Types (CalculationRate(..))
import Vivid.SynthDef
import Vivid.UGens.Args
import Vivid.SynthDef.FromUA

-- | You can use "wintype_" and "winsize_" if you're used to the SC args:
fft :: (Args '["buf"] '["in", "hop", "windowType", "active", "windowSize"] a) => a -> SDBody a Signal
fft = makeUGen
   "FFT" KR
   (Vs::Vs ["buf", "in", "hop", "windowType", "active", "windowSize"])
   (in_ (0::Float), hop_ (0.5::Float), wintype_ (0::Float), active_ (1::Float), winsize_ (0::Float))

-- | You can use "wintype_" and "winsize_" if you're used to the SC args:
ifft :: (Args '["buf"] '["windowType", "windowSize"] a) => a -> SDBody a Signal
ifft =
   makeUGen "IFFT" AR
   (Vs::Vs '["buf", "windowType", "windowSize"])
   (wintype_ (0::Float), winsize_ (0::Float))

--- fftTrigger ::
--- fftTrigger =

--- packFFT :: Args ["buf","bufsize","magsphases","tobin"] '["frombin","zeroothers"] a => a -> SDBody a Signal
--- packFFT =
-- frombin: 0, zeroothers: 0

{-
"
Given an FFT chain, this measures the spectral centroid, which is the weighted mean frequency, or the "centre of mass" of the spectrum. (DC is ignored.)
This can be a useful indicator of the perceptual brightness of a signal.
"
-}

--- specCentroid ::
--- specCentroid =

--- specFlatness ::
--- specFlatness =

--- specPcile ::
--- specPcile =

--- unpack1FFT :: Args '["chain","bufsize","binindex"] '["whichmeasure"] a => SDBody a Signal
--- unpack1FFT =
-- whichmeasure: 0

--- unpackFFT :: Args '["chain","bufsize","tobin"] '["frombin"] a => SDBody a Signal
--- unpackFFT =
-- frombin: 0

--- pv_add :: (ToSig bufA as, ToSig bufB as) => bufA -> bufB -> SDBody' as Signal
--- pv_add bufA bufB =


pv_binScramble :: (Args '["buf"] '["wipe", "width", "trigger"] a) => a -> SDBody a Signal
pv_binScramble = makeUGen
   "PV_BinScramble" KR
   (Vs::Vs '["buf", "wipe", "width", "trigger"])
   (wipe_ (0::Float), width_ (0.2::Float), trigger_ (0::Float))

pv_binShift :: (Args '["buf"] '["stretch", "shift", "interp"] a) => a -> SDBody a Signal
pv_binShift = makeUGen
   "PV_BinShift" KR
   (Vs::Vs '["buf", "stretch", "shift", "interp"])
   (stretch_ (1::Float), shift_ (0::Float), interp_ (0::Float))

--- pv_binWipe ::
--- pv_binWipe =

pv_brickWall :: (Args '["buf"] '["wipe"] a) => a -> SDBody a Signal
pv_brickWall = makeUGen
   "PV_BrickWall" KR
   (Vs::Vs '["buf", "wipe"])
   (wipe_ (0::Float))

--- pv_chainUGen ::
--- pv_chainUGen =

pv_conformalMap :: (Args '["buf"] '["aReal", "aImag"] a) => a -> SDBody a Signal
pv_conformalMap = makeUGen
   "PV_ConformalMap" KR
   (Vs::Vs '["buf", "aReal","aImag"])
   (aReal_ (0::Float), aImag_ (0::Float))

pv_conj :: (Args '["buf"] '[] a) => a -> SDBody a Signal
pv_conj = makeUGen
   "PV_Conj" KR
   (Vs::Vs '["buf"])
   NoDefaults

--- pv_copy :: (ToSig bufA as, ToSig bufB as) => SDBody' as Signal
--- pv_copy bufA bufB =

--- pv_copyPhase :: (ToSig bufA as, ToSig bufB as) => SDBody' as Signal
--- pv_copyPhase bufA bufB =

pv_diffuser :: (Args '["buf"] '["trigger"] a) => a -> SDBody a Signal
pv_diffuser = makeUGen
   "PV_Diffuser" KR
   (Vs::Vs '["buf", "trigger"])
   (trig_ (0::Float))

--- pv_div :: (ToSig bufA as, ToSig bufB as) => bufA -> bufB -> SDBody' as Signal
--- pv_div bufA bufB =

--- pv_hainsworthFoote ::
--- pv_hainsworthFoote =
--- pv_jensenAndersen ::
--- pv_jensenAndersen =

pv_localMax :: (Args '["buf"] '["threshold"] a) => a -> SDBody a Signal
pv_localMax = makeUGen
   "PV_LocalMax" KR
   (Vs::Vs '["buf", "threshold"])
   (threshold_ (0::Float))

pv_magAbove :: (Args '["buf", "threshold"] '[] a) => a -> SDBody a Signal
pv_magAbove = makeUGen
   "PV_MagAbove" KR
   (Vs::Vs '["buf", "threshold"])
   NoDefaults

pv_magBelow :: (Args '["buf", "threshold"] '[] a) => a -> SDBody a Signal
pv_magBelow = makeUGen
   "PV_MagBelow" KR
   (Vs::Vs '["buf", "threshold"])
   NoDefaults

pv_magClip :: (Args '["buf", "threshold"] '[] a) => a -> SDBody a Signal
pv_magClip = makeUGen
   "PV_MagClip" KR
   (Vs::Vs '["buf", "threshold"])
   NoDefaults

--- pv_magDiv ::
--- pv_magDiv =

pv_magFreeze :: (Args '["buf"] '["freeze"] a) => a -> SDBody a Signal
pv_magFreeze = makeUGen
   "PV_MagFreeze" KR
   (Vs::Vs '["buf", "freeze"])
   (freeze_ (0::Float))

--- pv_magMul ::
--- pv_magMul =

pv_magNoise :: (Args '["buf"] '[] a) => a -> SDBody a Signal
pv_magNoise = makeUGen
   "PV_MagNoise" KR
   (Vs::Vs '["buf"])
   NoDefaults

pv_magShift :: (Args '["buf"] '["stretch", "shift"] a) => a -> SDBody a Signal
pv_magShift = makeUGen
   "PV_MagShift" KR
   (Vs::Vs '["buf", "stretch", "shift"])
   (stretch_ (1::Float), shift_ (0::Float))

-- | "As [the number of bins] rises, so will CPU usage."
pv_magSmear :: (Args '["buf"] '["bins"] a) => a -> SDBody a Signal
pv_magSmear = makeUGen
   "PV_MagSmear" KR
   (Vs::Vs '["buf", "bins"])
   (bins_ (0::Float))

pv_magSquared :: (Args '["buf"] '[] a) => a -> SDBody a Signal
pv_magSquared = makeUGen
   "PV_MagSquared" KR
   (Vs::Vs '["buf"])
   NoDefaults

--- pv_max :: (ToSig bufA as, ToSig bufB as) => bufA -> bufB -> SDBody' as Signal
--- pv_max bufA bufB = do
   --
--- pv_min :: (ToSig bufA as, ToSig bufB as) => bufA -> bufB -> SDBody' as Signal
--- pv_min bufA bufB =
--- pv_mul :: (ToSig bufA as, ToSig bufB as) => bufA -> bufB -> SDBody' as Signal
--- pv_mul bufA bufB =

pv_phaseShift :: (Args '["buf", "shift"] '["integrate"] a) => a -> SDBody a Signal
pv_phaseShift = makeUGen
   "PV_PhaseShift" KR
   (Vs::Vs '["buf", "shift", "integrate"])
   (integrate_ (0::Float))

pv_phaseShift270 :: (Args '["buf"] '[] a) => a -> SDBody a Signal
pv_phaseShift270 = makeUGen
   "PV_PhaseShift270" KR
   (Vs::Vs '["buf"])
   NoDefaults

pv_phaseShift90 :: (Args '["buf"] '[] a) => a -> SDBody a Signal
pv_phaseShift90 = makeUGen
   "PV_PhaseShift90" KR
   (Vs::Vs '["buf"])
   NoDefaults

pv_randComb :: (Args '["buf"] '["wipe", "trigger"] a) => a -> SDBody a Signal
pv_randComb = makeUGen
   "PV_RandComb" KR
   (Vs::Vs '["buf", "wipe", "trigger"])
   (wipe_ (0::Float), trigger_ (0::Float))

--- pv_randWipe ::
--- pv_randWipe =

-- Possibly "numTeeth" should be required:
-- | "Alternates blocks of bins between the two inputs."
pv_rectComb :: (Args '["buf"] '["numTeeth", "phase", "width"] a) => a -> SDBody a Signal
pv_rectComb = makeUGen
   "PV_RandComb" KR
   (Vs::Vs '["buf", "numTeeth", "phase", "width"])
   (numTeeth_ (0::Float), phase_ (0::Float), width_ (0.5::Float))

-- Possibly "numTeeth" should be required:
--- pv_rectComb2 ::
--- pv_rectComb2 =