{-# LANGUAGE RecordWildCards #-}
module Horizon.Gen.Nix (
    main
  , horizonGenNix
  , makeMakePackageSet
  , makeOverlay
  ) where

import qualified Data.Text               as T (unpack)
import           Dhall                   (auto, inputFile)
import           Distribution.Parsec     (eitherParsec)
import           Horizon.Gen.Nix.Options (HorizonOptions (MkHorizonOptions),
                                          fromInputFile, horizonGenNixOptsInfo,
                                          optInputFile)
import           Horizon.Gen.Nix.Writers (writeHaskellPackages,
                                          writeMakePackageSet, writeOverlay)
import           Horizon.Spec            (HorizonExport (MakeOverlay, MakePackageSet),
                                          OverlayExportSettings (MkOverlayExportSettings),
                                          PackageSetExportSettings (MkPackageSetExportSettings),
                                          compiler, fromCompiler, fromOverlay,
                                          packages)
import           Options.Applicative     (execParser)
import           Path                    (toFilePath)
import           Path.Dhall              ()


makeMakePackageSet :: PackageSetExportSettings -> IO ()
makeMakePackageSet (MkPackageSetExportSettings d f xs) = do
  case eitherParsec (T.unpack $ fromCompiler $ compiler xs) of
    Left e -> putStrLn e
    Right x -> do
      writeHaskellPackages d x (packages xs)
      writeMakePackageSet d f xs

makeOverlay :: OverlayExportSettings -> IO ()
makeOverlay (MkOverlayExportSettings d f xs) = let
  xs' = fromOverlay xs
  in
  case eitherParsec (T.unpack $ fromCompiler $ compiler xs') of
    Left e -> putStrLn e
    Right x -> do
      writeHaskellPackages d x (packages xs')
      writeOverlay d f xs

processHorizonExport :: HorizonExport -> IO ()
processHorizonExport (MakePackageSet settings) = makeMakePackageSet settings
processHorizonExport (MakeOverlay settings)    = makeOverlay settings

horizonGenNix :: HorizonOptions -> IO ()
horizonGenNix MkHorizonOptions{..} = do
  let fp = toFilePath . fromInputFile $ optInputFile
  x <- inputFile @HorizonExport auto fp
  processHorizonExport x

main :: IO ()
main = do
  x <- execParser horizonGenNixOptsInfo
  horizonGenNix x