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

-- | One selected storage provider owns all metadata retention capabilities.
module Ecluse.Core.Server.Cache.Provider (
    CacheProvider,
    cacheProvider,
    localCacheProviderWithPool,
    providerFull,
    providerDirectory,
    providerVersion,
    providerAssembled,
) where

import Data.ByteString qualified as BS

import Ecluse.Core.Registry.Metadata (VersionRead)
import Ecluse.Core.Registry.RubyGems.Directory (GemDirectory, directoryWeight)
import Ecluse.Core.Server.Cache.Backend (BackendStorage (LocalStorage), RetentionBackend, RetentionOperations, retentionBackend, supportsFullRetention)
import Ecluse.Core.Server.Cache.Backend.Local (LocalPool, newPooledRetention)
import Ecluse.Core.Server.Cache.Types
import Ecluse.Core.Server.Cache.VersionWeight (weighVersion)

-- | Missing capabilities remain uncached. They never fall back to another storage provider.
data CacheProvider = CacheProvider
    { CacheProvider
-> Maybe (RetentionBackend CacheKey (GemDirectory, Int))
cpDirectory :: Maybe (RetentionBackend CacheKey (GemDirectory, Int))
    , CacheProvider -> Maybe (RetentionBackend CacheKey CacheEntry)
cpFull :: Maybe (RetentionBackend CacheKey CacheEntry)
    -- ^ Full metadata is absent for local storage, regardless of the supplied operations.
    , CacheProvider -> Maybe (RetentionBackend CacheKey VersionRead)
cpVersion :: Maybe (RetentionBackend CacheKey VersionRead)
    -- ^ Selected reads may use an adapter-owned projection without loading a full value locally.
    , CacheProvider -> Maybe (RetentionBackend CacheKey ByteString)
cpAssembled :: Maybe (RetentionBackend CacheKey ByteString)
    }

-- | Public discovery shares the local pool without using a package identity.
providerDirectory :: CacheProvider -> Maybe (RetentionBackend CacheKey (GemDirectory, Int))
providerDirectory :: CacheProvider
-> Maybe (RetentionBackend CacheKey (GemDirectory, Int))
providerDirectory = CacheProvider
-> Maybe (RetentionBackend CacheKey (GemDirectory, Int))
cpDirectory

-- | Full retention from the selected provider, absent for local storage.
providerFull :: CacheProvider -> Maybe (RetentionBackend CacheKey CacheEntry)
providerFull :: CacheProvider -> Maybe (RetentionBackend CacheKey CacheEntry)
providerFull = CacheProvider -> Maybe (RetentionBackend CacheKey CacheEntry)
cpFull

-- | Selected retention from the same provider, without a full-document read.
providerVersion :: CacheProvider -> Maybe (RetentionBackend CacheKey VersionRead)
providerVersion :: CacheProvider -> Maybe (RetentionBackend CacheKey VersionRead)
providerVersion = CacheProvider -> Maybe (RetentionBackend CacheKey VersionRead)
cpVersion

-- | Assembled retention from the same provider, with no local fallback.
providerAssembled :: CacheProvider -> Maybe (RetentionBackend CacheKey ByteString)
providerAssembled :: CacheProvider -> Maybe (RetentionBackend CacheKey ByteString)
providerAssembled = CacheProvider -> Maybe (RetentionBackend CacheKey ByteString)
cpAssembled

-- | Classify every operation together. Local storage cannot opt into full retention.
cacheProvider ::
    BackendStorage ->
    Maybe (RetentionOperations CacheKey (GemDirectory, Int)) ->
    Maybe (RetentionOperations CacheKey CacheEntry) ->
    Maybe (RetentionOperations CacheKey VersionRead) ->
    Maybe (RetentionOperations CacheKey ByteString) ->
    CacheProvider
cacheProvider :: BackendStorage
-> Maybe (RetentionOperations CacheKey (GemDirectory, Int))
-> Maybe (RetentionOperations CacheKey CacheEntry)
-> Maybe (RetentionOperations CacheKey VersionRead)
-> Maybe (RetentionOperations CacheKey ByteString)
-> CacheProvider
cacheProvider BackendStorage
storage Maybe (RetentionOperations CacheKey (GemDirectory, Int))
directory Maybe (RetentionOperations CacheKey CacheEntry)
full Maybe (RetentionOperations CacheKey VersionRead)
version Maybe (RetentionOperations CacheKey ByteString)
assembled =
    CacheProvider
        { cpDirectory :: Maybe (RetentionBackend CacheKey (GemDirectory, Int))
cpDirectory = BackendStorage
-> RetentionOperations CacheKey (GemDirectory, Int)
-> RetentionBackend CacheKey (GemDirectory, Int)
forall k v.
BackendStorage -> RetentionOperations k v -> RetentionBackend k v
retentionBackend BackendStorage
storage (RetentionOperations CacheKey (GemDirectory, Int)
 -> RetentionBackend CacheKey (GemDirectory, Int))
-> Maybe (RetentionOperations CacheKey (GemDirectory, Int))
-> Maybe (RetentionBackend CacheKey (GemDirectory, Int))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (RetentionOperations CacheKey (GemDirectory, Int))
directory
        , cpFull :: Maybe (RetentionBackend CacheKey CacheEntry)
cpFull = (BackendStorage
-> RetentionOperations CacheKey CacheEntry
-> RetentionBackend CacheKey CacheEntry
forall k v.
BackendStorage -> RetentionOperations k v -> RetentionBackend k v
retentionBackend BackendStorage
storage (RetentionOperations CacheKey CacheEntry
 -> RetentionBackend CacheKey CacheEntry)
-> Maybe (RetentionOperations CacheKey CacheEntry)
-> Maybe (RetentionBackend CacheKey CacheEntry)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (RetentionOperations CacheKey CacheEntry)
full) Maybe (RetentionBackend CacheKey CacheEntry)
-> Maybe () -> Maybe (RetentionBackend CacheKey CacheEntry)
forall a b. Maybe a -> Maybe b -> Maybe a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (BackendStorage -> Bool
supportsFullRetention BackendStorage
storage)
        , cpVersion :: Maybe (RetentionBackend CacheKey VersionRead)
cpVersion = BackendStorage
-> RetentionOperations CacheKey VersionRead
-> RetentionBackend CacheKey VersionRead
forall k v.
BackendStorage -> RetentionOperations k v -> RetentionBackend k v
retentionBackend BackendStorage
storage (RetentionOperations CacheKey VersionRead
 -> RetentionBackend CacheKey VersionRead)
-> Maybe (RetentionOperations CacheKey VersionRead)
-> Maybe (RetentionBackend CacheKey VersionRead)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (RetentionOperations CacheKey VersionRead)
version
        , cpAssembled :: Maybe (RetentionBackend CacheKey ByteString)
cpAssembled = BackendStorage
-> RetentionOperations CacheKey ByteString
-> RetentionBackend CacheKey ByteString
forall k v.
BackendStorage -> RetentionOperations k v -> RetentionBackend k v
retentionBackend BackendStorage
storage (RetentionOperations CacheKey ByteString
 -> RetentionBackend CacheKey ByteString)
-> Maybe (RetentionOperations CacheKey ByteString)
-> Maybe (RetentionBackend CacheKey ByteString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (RetentionOperations CacheKey ByteString)
assembled
        }

-- | Share the existing retention bounds with another source-only metadata store.
localCacheProviderWithPool :: LocalPool -> CacheConfig -> IO CacheProvider
localCacheProviderWithPool :: LocalPool -> CacheConfig -> IO CacheProvider
localCacheProviderWithPool LocalPool
pool CacheConfig
config = do
    version <- LocalPool
-> NominalDiffTime
-> StoreBudget
-> (VersionRead -> Int)
-> IO (RetentionOperations CacheKey VersionRead)
forall k v.
Hashable k =>
LocalPool
-> NominalDiffTime
-> StoreBudget
-> (v -> Int)
-> IO (RetentionOperations k v)
newPooledRetention LocalPool
pool (CacheConfig -> NominalDiffTime
cacheTtl CacheConfig
config) (CacheConfig -> StoreBudget
cacheVersionBudget CacheConfig
config) VersionRead -> Int
weighVersion
    assembled <- newPooledRetention pool (cacheTtl config) (cacheAssembledBudget config) weighAssembled
    directory <- newPooledRetention pool (cacheTtl config) (StoreBudget 0 0) (\(GemDirectory
value, Int
keyBytes) -> GemDirectory -> Int
directoryWeight GemDirectory
value Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
keyBytes)
    pure (cacheProvider LocalStorage (Just directory) Nothing (Just version) (Just assembled))

weighAssembled :: ByteString -> Int
weighAssembled :: ByteString -> Int
weighAssembled ByteString
bytes = ByteString -> Int
BS.length ByteString
bytes Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
256