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

-- | Native RubyGems reads bind the actual origin and charged complete-response reader.
module Ecluse.Core.Registry.RubyGems.Metadata (rubyGemsChargeFactors, prepareGemRead, gemReadWith, finishGemFull) where

import Ecluse.Core.Package (PackageInfo, PackageName)
import Ecluse.Core.Registry (UrlFormationError (UnparseableUrl))
import Ecluse.Core.Registry.CachedDocument (CachedDoc, rubyGemsCached)
import Ecluse.Core.Registry.JsonStream (StreamResult (..))
import Ecluse.Core.Registry.Metadata (MetadataError)
import Ecluse.Core.Registry.Metadata.EntryFloor (noRetainedEntries)
import Ecluse.Core.Registry.Metadata.Fetch.Preparation (PrepareRead (..), bindToOrigin)
import Ecluse.Core.Registry.Metadata.Fetch.Types (EcosystemRead (..))
import Ecluse.Core.Registry.Metadata.Projection (finishSelectedVersion, streamError)
import Ecluse.Core.Registry.Origin (OriginClient (..), originBaseUrl)
import Ecluse.Core.Registry.RubyGems.Document (selectGemVersion)
import Ecluse.Core.Registry.RubyGems.Reader (GemRead (..), GemReadResult (..), readGemInfoCharged)
import Ecluse.Core.Registry.RubyGems.Request (gemInfoRequestUnder)
import Ecluse.Core.Security (Limits)
import Ecluse.Core.Server.Admission.Types (ChargeFactors (..))

-- | ARM64 charges combine public captures with labelled synthetic listings.
rubyGemsChargeFactors :: ChargeFactors
rubyGemsChargeFactors :: ChargeFactors
rubyGemsChargeFactors =
    -- Public captures: https://github.com/AlexaDeWit/Ecluse/actions/runs/40559003401/job/122382799126
    -- Synthetic: https://github.com/AlexaDeWit/Ecluse/actions/runs/40575218918/job/122439883465
    ChargeFactors{cfFullReadPermille :: Int
cfFullReadPermille = Int
18000, cfKeptPermille :: Int
cfKeptPermille = Int
17300, cfOutputPermille :: Int
cfOutputPermille = Int
4600}

-- | Bind charging callbacks without performing discovery or metadata IO at boot.
prepareGemRead :: PrepareRead
prepareGemRead :: PrepareRead
prepareGemRead = (OriginClient -> IO (Either MetadataError EcosystemRead))
-> PrepareRead
PrepareRead (\OriginClient
origin -> Either MetadataError EcosystemRead
-> IO (Either MetadataError EcosystemRead)
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (EcosystemRead -> Either MetadataError EcosystemRead
forall a b. b -> Either a b
Right ((Int -> IO ()) -> (Int -> IO ()) -> Text -> EcosystemRead
gemReadWith (OriginClient -> Int -> IO ()
ocChargeFullReadWorkspace OriginClient
origin) (OriginClient -> Int -> IO ()
ocChargeSelectedRead OriginClient
origin) (OriginClient -> Text
originBaseUrl OriginClient
origin))))

-- | Keep full and selected reads under the same captured source authority.
gemReadWith :: (Int -> IO ()) -> (Int -> IO ()) -> Text -> EcosystemRead
gemReadWith :: (Int -> IO ()) -> (Int -> IO ()) -> Text -> EcosystemRead
gemReadWith Int -> IO ()
fullPay Int -> IO ()
selectedPay Text
sourceBase =
    UrlFormationError -> Text -> EcosystemRead -> EcosystemRead
bindToOrigin
        (Text -> UrlFormationError
UnparseableUrl Text
"RubyGems reader belongs to another origin")
        Text
sourceBase
        EcosystemRead
            { erRequest :: BaseRequest
-> Maybe ClientCredential
-> PackageName
-> Either UrlFormationError Request
erRequest = BaseRequest
-> Maybe ClientCredential
-> PackageName
-> Either UrlFormationError Request
gemInfoRequestUnder
            , erUniqueFields :: [Text]
erUniqueFields = []
            , erWalkFull :: Limits -> PackageName -> Text -> DocumentWalk GemReadResult
erWalkFull = \Limits
limits PackageName
name Text
_ -> (Int -> IO ())
-> Limits
-> PackageName
-> Text
-> GemRead
-> DocumentWalk GemReadResult
readGemInfoCharged Int -> IO ()
fullPay Limits
limits PackageName
name Text
sourceBase GemRead
FullRead
            , erFinishFull :: Limits
-> PackageName
-> Text
-> StreamResult GemReadResult
-> Either MetadataError (PackageInfo, CachedDoc)
erFinishFull = Limits
-> PackageName
-> Text
-> StreamResult GemReadResult
-> Either MetadataError (PackageInfo, CachedDoc)
finishGemFull
            , erRetainedEntries :: GemReadResult -> RetainedEntries
erRetainedEntries = RetainedEntries -> GemReadResult -> RetainedEntries
forall a b. a -> b -> a
const RetainedEntries
noRetainedEntries
            , erWalkSelected :: Limits -> PackageName -> Version -> DocumentWalk GemReadResult
erWalkSelected = \Limits
limits PackageName
name Version
version -> (Int -> IO ())
-> Limits
-> PackageName
-> Text
-> GemRead
-> DocumentWalk GemReadResult
readGemInfoCharged Int -> IO ()
selectedPay Limits
limits PackageName
name Text
sourceBase (Version -> GemRead
SelectedRead Version
version)
            , erFinishSelected :: Limits
-> PackageName
-> Text
-> Version
-> StreamResult GemReadResult
-> Either MetadataError VersionRead
erFinishSelected = \Limits
limits PackageName
_ Text
_ -> (GemReadResult -> PackageInfo)
-> (Version -> GemReadResult -> Maybe CachedDoc)
-> Limits
-> Version
-> StreamResult GemReadResult
-> Either MetadataError VersionRead
forall a.
(a -> PackageInfo)
-> (Version -> a -> Maybe CachedDoc)
-> Limits
-> Version
-> StreamResult a
-> Either MetadataError VersionRead
finishSelectedVersion GemReadResult -> PackageInfo
gemReadInfo (\Version
version GemReadResult
result -> (GemDocument -> CachedDoc, CachedDoc -> Maybe GemDocument)
-> GemDocument -> CachedDoc
forall a b. (a, b) -> a
fst (GemDocument -> CachedDoc, CachedDoc -> Maybe GemDocument)
rubyGemsCached (GemDocument -> CachedDoc) -> Maybe GemDocument -> Maybe CachedDoc
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Version -> GemDocument -> Maybe GemDocument
selectGemVersion Version
version (GemReadResult -> GemDocument
gemReadDocument GemReadResult
result)) Limits
limits
            }

-- | Retain policy facts and native rows from one fully consumed named response.
finishGemFull :: Limits -> PackageName -> Text -> StreamResult GemReadResult -> Either MetadataError (PackageInfo, CachedDoc)
finishGemFull :: Limits
-> PackageName
-> Text
-> StreamResult GemReadResult
-> Either MetadataError (PackageInfo, CachedDoc)
finishGemFull Limits
limits PackageName
_ Text
_ StreamResult GemReadResult
streamed = do
    result <- (ParseError -> MetadataError)
-> Either ParseError GemReadResult
-> Either MetadataError GemReadResult
forall a b c. (a -> b) -> Either a c -> Either b c
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (Limits -> ParseError -> MetadataError
streamError Limits
limits) (StreamResult GemReadResult -> Either ParseError GemReadResult
forall a. StreamResult a -> Either ParseError a
streamValue StreamResult GemReadResult
streamed)
    pure (gemReadInfo result, fst rubyGemsCached (gemReadDocument result))