{-# LANGUAGE DeriveAnyClass    #-}
{-# LANGUAGE DeriveGeneric     #-}
{-# LANGUAGE LambdaCase        #-}
{-# LANGUAGE NamedFieldPuns    #-}
{-# LANGUAGE OverloadedStrings #-}

module Main where

import           Data.Aeson                    (encode)
import           Data.Aeson.Encode.Pretty      (encodePretty)
import qualified Data.ByteString.Lazy          as LB
import qualified Data.ByteString.Lazy.Encoding as LB
import           Data.Maybe                    (fromMaybe)
import           Data.Text.Lazy                as T
import           System.IO                     (utf8)
import           WithCli

import           Util                          (printPretty)
import CheckDir (recursiveCheckDir)
import Types (Level(..))

-- | the options this cli tool can take
data Options = Options
  { repository   :: Maybe String
  -- ^ path to the repository containing maps to lint
  , entrypoint   :: Maybe String
  -- ^ entrypoint in that repository
  , allowScripts :: Bool
  -- ^ pass --allowScripts to allow javascript in map
  , json         :: Bool
  -- ^ emit json if --json was given
  , lintlevel        :: Maybe Level
  -- ^ maximum lint level to print
  , pretty       :: Bool
  -- ^ pretty-print the json to make it human-readable
  } deriving (Show, Generic, HasArguments)


main :: IO ()
main = withCli run

run :: Options -> IO ()
run options = do
  let repo = fromMaybe "." (repository options)
  let entry = fromMaybe "main.json" (entrypoint options)
  let level = fromMaybe Suggestion (lintlevel options)

  lints <- recursiveCheckDir repo entry

  if json options
    then printLB
    $ if pretty options then encodePretty lints else encode lints
    else printPretty (level, lints)

-- | haskell's many string types are FUN …
printLB :: LB.ByteString -> IO ()
printLB = putStrLn . T.unpack . LB.decode utf8