module Chiasma.Data.SelectParams where

import Prelude hiding (input, last)

import Chiasma.Class.CmdArgs (CmdArgs (cmdArgs), flag1, option, optionArgs)
import Chiasma.Data.Direction (Direction)
import Chiasma.Data.Target (Target)

data SelectInput =
  EnableInput
  |
  DisableInput
  deriving stock (SelectInput -> SelectInput -> Bool
(SelectInput -> SelectInput -> Bool)
-> (SelectInput -> SelectInput -> Bool) -> Eq SelectInput
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SelectInput -> SelectInput -> Bool
$c/= :: SelectInput -> SelectInput -> Bool
== :: SelectInput -> SelectInput -> Bool
$c== :: SelectInput -> SelectInput -> Bool
Eq, Int -> SelectInput -> ShowS
[SelectInput] -> ShowS
SelectInput -> String
(Int -> SelectInput -> ShowS)
-> (SelectInput -> String)
-> ([SelectInput] -> ShowS)
-> Show SelectInput
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SelectInput] -> ShowS
$cshowList :: [SelectInput] -> ShowS
show :: SelectInput -> String
$cshow :: SelectInput -> String
showsPrec :: Int -> SelectInput -> ShowS
$cshowsPrec :: Int -> SelectInput -> ShowS
Show)

instance CmdArgs SelectInput where
  cmdArgs :: SelectInput -> [Text]
cmdArgs = \case
    SelectInput
EnableInput -> [Item [Text]
"-e"]
    SelectInput
DisableInput -> [Item [Text]
"-d"]

data SelectMark =
  SelectMark
  |
  SelectUnmark
  deriving stock (SelectMark -> SelectMark -> Bool
(SelectMark -> SelectMark -> Bool)
-> (SelectMark -> SelectMark -> Bool) -> Eq SelectMark
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SelectMark -> SelectMark -> Bool
$c/= :: SelectMark -> SelectMark -> Bool
== :: SelectMark -> SelectMark -> Bool
$c== :: SelectMark -> SelectMark -> Bool
Eq, Int -> SelectMark -> ShowS
[SelectMark] -> ShowS
SelectMark -> String
(Int -> SelectMark -> ShowS)
-> (SelectMark -> String)
-> ([SelectMark] -> ShowS)
-> Show SelectMark
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SelectMark] -> ShowS
$cshowList :: [SelectMark] -> ShowS
show :: SelectMark -> String
$cshow :: SelectMark -> String
showsPrec :: Int -> SelectMark -> ShowS
$cshowsPrec :: Int -> SelectMark -> ShowS
Show)

instance CmdArgs SelectMark where
  cmdArgs :: SelectMark -> [Text]
cmdArgs = \case
    SelectMark
SelectMark -> [Item [Text]
"-m"]
    SelectMark
SelectUnmark -> [Item [Text]
"-M"]

data SelectParams =
  SelectParams {
    SelectParams -> Maybe Direction
neighbor :: Maybe Direction,
    SelectParams -> Bool
last :: Bool,
    SelectParams -> Maybe SelectInput
input :: Maybe SelectInput,
    SelectParams -> Maybe SelectMark
mark :: Maybe SelectMark,
    SelectParams -> Maybe Text
title :: Maybe Text,
    SelectParams -> Target
target :: Target
  }
  deriving stock (SelectParams -> SelectParams -> Bool
(SelectParams -> SelectParams -> Bool)
-> (SelectParams -> SelectParams -> Bool) -> Eq SelectParams
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SelectParams -> SelectParams -> Bool
$c/= :: SelectParams -> SelectParams -> Bool
== :: SelectParams -> SelectParams -> Bool
$c== :: SelectParams -> SelectParams -> Bool
Eq, Int -> SelectParams -> ShowS
[SelectParams] -> ShowS
SelectParams -> String
(Int -> SelectParams -> ShowS)
-> (SelectParams -> String)
-> ([SelectParams] -> ShowS)
-> Show SelectParams
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SelectParams] -> ShowS
$cshowList :: [SelectParams] -> ShowS
show :: SelectParams -> String
$cshow :: SelectParams -> String
showsPrec :: Int -> SelectParams -> ShowS
$cshowsPrec :: Int -> SelectParams -> ShowS
Show)

instance Default SelectParams where
  def :: SelectParams
def =
    SelectParams :: Maybe Direction
-> Bool
-> Maybe SelectInput
-> Maybe SelectMark
-> Maybe Text
-> Target
-> SelectParams
SelectParams {
      $sel:neighbor:SelectParams :: Maybe Direction
neighbor = Maybe Direction
forall a. Maybe a
Nothing,
      $sel:last:SelectParams :: Bool
last = Bool
False,
      $sel:input:SelectParams :: Maybe SelectInput
input = Maybe SelectInput
forall a. Maybe a
Nothing,
      $sel:mark:SelectParams :: Maybe SelectMark
mark = Maybe SelectMark
forall a. Maybe a
Nothing,
      $sel:title:SelectParams :: Maybe Text
title = Maybe Text
forall a. Maybe a
Nothing,
      $sel:target:SelectParams :: Target
target = Target
forall a. Default a => a
def
    }

instance CmdArgs SelectParams where
  cmdArgs :: SelectParams -> [Text]
cmdArgs SelectParams {Bool
Maybe Text
Maybe Direction
Maybe SelectMark
Maybe SelectInput
Target
target :: Target
title :: Maybe Text
mark :: Maybe SelectMark
input :: Maybe SelectInput
last :: Bool
neighbor :: Maybe Direction
$sel:target:SelectParams :: SelectParams -> Target
$sel:title:SelectParams :: SelectParams -> Maybe Text
$sel:mark:SelectParams :: SelectParams -> Maybe SelectMark
$sel:input:SelectParams :: SelectParams -> Maybe SelectInput
$sel:last:SelectParams :: SelectParams -> Bool
$sel:neighbor:SelectParams :: SelectParams -> Maybe Direction
..} =
    Maybe Direction -> [Text]
forall a. CmdArgs a => Maybe a -> [Text]
optionArgs Maybe Direction
neighbor
    [Text] -> [Text] -> [Text]
forall a. Semigroup a => a -> a -> a
<>
    Text -> Bool -> [Text]
flag1 Text
"-l" Bool
last
    [Text] -> [Text] -> [Text]
forall a. Semigroup a => a -> a -> a
<>
    Maybe SelectInput -> [Text]
forall a. CmdArgs a => Maybe a -> [Text]
optionArgs Maybe SelectInput
input
    [Text] -> [Text] -> [Text]
forall a. Semigroup a => a -> a -> a
<>
    Maybe SelectMark -> [Text]
forall a. CmdArgs a => Maybe a -> [Text]
optionArgs Maybe SelectMark
mark
    [Text] -> [Text] -> [Text]
forall a. Semigroup a => a -> a -> a
<>
    Text -> Maybe Text -> [Text]
option Text
"-T" Maybe Text
title
    [Text] -> [Text] -> [Text]
forall a. Semigroup a => a -> a -> a
<>
    Target -> [Text]
forall a. CmdArgs a => a -> [Text]
cmdArgs Target
target