{-# LANGUAGE
    OverloadedStrings
  #-}

module DataTypeTool.Config.Config where

import qualified Antelude.List                    as List
import qualified Antelude.List.NonEmpty           as NE
import qualified Antelude.Maybe                   as Maybe
import qualified Antelude.Tuple.Pair              as Pair

import           Control.Applicative

import qualified Data.Map.Strict                  as Map
import qualified Data.Text                        as Text
import qualified Data.Version                     as Version

import qualified DataTypeTool.Lang.DTT.Config     as DTTConfig
import qualified DataTypeTool.Lang.Elm.Config     as ElmConfig
import qualified DataTypeTool.Lang.Elm.Toml       as ElmToml
import qualified DataTypeTool.Lang.Gleam.Config   as GleamConfig
import qualified DataTypeTool.Lang.Gleam.Toml     as GleamToml
import qualified DataTypeTool.Lang.Haskell.Config as HaskellConfig
import qualified DataTypeTool.Lang.Haskell.Toml   as HaskellToml
import qualified DataTypeTool.Lang.Python.Config  as PythonConfig
import qualified DataTypeTool.Lang.Python.Toml    as PythonToml
import qualified DataTypeTool.Lang.Python.Writer  as PythonWrite
import qualified DataTypeTool.Parsing.Types       as PT

import           Toml                             ( (.=) )
import qualified Toml

data Config
    = Config
          { sources :: FilePath
          , spacing :: Spacing
          , targets :: NonEmpty LangConfiguration
          }

datatypetoolCodec :: Toml.TomlCodec Config
datatypetoolCodec =
    Config
        <$> Toml.table
            (Toml.string "sources")
            "datatypetool"
            .= sources
        <*> Toml.table
            ( Toml.dioptional
                ( Toml.dimap
                    fromSpacing
                    toSpacing
                    (Toml.string "spacing")
                )
                |> Toml.dimap
                    Just
                    (Maybe.withDefault Spaces4)
            )
            "datatypetool"
            .= spacing
        <*> ( Toml.tableMap
                Toml._KeyText
                indvLangCodec
                "targets"
                |> parseTableAsNEList
            )
            .= targets

data Spacing = Tabs | Spaces2 | Spaces3 | Spaces4
    deriving (Eq, Ord, Show)

toSpacing :: String -> Spacing
toSpacing "tabs"    = Tabs
toSpacing "spaces2" = Spaces2
toSpacing "spaces3" = Spaces3
toSpacing "spaces4" = Spaces4

fromSpacing :: Spacing -> String
fromSpacing Tabs    = "tabs"
fromSpacing Spaces2 = "spaces2"
fromSpacing Spaces3 = "spaces3"
fromSpacing Spaces4 = "spaces4"

data LangConfiguration
    = EmptyConfig
    | Python PythonConfig.LangConf
    | Haskell HaskellConfig.LangConf
    | Elm ElmConfig.LangConf
    | Gleam GleamConfig.LangConf

parseTableAsNEList
    :: Toml.TomlCodec (Map.Map Text LangConfiguration)
    -> Toml.TomlCodec (NE.NonEmpty LangConfiguration)
parseTableAsNEList =
    Toml.dimap
        ( NE.toList
            .> List.map
                (\a -> (langNameString a, a))
            .> Map.fromList
        )
        ( Map.toList
            .> List.map Pair.second
            .> NE.fromList
            .> Maybe.withDefault
                (EmptyConfig :| [])
        )

langNameString :: LangConfiguration -> Text
langNameString (Python _)  = "python"
langNameString (Haskell _) = "haskell"
langNameString (Elm _)     = "elm"
langNameString (Gleam _)   = "gleam"

matchPython :: LangConfiguration -> Maybe PythonConfig.LangConf
matchPython (Python cnf) = Just cnf
matchPython _            = Nothing

matchHaskell :: LangConfiguration -> Maybe HaskellConfig.LangConf
matchHaskell (Haskell cnf) = Just cnf
matchHaskell _             = Nothing

matchElm :: LangConfiguration -> Maybe ElmConfig.LangConf
matchElm (Elm cnf) = Just cnf
matchElm _         = Nothing

matchGleam :: LangConfiguration -> Maybe GleamConfig.LangConf
matchGleam (Gleam cnf) = Just cnf
matchGleam _           = Nothing

indvLangCodec :: Toml.Key -> Toml.TomlCodec LangConfiguration
indvLangCodec "python" =
    Toml.dimatch matchPython Python (Toml.table PythonToml.confCodec "python")
indvLangCodec "haskell" =
    Toml.dimatch matchHaskell Haskell (Toml.table HaskellToml.confCodec "haskell")
indvLangCodec "gleam" =
    Toml.dimatch matchGleam Gleam (Toml.table GleamToml.confCodec "gleam")
indvLangCodec "elm" =
    Toml.dimatch matchElm Elm (Toml.table ElmToml.confCodec "elm")

runLangWriter :: LangConfiguration -> (FilePath -> [(FilePath, [PT.DataTypes])] -> IO ())
runLangWriter (Python cnf)  = PythonConfig.langWriter cnf cnf
runLangWriter (Haskell cnf) = HaskellConfig.langWriter cnf cnf
runLangWriter (Elm cnf)     = ElmConfig.langWriter cnf cnf
runLangWriter (Gleam cnf)   = GleamConfig.langWriter cnf cnf