-- SPDX-FileCopyrightText: 2026 Alexandra de Wit
--
-- SPDX-License-Identifier: MIT

-- | Ruby native formats share admission, mirroring and backend role contracts.
module Ecluse.Core.Registry.RubyGems.Adapter (rubyGemsAdapter) where

import Data.Map.Strict qualified as Map

import Ecluse.Core.Ecosystem (Ecosystem (RubyGems))
import Ecluse.Core.Registry (UrlFormationError (UnparseableUrl))
import Ecluse.Core.Registry.Adapter.Capability (AdapterArtifact (..), AdapterMaintenance (..), AdapterMetadata (..), PrivateArtifactAddressing (AdmittedIndexedArtifactLocation))
import Ecluse.Core.Registry.Adapter.Types (AdapterServe (..), RegistryAdapter (..))
import Ecluse.Core.Registry.FirstParty (FirstPartyDeclaration (FirstPartyDeclaration))
import Ecluse.Core.Registry.Maintenance.NameSpace (mkNameAlphabet)
import Ecluse.Core.Registry.Origin (OriginClient (ocBaseRequest, ocToken))
import Ecluse.Core.Registry.Request (artifactGet, artifactRequestByUrl, requestAt)
import Ecluse.Core.Registry.RubyGems.Credential (rubyReadCredential)
import Ecluse.Core.Registry.RubyGems.FirstParty (rubyGemsFirstPartyNames)
import Ecluse.Core.Registry.RubyGems.Metadata (prepareGemRead)
import Ecluse.Core.Registry.RubyGems.Project (projectName, rubyGemsNameChars)
import Ecluse.Core.Registry.RubyGems.Publish (rubyPublish)
import Ecluse.Core.Registry.RubyGems.Request (gemPath)
import Ecluse.Core.Registry.RubyGems.Route (rubyGemsRouteSpecs, rubyGemsRouter)
import Ecluse.Core.Registry.RubyGems.Serving (assembleRubyGemsDocument, serialiseRubyGemsDocument)
import Ecluse.Core.Rules.Types (RuleType (AllowScopeType, DenyExternalDependenciesType, DenyIfDeprecatedType, DenyIfYankedType, DenyInstallTimeExecutionType))
import Ecluse.Core.Server.Admission.Types (ChargeFactors)
import Ecluse.Core.Server.Path (mkFilename, unFilename)

-- | Activation requires observed resource factors supplied by composition.
rubyGemsAdapter :: ChargeFactors -> RegistryAdapter
rubyGemsAdapter :: ChargeFactors -> RegistryAdapter
rubyGemsAdapter ChargeFactors
factors =
    RegistryAdapter
        { adapterEcosystem :: Ecosystem
adapterEcosystem = Ecosystem
RubyGems
        , adapterRuleBlocks :: Map RuleType Text
adapterRuleBlocks =
            [(RuleType, Text)] -> Map RuleType Text
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
                [ (RuleType
DenyInstallTimeExecutionType, Text
"RubyGems native builds are normal installation behaviour. This rule is unsupported for the ecosystem.")
                , (RuleType
DenyIfYankedType, Text
"RubyGems reports no yank flag in a gem's metadata. Yanked versions disappear from it.")
                , (RuleType
DenyExternalDependenciesType, Text
"A RubyGems dependency names only a gem and its requirements, never a source, so this rule can never match one.")
                , (RuleType
DenyIfDeprecatedType, Text
"RubyGems metadata supplies no supported deprecation flag.")
                , (RuleType
AllowScopeType, Text
"RubyGems package names have no scope.")
                ]
        , adapterServe :: AdapterServe
adapterServe =
            AdapterServe
                { serveRouter :: MountRouter
serveRouter = MountRouter
rubyGemsRouter
                , serveRoutes :: NonEmpty RouteSpec
serveRoutes = NonEmpty RouteSpec
rubyGemsRouteSpecs
                , serveCredential :: CredentialMapping
serveCredential = CredentialMapping
rubyReadCredential
                }
        , adapterMetadata :: AdapterMetadata
adapterMetadata =
            AdapterMetadata
                { metadataRead :: PrepareRead
metadataRead = PrepareRead
prepareGemRead
                , metadataAssemble :: Text
-> Map SourceId (Snapshot CachedDoc)
-> MergePlan
-> Maybe CachedDoc
-> CachedDoc
metadataAssemble = Text
-> Map SourceId (Snapshot CachedDoc)
-> MergePlan
-> Maybe CachedDoc
-> CachedDoc
assembleRubyGemsDocument
                , metadataSerialise :: CachedDoc -> Either RenderRefused LByteString
metadataSerialise = CachedDoc -> Either RenderRefused LByteString
serialiseRubyGemsDocument
                , metadataChargeFactors :: ChargeFactors
metadataChargeFactors = ChargeFactors
factors
                }
        , adapterArtifact :: AdapterArtifact
adapterArtifact =
            AdapterArtifact
                { artifactByFile :: OriginClient
-> PackageName -> Text -> Either UrlFormationError Request
artifactByFile = \OriginClient
origin PackageName
_ Text
raw -> do
                    file <- UrlFormationError
-> Maybe Filename -> Either UrlFormationError Filename
forall l r. l -> Maybe r -> Either l r
maybeToRight (Text -> UrlFormationError
UnparseableUrl Text
"invalid RubyGems artifact filename") (Text -> Maybe Filename
mkFilename Text
raw)
                    artifactGet rubyReadCredential (ocToken origin) <$> requestAt (ocBaseRequest origin) (gemPath (unFilename file))
                , artifactByUrl :: Maybe ClientCredential -> Text -> Either UrlFormationError Request
artifactByUrl = CredentialMapping
-> Maybe ClientCredential
-> Text
-> Either UrlFormationError Request
artifactRequestByUrl CredentialMapping
rubyReadCredential
                , artifactHosts :: [Text]
artifactHosts = []
                , artifactPrivateAddressing :: PrivateArtifactAddressing
artifactPrivateAddressing = PrivateArtifactAddressing
AdmittedIndexedArtifactLocation
                }
        , adapterProjectName :: ProjectName
adapterProjectName = Either ParseError PackageName -> Maybe PackageName
forall l r. Either l r -> Maybe r
rightToMaybe (Either ParseError PackageName -> Maybe PackageName)
-> (Text -> Either ParseError PackageName) -> ProjectName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Either ParseError PackageName
projectName
        , adapterFirstParty :: FirstPartyDeclaration
adapterFirstParty = FirstPartyNames RubyGemsFirstParty -> FirstPartyDeclaration
forall entry.
(Eq entry, Show entry, Typeable entry) =>
FirstPartyNames entry -> FirstPartyDeclaration
FirstPartyDeclaration FirstPartyNames RubyGemsFirstParty
rubyGemsFirstPartyNames
        , adapterPublish :: Maybe AdapterPublish
adapterPublish = AdapterPublish -> Maybe AdapterPublish
forall a. a -> Maybe a
Just (ChargeFactors -> AdapterPublish
rubyPublish ChargeFactors
factors)
        , adapterMaintenance :: AdapterMaintenance
adapterMaintenance = Maybe StoreListing
-> Maybe VersionDelete -> NameAlphabet -> AdapterMaintenance
AdapterMaintenance Maybe StoreListing
forall a. Maybe a
Nothing Maybe VersionDelete
forall a. Maybe a
Nothing (String -> NameAlphabet
mkNameAlphabet String
rubyGemsNameChars)
        }