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

import           Dhall                                   (auto, inputFile)
import           Horizon.Gen.Nix.Options                 (HorizonCommand (MakePackageSetCommand, OverlayCommand),
                                                          HorizonOptions (MkHorizonOptions),
                                                          MakePackageSetOptions,
                                                          OverlayOptions,
                                                          fromInputFile,
                                                          horizonGenNixOptsInfo,
                                                          optHorizonCommand,
                                                          optInputFile,
                                                          optOverlayFile,
                                                          optPackageSetFile,
                                                          optPackagesDirectory)
import           Horizon.Gen.Nix.Types.PackagesDirectory (PackagesDirectory)
import           Horizon.Gen.Nix.Writers                 (writeHaskellPackages,
                                                          writeMakePackageSet,
                                                          writeOverlay)
import           Horizon.Spec                            (Overlay, PackageSet,
                                                          fromOverlay, packages)
import           Options.Applicative                     (execParser)
import           Path                                    (toFilePath)
import           Path.Dhall                              ()


makeMakePackageSet :: MakePackageSetOptions -> PackagesDirectory -> PackageSet -> IO ()
makeMakePackageSet opts d xs = do
  writeHaskellPackages d (packages xs)
  writeMakePackageSet d (optPackageSetFile opts) xs

makeOverlay :: OverlayOptions -> PackagesDirectory -> Overlay -> IO ()
makeOverlay opts d xs = do
  writeHaskellPackages d (fromOverlay xs)
  writeOverlay d (optOverlayFile opts) xs

horizonGenNix :: HorizonOptions -> IO ()
horizonGenNix MkHorizonOptions{..} =
  let fp = toFilePath . fromInputFile $ optInputFile
  in case optHorizonCommand of
    MakePackageSetCommand opts -> do
      x <- inputFile @PackageSet auto fp
      makeMakePackageSet opts optPackagesDirectory x
    OverlayCommand opts -> do
      x <- inputFile @Overlay auto fp
      makeOverlay opts optPackagesDirectory x

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