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

-- | Project native identity, integrity, yank, publication and dependency facts without inventing execution evidence.
module Ecluse.Core.Registry.Cargo.Projection (projectCargoRecord) where

import Data.Aeson (Value (..))
import Data.Aeson.KeyMap qualified as KeyMap
import Data.Vector qualified as V

import Ecluse.Core.Ecosystem (Ecosystem (Cargo))
import Ecluse.Core.Package (Artifact (..), CodeExecSignal (CodeExecUnknown), DependencySources (FetchesOutsideRegistry, RegistryDependencies), HashAlg (SHA256), InvalidEntry, InvalidEntryKind (InvalidVersionManifest), PackageDetails (..), PackageName, mkHash, mkInvalidEntry)
import Ecluse.Core.Package.Entry (EntryKey)
import Ecluse.Core.Registry (ParseError)
import Ecluse.Core.Registry.Cargo.Discovery (CargoDiscovery, bindCargoDownload, cargoArtifactCoordinate, coordinateFilename)
import Ecluse.Core.Registry.Cargo.Manifest (acceptedRegistries, namesOtherRegistry)
import Ecluse.Core.Registry.Cargo.Project (projectName)
import Ecluse.Core.Registry.Cargo.SourceState (CargoRecordFacts (..), cargoRecordFacts)
import Ecluse.Core.Registry.ServedDocument (stringField)
import Ecluse.Core.Registry.WireSupport (Projection (..), checkNameAgreement)
import Ecluse.Core.Server.Path (unFilename)
import Ecluse.Core.Version (mkVersion)

-- | Bind the artifact to the exact published spelling and source position before admission.
projectCargoRecord :: PackageName -> EntryKey -> CargoDiscovery -> Value -> Either InvalidEntry PackageDetails
projectCargoRecord :: PackageName
-> EntryKey
-> CargoDiscovery
-> Value
-> Either InvalidEntry PackageDetails
projectCargoRecord PackageName
requested EntryKey
key CargoDiscovery
discovery Value
value = (Text -> InvalidEntry)
-> Either Text PackageDetails -> Either InvalidEntry PackageDetails
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 Text -> InvalidEntry
invalid (Either Text PackageDetails -> Either InvalidEntry PackageDetails)
-> Either Text PackageDetails -> Either InvalidEntry PackageDetails
forall a b. (a -> b) -> a -> b
$ do
    facts <- Value -> Either Text CargoRecordFacts
cargoRecordFacts Value
value
    name <- first (const "invalid Cargo package name") (projectName (crfName facts))
    case checkNameAgreement requested name () of
        NameMismatch Text
_ -> Text -> Either Text ()
forall a b. a -> Either a b
Left Text
"Cargo index name differs from the requested package"
        Projected () -> () -> Either Text ()
forall a b. b -> Either a b
Right ()
    let version = Ecosystem -> Text -> Version
mkVersion Ecosystem
Cargo (CargoRecordFacts -> Text
crfVersion CargoRecordFacts
facts)
    checksum <- mkHash SHA256 (crfChecksum facts)
    coordinate <- cargoArtifactCoordinate (crfName facts) version checksum
    url <- bindCargoDownload discovery coordinate
    let !artifact = Artifact{artEntryKey :: EntryKey
artEntryKey = EntryKey
key, artFilename :: Text
artFilename = Filename -> Text
unFilename (CargoArtifactCoordinate -> Filename
coordinateFilename CargoArtifactCoordinate
coordinate), artUrl :: Text
artUrl = Text
url, artHashes :: [Hash]
artHashes = [Hash
checksum], artCoreMetadata :: Maybe CoreMetadata
artCoreMetadata = Maybe CoreMetadata
forall a. Maybe a
Nothing, artSize :: Maybe Int
artSize = Maybe Int
forall a. Maybe a
Nothing}
    pure
        PackageDetails
            { pkgName = name
            , pkgVersion = version
            , pkgPublishedAt = crfPublishedAt facts
            , pkgInstallCode = CodeExecUnknown
            , pkgDependencySources = dependencySources value
            , pkgAvailability = crfAvailability facts
            , pkgArtifacts = artifact :| []
            }
  where
    invalid :: Text -> InvalidEntry
invalid = InvalidEntryKind -> Text -> Value -> Text -> InvalidEntry
mkInvalidEntry InvalidEntryKind
InvalidVersionManifest (EntryKey -> Text
forall b a. (Show a, IsString b) => a -> b
show EntryKey
key) Value
Null

-- A row naming Écluse's own index by URL counts as external: the reader knows no address for Écluse.
dependencySources :: Value -> DependencySources
dependencySources :: Value -> DependencySources
dependencySources = \case
    Object Object
fields
        | Just (Array Array
dependencies) <- Key -> Object -> Maybe Value
forall v. Key -> KeyMap v -> Maybe v
KeyMap.lookup Key
"deps" Object
fields
        , Just (Object Object
dependency) <- (Value -> Bool) -> Array -> Maybe Value
forall a. (a -> Bool) -> Vector a -> Maybe a
V.find Value -> Bool
fromOtherRegistry Array
dependencies ->
            Text -> DependencySources
FetchesOutsideRegistry (Object -> Text
renderOutside Object
dependency)
    Value
_ -> DependencySources
RegistryDependencies
  where
    -- Most rows name no registry, so only a named one pays for parsing. An unparseable one fails closed.
    fromOtherRegistry :: Value -> Bool
fromOtherRegistry = \case
        Object Object
dependency -> case Key -> Object -> Maybe Value
forall v. Key -> KeyMap v -> Maybe v
KeyMap.lookup Key
"registry" Object
dependency of
            Maybe Value
Nothing -> Bool
False
            Just Value
Null -> Bool
False
            Just Value
_ -> Bool -> Either ParseError Bool -> Bool
forall b a. b -> Either a b -> b
fromRight Bool
True (Either ParseError (Set Text)
cratesIo Either ParseError (Set Text)
-> (Set Text -> Either ParseError Bool) -> Either ParseError Bool
forall a b.
Either ParseError a
-> (a -> Either ParseError b) -> Either ParseError b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Set Text -> Object -> Either ParseError Bool
`namesOtherRegistry` Object
dependency))
        Value
_ -> Bool
False

cratesIo :: Either ParseError (Set Text)
cratesIo :: Either ParseError (Set Text)
cratesIo = [Text] -> Either ParseError (Set Text)
acceptedRegistries []
{-# NOINLINE cratesIo #-}

-- Name the crate and its manifest table, never the registry, which can carry a credential.
renderOutside :: KeyMap.KeyMap Value -> Text
renderOutside :: Object -> Text
renderOutside Object
dependency = Text
"dependency '" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
crate Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"' in " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
table Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" names a registry other than crates.io"
  where
    crate :: Text
crate = Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe Text
"" (Key -> Object -> Maybe Text
stringField Key
"package" Object
dependency Maybe Text -> Maybe Text -> Maybe Text
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Key -> Object -> Maybe Text
stringField Key
"name" Object
dependency)
    table :: Text
table = if Key -> Object -> Maybe Value
forall v. Key -> KeyMap v -> Maybe v
KeyMap.lookup Key
"kind" Object
dependency Maybe Value -> Maybe Value -> Bool
forall a. Eq a => a -> a -> Bool
== Value -> Maybe Value
forall a. a -> Maybe a
Just (Text -> Value
String Text
"build") then Text
"build-dependencies" else Text
"dependencies"