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

module Main where

import           Data.Aeson               (eitherDecode, encode)
import           Data.Aeson.Encode.Pretty (encodePretty)
import qualified Data.ByteString.Char8    as C8
import qualified Data.ByteString.Lazy     as LB
import           Data.Maybe               (fromMaybe)
import           WithCli

import           CheckDir                 (recursiveCheckDir)
import           Control.Monad.Identity   (Identity)
import           LintConfig               (LintConfig (..), patch)
import           System.Exit              (exitWith)
import           Types                    (Level (..))
import           Util                     (printPretty)
import           WriteRepo                (writeAdjustedRepository)

-- | 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
  , out          :: Maybe String
  , config       :: Maybe (LintConfig Maybe)
  , configFile   :: Maybe FilePath
  } 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)

  lintconfig <- case configFile options of
    Nothing -> error "Need a config file!"
    Just path -> LB.readFile path >>= \res ->
      case eitherDecode res :: Either String (LintConfig Identity) of
        Left err -> error $ "config file invalid: " <> err
        Right file -> case config options of
          Just p  -> pure (patch file p)
          Nothing -> pure file

  lints <- recursiveCheckDir lintconfig repo entry

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

  case out options of
    Just outpath -> writeAdjustedRepository repo outpath lints
                    >>= exitWith
    Nothing -> pure ()

-- | haskell's many string types are FUN …
printLB :: LB.ByteString -> IO ()
printLB a = putStrLn $ C8.unpack $ LB.toStrict a