{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralisedNewtypeDeriving #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE ViewPatterns #-}
{-# OPTIONS_GHC -fno-warn-unused-top-binds #-}

module Main (main) where

import Composite
import Composite.Csv
import Composite.TH
import Data.ByteString.Lazy as LBS
import Data.Csv
import Data.Proxy
import Data.Text
import Data.Text.Encoding
import Data.Vector
import Test.Tasty
import Test.Tasty.HUnit

withLensesAndProxies
  [d|
    type A = "A" :-> Text

    type B = "B" :-> Double

    type C = "C" :-> Text

    type D = "D" :-> Int
    |]

type RecMaybe = Rec Maybe '[A, B, C, D]

deriving newtype instance FromField A

deriving newtype instance FromField B

deriving newtype instance FromField C

deriving newtype instance FromField D

deriving newtype instance ToField A

deriving newtype instance ToField B

deriving newtype instance ToField C

deriving newtype instance ToField D

deriving via (TF Maybe '[A, B, C, D]) instance FromNamedRecord RecMaybe

deriving via (TF Maybe '[A, B, C, D]) instance ToNamedRecord RecMaybe

rec1 :: RecMaybe
rec1 = Just "foo" :^: Just 5e-4 :^: Nothing :^: Just 5 :^: RNil

rec2 :: RecMaybe
rec2 = Just "bar" :^: Just 100e-10 :^: Just "quux" :^: Just 4 :^: RNil

testData :: [RecMaybe]
testData = [rec1, rec2]

tests :: TestTree
tests =
  testGroup
    "Parsing Tests"
    [ testCase "parses Record" $ do
        a <- LBS.readFile "./test/data/A.csv"
        let Right (x, toList -> xs) = decodeByName a
        assertEqual "" testData xs
        b <- LBS.readFile "./test/data/B.csv"
        let Right (y, toList -> ys) = decodeByName b
        assertEqual "" xs ys
        let a' = encodeByName x xs
        let Right (a'', toList -> xs') = decodeByName a'
        assertEqual "" xs xs'
        let b' = encodeByName (extractRecHeader (Proxy @RecMaybe)) ys
        let Right (b'', toList -> ys') = decodeByName b'
        assertEqual "" xs ys'
    ]

main :: IO ()
main = defaultMain tests