module Main
  ( main,
  )
where

import Control.Applicative ((<**>))
import Control.Monad.Trans (liftIO)
import Data.Aeson qualified as J
import Data.ByteString.Lazy.Char8 qualified as LB
import Data.String (IsString (fromString))
import Options.Applicative qualified as A
import Store qualified as Q
import System.Console.Repline qualified as R
import System.Directory (setCurrentDirectory)
import Text.Printf (printf)

data Args = Args
  { cmd :: Cmd
  }

args :: A.Parser Args
args =
  Args <$> cmd_

data Cmd
  = Repl

cmd_ :: A.Parser Cmd
cmd_ =
  A.hsubparser . mconcat $
    [ A.command "repl" . A.info replCmd $
        A.progDesc "Interactively execute statements"
    ]

replCmd :: A.Parser Cmd
replCmd =
  pure Repl

main :: IO ()
main = do
  A.execParser (A.info (args <**> A.helper) A.idm) >>= \case
    Args {cmd = Repl} -> do
      setCurrentDirectory "./data"

      {-
      mapM_
        ( \q -> do
            printf "> %s\n" (show q)
            query' q
        )
        [ "SELECT * FROM c",
          "SELECT * FROM j",
          "SELECT c.id, j.id, is_j FROM c LEFT JOIN j ON j.id == c.j_id",
          "SELECT c.id, j.id FROM c RIGHT JOIN j ON j.id == c.j_id",
          "SELECT c.id, j.id FROM c FULL JOIN j ON j.id == c.j_id",
          "SELECT c.id, j FROM c EMBED j ON j.id == c.j_id"
        ]
        -}

      -- TODO Catch `ParseError` exception
      --
      -- @topic repl

      -- TODO Add query auto-completion
      --
      -- @topic repl
      R.evalRepl
        (const . pure $ ">>> ")
        (liftIO . query' . fromString)
        ([])
        (Just ':')
        (Just "paste")
        (R.Word (\_ -> pure ["SELECT"]))
        (pure ())
        (pure R.Exit)

query' :: Q.Query -> IO ()
query' q = mapM_ (LB.putStrLn . J.encode) =<< Q.query q