module Main where

import qualified Data.Vector as V
import qualified Data.Csv as C
import qualified Data.ByteString.Lazy as B
import System.Environment (getArgs)

type BinFunction = Int -> Int
type GroupList = V.Vector Int
type CombFunction = V.Vector Int -> Int
type ExtrFunction = Int -> V.Vector Int
type VectorBinner = V.Vector Int -> Int

data BinningType = Mod
                 | ModAndDate
                 deriving (Read, Show)

modBin :: Int -> BinFunction
modBin m n = mod n m

dateBin :: Int -> Int -> BinFunction
dateBin maxDays groupSize d = div (d * groupSize) maxDays

modComb :: GroupList -> CombFunction
modComb groupList values = V.sum $ V.zipWith (*) products values
  where products = V.tail $ V.scanr (*) 1 groupList

modExtr :: GroupList -> ExtrFunction
modExtr groupList value = V.reverse $ V.fromList $ snd $ V.foldr f (value, []) groupList
  where f x (v, acc) = (mod v x, div v x : acc)

binVector :: CombFunction -> V.Vector BinFunction -> VectorBinner
binVector combFunction binFunctions v =
  combFunction $ V.zipWith ($) binFunctions v

argHandler :: [String] -> VectorBinner
argHandler args = case read (args !! 0) of
  ModAndDate -> binVector (modComb groupList) modDateBFs
  Mod -> binVector (modComb groupList) $ V.map modBin groupNums

  where groupNums :: V.Vector Int
        groupNums = V.fromList $ map read $ tail args

        groupList :: GroupList
        groupList = V.map abs groupNums

        modDateBFs :: V.Vector BinFunction
        modDateBFs = V.map chooseModDateBF groupNums

        chooseModDateBF :: Int -> BinFunction
        chooseModDateBF g | g < 0 = dateBin 2557 (-g)
                          | g > 0 = modBin g

main = do args <- getArgs

          (Right input) <- fmap (C.decode False) B.getContents

          vectorBinner <- fmap argHandler getArgs

          B.putStr $ C.encode $ V.map (C.Only . vectorBinner) input