module Hix.Prelude where

import Data.Generics.Labels ()
import Data.List.Extra (firstJust)
import qualified Distribution.ModuleName as ModuleName
import Distribution.ModuleName (ModuleName)
import Distribution.PackageDescription (ModuleRenaming (..), unPackageName)
import Distribution.Types.IncludeRenaming (IncludeRenaming (..))
import Distribution.Types.Mixin (Mixin (..))
import qualified Exon

data Prelude =
  Prelude {
    Prelude -> String
preludePackage :: String,
    Prelude -> String
preludeModule :: String,
    Prelude -> Bool
local :: Bool
  }
  deriving stock (Prelude -> Prelude -> Bool
(Prelude -> Prelude -> Bool)
-> (Prelude -> Prelude -> Bool) -> Eq Prelude
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Prelude -> Prelude -> Bool
== :: Prelude -> Prelude -> Bool
$c/= :: Prelude -> Prelude -> Bool
/= :: Prelude -> Prelude -> Bool
Eq, Int -> Prelude -> ShowS
[Prelude] -> ShowS
Prelude -> String
(Int -> Prelude -> ShowS)
-> (Prelude -> String) -> ([Prelude] -> ShowS) -> Show Prelude
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Prelude -> ShowS
showsPrec :: Int -> Prelude -> ShowS
$cshow :: Prelude -> String
show :: Prelude -> String
$cshowList :: [Prelude] -> ShowS
showList :: [Prelude] -> ShowS
Show)

preludeRenaming :: [(b, ModuleName)] -> Maybe b
preludeRenaming :: forall b. [(b, ModuleName)] -> Maybe b
preludeRenaming =
  ((b, ModuleName) -> Maybe b) -> [(b, ModuleName)] -> Maybe b
forall a b. (a -> Maybe b) -> [a] -> Maybe b
firstJust \case
    (b
real, ModuleName
"Prelude") -> b -> Maybe b
forall a. a -> Maybe a
Just b
real
    (b, ModuleName)
_ -> Maybe b
forall a. Maybe a
Nothing

pattern PreludeRenaming :: ModuleName -> ModuleRenaming
pattern $mPreludeRenaming :: forall {r}.
ModuleRenaming -> (ModuleName -> r) -> ((# #) -> r) -> r
PreludeRenaming p <- ModuleRenaming (preludeRenaming -> Just p)

pattern PreludeInclude :: ModuleName -> IncludeRenaming
pattern $mPreludeInclude :: forall {r}.
IncludeRenaming -> (ModuleName -> r) -> ((# #) -> r) -> r
PreludeInclude p <- IncludeRenaming {includeProvidesRn = PreludeRenaming p}

findPrelude :: [Mixin] -> Maybe Prelude
findPrelude :: [Mixin] -> Maybe Prelude
findPrelude =
  (Mixin -> Maybe Prelude) -> [Mixin] -> Maybe Prelude
forall a b. (a -> Maybe b) -> [a] -> Maybe b
firstJust \case
    Mixin {mixinIncludeRenaming :: Mixin -> IncludeRenaming
mixinIncludeRenaming = PreludeInclude ModuleName
real, LibraryName
PackageName
mixinPackageName :: PackageName
mixinLibraryName :: LibraryName
mixinPackageName :: Mixin -> PackageName
mixinLibraryName :: Mixin -> LibraryName
..} ->
      let
        preludePackage :: String
preludePackage = PackageName -> String
unPackageName PackageName
mixinPackageName
        preludeModule :: String
preludeModule = String -> [String] -> String
forall a (t :: * -> *).
(Exon a, Monoid a, Foldable t) =>
a -> t a -> a
Exon.intercalate String
"." (ModuleName -> [String]
ModuleName.components ModuleName
real)
      in Prelude -> Maybe Prelude
forall a. a -> Maybe a
Just Prelude {$sel:local:Prelude :: Bool
local = Bool
False, String
$sel:preludePackage:Prelude :: String
$sel:preludeModule:Prelude :: String
preludePackage :: String
preludeModule :: String
..}
    Mixin
_ -> Maybe Prelude
forall a. Maybe a
Nothing