{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE NoMonomorphismRestriction #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE UndecidableInstances #-}
module Symantic.CLI.Test where

-- import Data.Monoid (Monoid(..))
-- import Data.Ord (Ord(..))
-- import Text.Show (Show(..))
import Control.Applicative (Applicative(..), Alternative(..))
import Control.Monad (Monad(..))
import Data.Bool
import Data.Ord (Ord(..))
import Data.Either (Either(..))
import Data.Function (($), (.))
import Data.Functor ((<$>))
import Data.List.NonEmpty (NonEmpty(..))
import Data.Maybe (Maybe(..))
import Data.Semigroup (Semigroup(..))
import Data.String (String)
import Data.Void (Void)
import Text.Show (Show(..))
import Type.Reflection (Typeable)
import System.IO (IO, print, stderr, putStrLn)
import System.Environment (getArgs)
import Data.Int (Int)
import qualified Data.Set as Set
import qualified Data.Text.Lazy.IO as TL
import qualified Symantic.Document.Term as Doc
import qualified Symantic.Document.Term.IO as DocIO
import qualified System.IO as IO

import Symantic.CLI

data Opts = Opts
 { opts_git_dir   :: String
 , opts_work_tree :: String
 , opts_int       :: Int
 } deriving (Show)

api =
	-- rule "main" $
	(rule "OPTIONS" $
		Opts <$> longOpt "git-dir" "GIT_DIR" (var "path")
		     <*> longOpt "work-tree" "X" (var "path")
		     <*> longOpt "int" 0 (var "name"))
	<?>
	rule "INFOS" (
		api_clone
		<!> api_push
		<!> api_fetch
		<!> api_help
		<!> api_version
	)

help_ d = help (d::DocIO.TermIO)

api_help =
	help_ "print some help" $
	tagged (Tag 'h' "help") nothing
	<.> response @DocIO.TermIO

api_version =
	help_ "print the version" $
	tagged (TagLong "version") nothing
	<.> response @String

api_clone =
	help_ "cloned" $
	command "clone" $
		(Clone <$> longOpt "branch" "master" (var "name"))
		<?> response @(Opts,Clone)

api_push =
	command "push" $
		(Push <$> longOpt "set-upstream" False (just True)
		      <*> longOpt "all" False (just True))
		<?> endOpts
		<.> many1 (var @String "refspec")
		<.> response @(Opts,Push,[String])

api_fetch =
	command "fetch" $
		response @Opts

data Clone = Clone String
 deriving (Show)
data Push = Push Bool Bool
 deriving (Show)

doc0 = DocIO.runTermIO IO.stderr $ plainDoc api
help0 = DocIO.runTermIO IO.stderr $ helpDoc api
route_git gitOpts =
	route_clone :!:
	route_push  :!:
	route_fetch :!:
	route_help  :!:
	route_version
	where
	route_help    = return $ helpDoc api
	route_version = return "1.0"
	route_clone (cloneOpts::Clone) =
		return (gitOpts,cloneOpts)
	route_push pushOpts refs =
		return (gitOpts,pushOpts,refs)
	route_fetch =
		return (gitOpts)

instance Typeable (a,b) => IOType (a,b)
instance Typeable (a,b,c) => IOType (a,b,c)
instance IOType Opts
instance (Show (a,b), Typeable (a,b)) => Outputable (a,b)
instance (Show (a,b,c), Typeable (a,b,c)) => Outputable (a,b,c)
instance Outputable Opts

parser0 = parser api route_git
main :: IO ()
main = do
	args <- getArgs
	putStrLn $ "args: " <> show args
	parser0 $ parseArgs args