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

import           Dhall                   (auto, inputFile)
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),
                                          fromOverlay, packages)
import           Options.Applicative     (execParser)
import           Path                    (toFilePath)
import           Path.Dhall              ()


makeMakePackageSet :: PackageSetExportSettings -> IO ()
makeMakePackageSet (MkPackageSetExportSettings d f xs) = do
  writeHaskellPackages d (packages xs)
  writeMakePackageSet d f xs

makeOverlay :: OverlayExportSettings -> IO ()
makeOverlay (MkOverlayExportSettings d f xs) = do
  writeHaskellPackages d (fromOverlay 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