// Copyright 2024 RustFS Team
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use super::metadata::{BUCKET_TARGETS_FILE, BucketMetadata, load_bucket_metadata};
use super::quota::BucketQuota;
use super::target::BucketTargets;
use crate::bucket::bucket_target_sys::BucketTargetSys;
use crate::bucket::metadata::{load_bucket_metadata_parse, load_bucket_metadata_parse_with_presence};
use crate::bucket::utils::is_meta_bucketname;
use crate::disk::RUSTFS_META_BUCKET;
use crate::error::{Error, Result, is_err_bucket_not_found};
use crate::runtime::sources as runtime_sources;
use crate::storage_api_contracts::heal::HealOperations as _;
use crate::storage_api_contracts::namespace::NamespaceLocking as _;
use crate::store::{ECStore, await_bucket_namespace_operation};
use futures::future::join_all;
use rustfs_common::heal_channel::HealOpts;
use rustfs_policy::policy::BucketPolicy;
use s3s::dto::ReplicationConfiguration;
use s3s::dto::{
    AccelerateConfiguration, BucketLifecycleConfiguration, BucketLoggingStatus, CORSConfiguration, NotificationConfiguration,
    ObjectLockConfiguration, PublicAccessBlockConfiguration, RequestPaymentConfiguration, ServerSideEncryptionConfiguration,
    Tagging, VersioningConfiguration, WebsiteConfiguration,
};
use std::collections::HashSet;
use std::time::Duration;
use std::{collections::HashMap, sync::Arc};
use time::OffsetDateTime;
use tokio::sync::{Mutex, RwLock};
use tokio::time::sleep;
use tokio_util::sync::CancellationToken;
use tracing::{error, warn};

const BUCKET_METADATA_REFRESH_INTERVAL: Duration = Duration::from_secs(15 * 60);

#[derive(Clone, Copy)]
enum MetadataLoadMode {
    Initial,
    Refresh,
}

pub async fn init_bucket_metadata_sys(api: Arc<ECStore>, buckets: Vec<String>) {
    // The metadata system is inherently per-store (it holds the store handle
    // and that store's bucket cache), so it lives on the store's own instance
    // context (backlog#1052 S3) — a second instance initializes its own cell
    // instead of panicking on the process-global one.
    let instance_ctx = api.ctx.clone();
    let is_dist_erasure = instance_ctx.is_dist_erasure().await;

    let mut sys = BucketMetadataSys::new(api);
    sys.init(buckets).await;

    let sys = Arc::new(RwLock::new(sys));

    instance_ctx.init_bucket_metadata_sys(sys.clone());

    if is_dist_erasure {
        start_refresh_buckets_metadata_loop(sys);
    }
}

/// The current instance's bucket metadata system (legacy free-function
/// facade: resolves the published store's context, or the bootstrap one).
pub fn get_global_bucket_metadata_sys() -> Option<Arc<RwLock<BucketMetadataSys>>> {
    crate::runtime::global::current_ctx().bucket_metadata_sys()
}

pub(super) fn get_bucket_metadata_sys() -> Result<Arc<RwLock<BucketMetadataSys>>> {
    if let Some(sys) = get_global_bucket_metadata_sys() {
        Ok(sys)
    } else {
        Err(Error::other("bucket metadata sys not initialized for this instance"))
    }
}

pub async fn set_bucket_metadata(bucket: String, bm: BucketMetadata) -> Result<()> {
    let sys = get_bucket_metadata_sys()?;
    let lock = sys.write().await;
    lock.set(bucket, Arc::new(bm)).await;
    Ok(())
}

/// Peer LoadBucketMetadata entry point; see
/// [`BucketMetadataSys::reload_from_store`] for the caching contract.
///
/// The outer write guard spans the disk load, mirroring [`update`]: every
/// other cache installer holds this lock (read or write), so the snapshot
/// read here can never land after — and roll back — a newer concurrent
/// install, and the install-plus-registry-sync sequence stays atomic
/// against concurrent removes and reloads.
pub async fn reload_bucket_metadata(bucket: &str) -> Result<()> {
    let sys = get_bucket_metadata_sys()?;
    let lock = sys.write().await;
    lock.reload_from_store(bucket).await
}

/// Drop a bucket's cached metadata from the in-memory map.
///
/// This is the counterpart to [`set_bucket_metadata`] and is invoked when a
/// bucket is deleted so peers stop serving stale cached configuration for it.
/// Returns `true` if an entry was present.
pub async fn remove_bucket_metadata(bucket: &str) -> Result<bool> {
    let sys = get_bucket_metadata_sys()?;
    let lock = sys.read().await;
    Ok(lock.remove(bucket).await)
}

fn start_refresh_buckets_metadata_loop(sys: Arc<RwLock<BucketMetadataSys>>) {
    let Some(cancel_token) = runtime_sources::background_services_cancel_token() else {
        warn!("bucket metadata refresh loop skipped because background cancellation token is not initialized");
        return;
    };

    tokio::spawn(async move {
        refresh_buckets_metadata_loop(sys, cancel_token).await;
    });
}

async fn refresh_buckets_metadata_loop(sys: Arc<RwLock<BucketMetadataSys>>, cancel_token: CancellationToken) {
    loop {
        if !wait_refresh_interval_or_cancel(&cancel_token, BUCKET_METADATA_REFRESH_INTERVAL).await {
            break;
        }
        refresh_buckets_metadata_once(sys.clone()).await;
    }
}

async fn wait_refresh_interval_or_cancel(cancel_token: &CancellationToken, interval: Duration) -> bool {
    tokio::select! {
        _ = cancel_token.cancelled() => false,
        _ = sleep(interval) => true,
    }
}

async fn refresh_buckets_metadata_once(sys: Arc<RwLock<BucketMetadataSys>>) {
    let buckets = {
        let sys = sys.read().await;
        sys.bucket_names().await
    };
    if buckets.is_empty() {
        return;
    }

    let count = runtime_sources::endpoint_erasure_set_count()
        .map(|count| count * 10)
        .unwrap_or(10)
        .max(1);
    let mut failed_buckets = HashSet::new();

    for chunk in buckets.chunks(count) {
        let sys = sys.read().await;
        sys.concurrent_load(chunk, &mut failed_buckets, MetadataLoadMode::Refresh)
            .await;
    }

    if !failed_buckets.is_empty() {
        warn!(
            failed_bucket_count = failed_buckets.len(),
            "bucket metadata refresh loop left buckets queued for retry"
        );
    }
}

async fn sync_bucket_target_sys(bucket: &str, bm: &BucketMetadata) {
    BucketTargetSys::get()
        .update_all_targets(bucket, bm.bucket_target_config.as_ref())
        .await;
}

/// Publish the bucket's durability override (or its absence) to the disk
/// layer registry consulted by `effective_durability`.
///
/// Called from every path that installs a bucket's metadata into the cache
/// (initial load, config update, peer reload notification, refresh loop,
/// lazy load), so the override propagates with exactly the bucket-metadata
/// cache invalidation semantics and never through a channel of its own.
fn sync_bucket_durability(bucket: &str, bm: &BucketMetadata) {
    let mode = bm
        .durability_config()
        .and_then(|cfg| cfg.normalized_mode())
        .and_then(|mode| crate::disk::local::DurabilityMode::parse(&mode));
    crate::disk::local::bucket_durability::set(bucket, mode);
}

/// Drop a bucket's durability override when its metadata leaves the cache.
fn clear_bucket_durability(bucket: &str) {
    crate::disk::local::bucket_durability::set(bucket, None);
}

pub async fn get(bucket: &str) -> Result<Arc<BucketMetadata>> {
    let sys = get_bucket_metadata_sys()?;
    let lock = sys.read().await;
    lock.get(bucket).await
}

// ---- Instance-scoped variants (backlog#1052 S7) ----
//
// A store's own bucket operations resolve the metadata system of *their*
// instance context so two servers in one process stay isolated; when the
// instance cell is not initialized yet (early startup) they fall back to the
// ambient default — the single-instance legacy behavior.

pub(crate) fn bucket_metadata_sys_of(ctx: &crate::runtime::instance::InstanceContext) -> Result<Arc<RwLock<BucketMetadataSys>>> {
    if let Some(sys) = ctx.bucket_metadata_sys() {
        return Ok(sys);
    }
    get_bucket_metadata_sys()
}

pub(crate) async fn get_in(ctx: &crate::runtime::instance::InstanceContext, bucket: &str) -> Result<Arc<BucketMetadata>> {
    let sys = bucket_metadata_sys_of(ctx)?;
    let lock = sys.read().await;
    lock.get(bucket).await
}

pub(crate) async fn created_at_in(ctx: &crate::runtime::instance::InstanceContext, bucket: &str) -> Result<OffsetDateTime> {
    let sys = bucket_metadata_sys_of(ctx)?;
    let lock = sys.read().await;
    lock.created_at(bucket).await
}

pub(crate) async fn set_bucket_metadata_in(ctx: &crate::runtime::instance::InstanceContext, bm: BucketMetadata) -> Result<()> {
    let sys = bucket_metadata_sys_of(ctx)?;
    let lock = sys.read().await;
    lock.persist_and_set(bm).await
}

pub(crate) async fn remove_bucket_metadata_in(ctx: &crate::runtime::instance::InstanceContext, bucket: &str) -> Result<bool> {
    let sys = bucket_metadata_sys_of(ctx)?;
    let lock = sys.read().await;
    Ok(lock.remove(bucket).await)
}

pub async fn update(bucket: &str, config_file: &str, data: Vec<u8>) -> Result<OffsetDateTime> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let _targets_guard = if config_file == BUCKET_TARGETS_FILE {
        Some(acquire_bucket_targets_transaction_lock(bucket).await?)
    } else {
        None
    };
    let mut bucket_meta_sys = bucket_meta_sys_lock.write().await;

    bucket_meta_sys.update(bucket, config_file, data).await
}

pub async fn update_bucket_targets_under_transaction_lock(bucket: &str, data: Vec<u8>) -> Result<OffsetDateTime> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let mut bucket_meta_sys = bucket_meta_sys_lock.write().await;
    bucket_meta_sys.update(bucket, BUCKET_TARGETS_FILE, data).await
}

/// Read-modify-write one bucket config file under the metadata system's
/// outer write guard.
///
/// `mutate` sees the freshly loaded on-disk metadata and returns the
/// replacement payload for `config_file` (empty clears it, like
/// [`delete`]). Both the read and the persisted write happen inside the
/// same guard that [`update`] uses, so within this process the rewrite can
/// neither clobber a concurrent update to another config file nor lose a
/// concurrent write to the same one — unlike caching a mutated clone of
/// previously read metadata.
///
/// This guard is process-local. Writers on other nodes still race, exactly
/// as they do for [`update`]: each rewrites the whole metadata file, so the
/// later save wins. What this narrows is the window — from "as stale as the
/// local cache" down to a single metadata read plus write.
pub async fn update_config_with<F>(bucket: &str, config_file: &str, mutate: F) -> Result<OffsetDateTime>
where
    F: FnOnce(&BucketMetadata) -> Result<Vec<u8>> + Send,
{
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let _targets_guard = if config_file == BUCKET_TARGETS_FILE {
        Some(acquire_bucket_targets_transaction_lock(bucket).await?)
    } else {
        None
    };
    let mut bucket_meta_sys = bucket_meta_sys_lock.write().await;
    bucket_meta_sys.update_config_with(bucket, config_file, mutate).await
}

pub async fn acquire_bucket_targets_transaction_lock(bucket: &str) -> Result<rustfs_lock::NamespaceLockGuard> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let api = bucket_meta_sys_lock.read().await.object_store();
    let lock = api
        .new_ns_lock(RUSTFS_META_BUCKET, &bucket_targets_transaction_lock_key(bucket))
        .await?;
    Ok(lock.get_write_lock(crate::set_disk::get_lock_acquire_timeout()).await?)
}

fn bucket_targets_transaction_lock_key(bucket: &str) -> String {
    format!("bucket-targets/{bucket}/transaction.lock")
}

pub async fn delete(bucket: &str, config_file: &str) -> Result<OffsetDateTime> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let mut bucket_meta_sys = bucket_meta_sys_lock.write().await;

    bucket_meta_sys.delete(bucket, config_file).await
}

pub async fn get_bucket_policy(bucket: &str) -> Result<(BucketPolicy, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_bucket_policy(bucket).await
}

/// Returns the raw JSON string of the bucket policy as originally stored.
/// This preserves the exact format of the policy document as it was PUT.
pub async fn get_bucket_policy_raw(bucket: &str) -> Result<(String, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_bucket_policy_raw(bucket).await
}

pub async fn get_bucket_acl_config(bucket: &str) -> Result<(String, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_bucket_acl_config(bucket).await
}

/// The bucket's durability override config (if any) with its update time.
///
/// `Ok((None, ..))` means the bucket has no override and follows the global
/// durability mode.
pub async fn get_durability_config(
    bucket: &str,
) -> Result<(Option<crate::bucket::durability::BucketDurabilityConfig>, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    let (bm, _) = bucket_meta_sys.get_config(bucket).await?;
    Ok((bm.durability_config(), bm.durability_config_updated_at))
}

pub async fn get_quota_config(bucket: &str) -> Result<(BucketQuota, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_quota_config(bucket).await
}

pub async fn get_bucket_targets_config(bucket: &str) -> Result<BucketTargets> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_bucket_targets_config(bucket).await
}

pub async fn get_cors_config(bucket: &str) -> Result<(CORSConfiguration, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_cors_config(bucket).await
}

pub async fn get_tagging_config(bucket: &str) -> Result<(Tagging, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_tagging_config(bucket).await
}

pub async fn get_public_access_block_config(bucket: &str) -> Result<(PublicAccessBlockConfiguration, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_public_access_block_config(bucket).await
}

pub async fn get_lifecycle_config(bucket: &str) -> Result<(BucketLifecycleConfiguration, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_lifecycle_config(bucket).await
}

pub async fn get_sse_config(bucket: &str) -> Result<(ServerSideEncryptionConfiguration, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_sse_config(bucket).await
}

pub async fn get_object_lock_config(bucket: &str) -> Result<(ObjectLockConfiguration, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_object_lock_config(bucket).await
}

pub async fn get_replication_config(bucket: &str) -> Result<(ReplicationConfiguration, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_replication_config(bucket).await
}

pub async fn get_notification_config(bucket: &str) -> Result<Option<NotificationConfiguration>> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_notification_config(bucket).await
}

pub async fn get_versioning_config(bucket: &str) -> Result<(VersioningConfiguration, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_versioning_config(bucket).await
}

pub async fn get_website_config(bucket: &str) -> Result<(WebsiteConfiguration, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_website_config(bucket).await
}

pub async fn get_logging_config(bucket: &str) -> Result<(BucketLoggingStatus, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_logging_config(bucket).await
}

pub async fn get_accelerate_config(bucket: &str) -> Result<(AccelerateConfiguration, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_accelerate_config(bucket).await
}

pub async fn get_request_payment_config(bucket: &str) -> Result<(RequestPaymentConfiguration, OffsetDateTime)> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_request_payment_config(bucket).await
}

pub async fn get_config_from_disk(bucket: &str) -> Result<BucketMetadata> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_config_from_disk(bucket).await
}

pub async fn created_at(bucket: &str) -> Result<OffsetDateTime> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.created_at(bucket).await
}

pub async fn list_bucket_targets(bucket: &str) -> Result<BucketTargets> {
    let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
    let bucket_meta_sys = bucket_meta_sys_lock.read().await;

    bucket_meta_sys.get_bucket_targets_config(bucket).await
}

/// Bound and lifetime of the negative cache for buckets with no persisted
/// metadata. Entries are invalidated the moment real metadata is cached, so
/// the TTL only bounds staleness for out-of-band creations whose reload
/// notification was lost; the capacity bounds memory under bogus-name floods.
const ABSENT_BUCKET_METADATA_TTL: Duration = Duration::from_secs(30);
const ABSENT_BUCKET_METADATA_MAX_ENTRIES: u64 = 10_000;

#[derive(Debug)]
pub struct BucketMetadataSys {
    metadata_map: RwLock<HashMap<String, Arc<BucketMetadata>>>,
    metadata_publish_lock: Mutex<()>,
    #[cfg(test)]
    lazy_load_lock_probe: std::sync::atomic::AtomicBool,
    /// Buckets recently observed to have no persisted metadata. Serving the
    /// fabricated default from here (instead of re-reading disk) keeps the
    /// per-request cost of repeated lookups for such names bounded — without
    /// this, every request naming a nonexistent bucket pays a namespace-lock
    /// acquisition plus a full erasure-set metadata fanout (reachable
    /// pre-auth via CORS preflight, and per-key in DeleteObjects).
    absent_metadata: moka::future::Cache<String, ()>,
    api: Arc<ECStore>,
    initialized: RwLock<bool>,
}

impl BucketMetadataSys {
    pub fn new(api: Arc<ECStore>) -> Self {
        Self {
            metadata_map: RwLock::new(HashMap::new()),
            metadata_publish_lock: Mutex::new(()),
            #[cfg(test)]
            lazy_load_lock_probe: std::sync::atomic::AtomicBool::new(false),
            absent_metadata: moka::future::Cache::builder()
                .max_capacity(ABSENT_BUCKET_METADATA_MAX_ENTRIES)
                .time_to_live(ABSENT_BUCKET_METADATA_TTL)
                .build(),
            api,
            initialized: RwLock::new(false),
        }
    }

    pub(crate) fn object_store(&self) -> Arc<ECStore> {
        self.api.clone()
    }

    pub async fn init(&mut self, buckets: Vec<String>) {
        let _ = self.init_internal(buckets).await;
    }
    async fn init_internal(&self, buckets: Vec<String>) -> Result<()> {
        let count = runtime_sources::endpoint_erasure_set_count()
            .map(|count| count * 10)
            .ok_or_else(|| Error::other("endpoint pools not initialized"))?;

        let mut failed_buckets: HashSet<String> = HashSet::new();
        let mut buckets = buckets.as_slice();

        loop {
            if buckets.len() < count {
                self.concurrent_load(buckets, &mut failed_buckets, MetadataLoadMode::Initial)
                    .await;
                break;
            }

            self.concurrent_load(&buckets[..count], &mut failed_buckets, MetadataLoadMode::Initial)
                .await;

            buckets = &buckets[count..]
        }

        let mut initialized = self.initialized.write().await;
        *initialized = true;

        Ok(())
    }

    async fn concurrent_load(&self, buckets: &[String], failed_buckets: &mut HashSet<String>, mode: MetadataLoadMode) {
        let mut futures = Vec::new();

        for bucket in buckets.iter() {
            let api = self.api.clone();
            let bucket = bucket.clone();
            futures.push(async move {
                sleep(Duration::from_millis(30)).await;
                match mode {
                    MetadataLoadMode::Initial => {
                        let _ = api
                            .heal_bucket(
                                &bucket,
                                &HealOpts {
                                    recreate: true,
                                    ..Default::default()
                                },
                            )
                            .await;
                        let (bm, persisted) =
                            load_bucket_metadata_parse_with_presence(self.api.clone(), bucket.as_str(), true).await?;
                        if persisted {
                            self.set(bucket, Arc::new(bm)).await;
                        } else {
                            let _publish_guard = self.metadata_publish_lock.lock().await;
                            let mut map = self.metadata_map.write().await;
                            map.entry(bucket).or_insert_with(|| Arc::new(bm));
                        }
                    }
                    MetadataLoadMode::Refresh => {
                        let expected = self.metadata_map.read().await.get(&bucket).cloned();
                        let heal_lock = api.new_ns_lock(&bucket, &bucket).await?;
                        let heal_guard = heal_lock.get_read_lock(crate::set_disk::get_lock_acquire_timeout()).await?;
                        await_bucket_namespace_operation(
                            Some(&heal_guard),
                            &bucket,
                            "bucket metadata refresh heal",
                            api.heal_bucket(&bucket, &HealOpts::default()),
                        )
                        .await?;
                        drop(heal_guard);
                        let (bm, persisted) =
                            load_bucket_metadata_parse_with_presence(self.api.clone(), bucket.as_str(), true).await?;
                        let publish_lock = api.new_ns_lock(&bucket, &bucket).await?;
                        let guard = publish_lock
                            .get_read_lock(crate::set_disk::get_lock_acquire_timeout())
                            .await?;
                        if guard.is_lock_lost() {
                            return Err(Error::other(format!(
                                "bucket namespace lock was lost before bucket metadata refresh publish: {bucket}"
                            )));
                        }
                        self.publish_refresh_if_unchanged(&bucket, expected.as_ref(), bm, persisted)
                            .await;
                    }
                }
                Ok::<(), Error>(())
            });
        }

        let results = join_all(futures).await;

        for (idx, res) in results.into_iter().enumerate() {
            match res {
                Ok(()) => {}
                Err(e) => {
                    error!("Unable to load bucket metadata, will be retried: {:?}", e);
                    if let Some(bucket) = buckets.get(idx) {
                        failed_buckets.insert(bucket.clone());
                    }
                }
            }
        }
    }

    async fn publish_refresh_if_unchanged(
        &self,
        bucket: &str,
        expected: Option<&Arc<BucketMetadata>>,
        metadata: BucketMetadata,
        persisted: bool,
    ) {
        if !persisted {
            return;
        }
        let _publish_guard = self.metadata_publish_lock.lock().await;
        let metadata = Arc::new(metadata);
        let mut map = self.metadata_map.write().await;
        let unchanged = expected
            .zip(map.get(bucket))
            .is_some_and(|(expected, current)| Arc::ptr_eq(expected, current));
        if !unchanged {
            return;
        }
        map.insert(bucket.to_string(), Arc::clone(&metadata));
        drop(map);
        self.absent_metadata.invalidate(bucket).await;
        sync_bucket_target_sys(bucket, &metadata).await;
        sync_bucket_durability(bucket, &metadata);
    }

    pub async fn get(&self, bucket: &str) -> Result<Arc<BucketMetadata>> {
        if is_meta_bucketname(bucket) {
            return Err(Error::ConfigNotFound);
        }

        let map = self.metadata_map.read().await;
        if let Some(bm) = map.get(bucket) {
            Ok(bm.clone())
        } else {
            Err(Error::ConfigNotFound)
        }
    }

    pub async fn set(&self, bucket: String, bm: Arc<BucketMetadata>) {
        if !is_meta_bucketname(&bucket) {
            let _publish_guard = self.metadata_publish_lock.lock().await;
            let mut map = self.metadata_map.write().await;
            map.insert(bucket.clone(), bm.clone());
            drop(map);
            // Real metadata supersedes any recorded absence immediately.
            self.absent_metadata.invalidate(&bucket).await;
            sync_bucket_target_sys(&bucket, &bm).await;
            sync_bucket_durability(&bucket, &bm);
        }
    }

    /// Reload `bucket`'s metadata from this system's own store and cache it,
    /// refusing to treat a load miss as authoritative (the peer
    /// LoadBucketMetadata notification path, [`reload_bucket_metadata`]).
    ///
    /// Only metadata actually read from persisted storage reaches the cache.
    /// On a miss the fabricated default is discarded and an error is
    /// returned: installing it would let a transient ConfigNotFound during
    /// the notification overwrite a lock-enabled bucket's cached metadata
    /// with an authoritative "no Object Lock" default, disabling the
    /// batch-delete retention gate (`object_lock_delete_check_required`) on
    /// this node until the next refresh. A miss is also not treated as
    /// deletion: bucket deletion propagates through the dedicated
    /// DeleteBucketMetadata notification ([`remove_bucket_metadata`]), which
    /// is best-effort — a reload racing it can still re-install a just
    /// deleted bucket's entry (pre-existing, bounded by the next delete or
    /// restart) — but a reload miss removing entries would turn every
    /// transient quorum dip into dropped metadata and spurious
    /// target/durability teardown.
    ///
    /// The peer-visible error text is deliberately fixed: the notifying peer
    /// matches error strings against network-failure needles
    /// (`is_network_like_error`), so interpolating a caller-controlled
    /// bucket name here could mark a healthy peer offline.
    ///
    /// Lock order: the caller holds the outer metadata-sys guard, and the
    /// load acquires the namespace lock on the bucket's metadata config
    /// object — the same `outer guard → meta-config namespace lock` order
    /// `update`'s load takes; no path acquires these in reverse.
    pub(crate) async fn reload_from_store(&self, bucket: &str) -> Result<()> {
        let (bm, persisted) = load_bucket_metadata_parse_with_presence(self.api.clone(), bucket, true).await?;
        if !persisted {
            return Err(Error::other("no persisted bucket metadata readable; peer cache left unchanged"));
        }
        self.set(bucket.to_string(), Arc::new(bm)).await;
        Ok(())
    }

    /// Remove a bucket's cached metadata from the in-memory map.
    ///
    /// Returns `true` if an entry was present. Reserved meta buckets are ignored.
    pub async fn remove(&self, bucket: &str) -> bool {
        if is_meta_bucketname(bucket) {
            return false;
        }
        let _publish_guard = self.metadata_publish_lock.lock().await;
        let mut map = self.metadata_map.write().await;
        let removed = map.remove(bucket).is_some();
        drop(map);
        if removed {
            BucketTargetSys::get().delete(bucket).await;
            clear_bucket_durability(bucket);
        }
        removed
    }

    async fn _reset(&mut self) {
        let mut map = self.metadata_map.write().await;
        map.clear();
    }

    pub async fn update(&mut self, bucket: &str, config_file: &str, data: Vec<u8>) -> Result<OffsetDateTime> {
        self.update_and_parse(bucket, config_file, data, true).await
    }

    pub async fn delete(&mut self, bucket: &str, config_file: &str) -> Result<OffsetDateTime> {
        self.update_and_parse(bucket, config_file, Vec::new(), false).await
    }

    async fn update_and_parse(&mut self, bucket: &str, config_file: &str, data: Vec<u8>, parse: bool) -> Result<OffsetDateTime> {
        let Some(store) = runtime_sources::object_store_handle() else {
            return Err(Error::other("errServerNotInitialized"));
        };

        let mut bm = Self::load_bucket_metadata_for_update(store, bucket, parse).await?;

        let updated = bm.update_config(config_file, data)?;

        self.save(bm).await?;

        Ok(updated)
    }

    /// See the free [`update_config_with`]: same load-mutate-persist cycle as
    /// [`Self::update`], with the payload computed from the loaded metadata
    /// instead of supplied up front. Loads through this system's own store so
    /// the read and the persisted write target the same instance.
    async fn update_config_with<F>(&mut self, bucket: &str, config_file: &str, mutate: F) -> Result<OffsetDateTime>
    where
        F: FnOnce(&BucketMetadata) -> Result<Vec<u8>> + Send,
    {
        let mut bm = Self::load_bucket_metadata_for_update(self.api.clone(), bucket, true).await?;

        let data = mutate(&bm)?;
        let updated = bm.update_config(config_file, data)?;

        self.save(bm).await?;

        Ok(updated)
    }

    /// Load a bucket's on-disk metadata as the base of a config rewrite.
    /// Outside erasure setups a missing metadata file degrades to a fresh
    /// default (legacy buckets without one); erasure setups fail instead of
    /// fabricating state that a quorum may still hold.
    async fn load_bucket_metadata_for_update(store: Arc<ECStore>, bucket: &str, parse: bool) -> Result<BucketMetadata> {
        if is_meta_bucketname(bucket) {
            return Err(Error::other("errInvalidArgument"));
        }

        match load_bucket_metadata_parse(store, bucket, parse).await {
            Ok(res) => Ok(res),
            Err(err) => {
                if !runtime_sources::setup_is_erasure().await
                    && !runtime_sources::setup_is_dist_erasure().await
                    && is_err_bucket_not_found(&err)
                {
                    Ok(BucketMetadata::new(bucket))
                } else {
                    error!("load bucket metadata failed: {}", err);
                    Err(err)
                }
            }
        }
    }

    async fn save(&self, bm: BucketMetadata) -> Result<()> {
        if is_meta_bucketname(&bm.name) {
            return Err(Error::other("errInvalidArgument"));
        }

        self.persist_and_set(bm).await
    }

    /// Persist metadata through this system's own store and cache it here
    /// (backlog#1052 S7). The store-scoped bucket path uses this so a second
    /// server's metadata never leaks into the ambient (first) instance.
    pub(crate) async fn persist_and_set(&self, bm: BucketMetadata) -> Result<()> {
        let mut bm = bm;

        bm.save_with_store(self.api.clone()).await?;

        self.set(bm.name.clone(), Arc::new(bm)).await;

        Ok(())
    }

    async fn bucket_names(&self) -> Vec<String> {
        self.metadata_map.read().await.keys().cloned().collect()
    }

    pub async fn get_config_from_disk(&self, bucket: &str) -> Result<BucketMetadata> {
        if is_meta_bucketname(bucket) {
            return Err(Error::other("errInvalidArgument"));
        }

        load_bucket_metadata(self.api.clone(), bucket).await
    }

    pub async fn get_config(&self, bucket: &str) -> Result<(Arc<BucketMetadata>, bool)> {
        let has_bm = {
            let map = self.metadata_map.read().await;
            map.get(bucket).cloned()
        };

        if let Some(bm) = has_bm {
            Ok((bm, false))
        } else {
            // A recent lookup already established there is no persisted
            // metadata: serve the fabricated default without another
            // namespace-lock + erasure-set fanout.
            if self.absent_metadata.get(bucket).await.is_some() {
                let mut bm = BucketMetadata::new(bucket);
                bm.default_timestamps();
                return Ok((Arc::new(bm), true));
            }

            let lock = self.api.new_ns_lock(bucket, bucket).await?;
            let guard = lock.get_read_lock(crate::set_disk::get_lock_acquire_timeout()).await?;
            #[cfg(test)]
            if self.lazy_load_lock_probe.load(std::sync::atomic::Ordering::Relaxed) {
                let competing = self.api.new_ns_lock(bucket, bucket).await?;
                assert!(
                    competing.get_write_lock(Duration::from_millis(20)).await.is_err(),
                    "lazy metadata IO must start while the bucket namespace read lock is held"
                );
            }
            let (bm, persisted) = match await_bucket_namespace_operation(
                Some(&guard),
                bucket,
                "lazy bucket metadata load",
                Box::pin(load_bucket_metadata_parse_with_presence(self.api.clone(), bucket, true)),
            )
            .await
            {
                Ok(res) => res,
                Err(err) => {
                    return if *self.initialized.read().await {
                        Err(Error::other("errBucketMetadataNotInitialized"))
                    } else {
                        Err(err)
                    };
                }
            };

            let bm = Arc::new(bm);

            // This lazy path caches only metadata that actually exists on
            // this store. A fabricated default must not enter the map:
            // `get()` is map-only and fail-closed — the object-lock delete
            // gate (`object_lock_delete_check_required`) skips its per-object
            // protection stat exactly when the map serves metadata saying the
            // bucket has no Object Lock, so caching a fabricated default here
            // would turn a metadata miss into an authoritative "no lock"
            // answer. (Startup `concurrent_load` still caches fabricated
            // defaults for buckets listed on disk — legacy buckets without a
            // metadata file — but never lets one replace an existing entry.)
            if persisted {
                await_bucket_namespace_operation(
                    Some(&guard),
                    bucket,
                    "lazy bucket metadata existence check",
                    Box::pin(async {
                        self.api
                            .peer_sys
                            .get_bucket_info(bucket, &crate::storage_api_contracts::bucket::BucketOptions::default())
                            .await
                            .map(|_| ())
                            .map_err(Into::into)
                    }),
                )
                .await?;
                if guard.is_lock_lost() {
                    return Err(Error::other(format!(
                        "bucket namespace lock was lost before lazy bucket metadata publish: {bucket}"
                    )));
                }
                let _publish_guard = self.metadata_publish_lock.lock().await;
                let mut map = self.metadata_map.write().await;
                if let Some(current) = map.get(bucket) {
                    return Ok((Arc::clone(current), true));
                }
                map.insert(bucket.to_string(), bm.clone());
                drop(map);
                self.absent_metadata.invalidate(bucket).await;
                sync_bucket_target_sys(bucket, &bm).await;
                sync_bucket_durability(bucket, &bm);
            } else {
                self.absent_metadata.insert(bucket.to_string(), ()).await;
            }

            Ok((bm, true))
        }
    }

    pub async fn get_versioning_config(&self, bucket: &str) -> Result<(VersioningConfiguration, OffsetDateTime)> {
        let bm = match self.get_config(bucket).await {
            Ok((res, _)) => res,
            Err(err) => {
                return if err == Error::ConfigNotFound {
                    Ok((VersioningConfiguration::default(), OffsetDateTime::UNIX_EPOCH))
                } else {
                    Err(err)
                };
            }
        };

        if let Some(config) = &bm.versioning_config {
            Ok((config.clone(), bm.versioning_config_updated_at))
        } else {
            Ok((VersioningConfiguration::default(), bm.versioning_config_updated_at))
        }
    }

    pub async fn get_bucket_policy(&self, bucket: &str) -> Result<(BucketPolicy, OffsetDateTime)> {
        let (bm, _) = self.get_config(bucket).await?;

        if let Some(config) = &bm.policy_config {
            Ok((config.clone(), bm.policy_config_updated_at))
        } else if !bm.policy_config_json.is_empty() {
            Ok((serde_json::from_slice(&bm.policy_config_json)?, bm.policy_config_updated_at))
        } else {
            Err(Error::ConfigNotFound)
        }
    }

    /// Returns the raw JSON string of the bucket policy as originally stored.
    /// This preserves the exact format of the policy document as it was PUT.
    pub async fn get_bucket_policy_raw(&self, bucket: &str) -> Result<(String, OffsetDateTime)> {
        let (bm, _) = self.get_config(bucket).await?;

        if bm.policy_config_json.is_empty() {
            Err(Error::ConfigNotFound)
        } else {
            let policy_str = String::from_utf8(bm.policy_config_json.clone())
                .map_err(|e| Error::other(format!("invalid UTF-8 in policy JSON: {}", e)))?;
            Ok((policy_str, bm.policy_config_updated_at))
        }
    }

    pub async fn get_bucket_acl_config(&self, bucket: &str) -> Result<(String, OffsetDateTime)> {
        let (bm, _) = self.get_config(bucket).await?;

        if let Some(config) = &bm.bucket_acl_config {
            Ok((config.clone(), bm.bucket_acl_config_updated_at))
        } else {
            Err(Error::ConfigNotFound)
        }
    }

    pub async fn get_tagging_config(&self, bucket: &str) -> Result<(Tagging, OffsetDateTime)> {
        let (bm, _) = self.get_config(bucket).await?;

        if let Some(config) = &bm.tagging_config {
            Ok((config.clone(), bm.tagging_config_updated_at))
        } else {
            Err(Error::ConfigNotFound)
        }
    }

    pub async fn get_public_access_block_config(&self, bucket: &str) -> Result<(PublicAccessBlockConfiguration, OffsetDateTime)> {
        let (bm, _) = self.get_config(bucket).await?;

        if let Some(config) = &bm.public_access_block_config {
            Ok((config.clone(), bm.public_access_block_config_updated_at))
        } else {
            Err(Error::ConfigNotFound)
        }
    }

    pub async fn get_object_lock_config(&self, bucket: &str) -> Result<(ObjectLockConfiguration, OffsetDateTime)> {
        let (bm, _) = self.get_config(bucket).await?;

        if let Some(config) = &bm.object_lock_config {
            Ok((config.clone(), bm.object_lock_config_updated_at))
        } else {
            Err(Error::ConfigNotFound)
        }
    }

    pub async fn get_lifecycle_config(&self, bucket: &str) -> Result<(BucketLifecycleConfiguration, OffsetDateTime)> {
        let (bm, _) = self.get_config(bucket).await?;

        if let Some(config) = &bm.lifecycle_config {
            if config.rules.is_empty() {
                Err(Error::ConfigNotFound)
            } else {
                Ok((config.clone(), bm.lifecycle_config_updated_at))
            }
        } else {
            Err(Error::ConfigNotFound)
        }
    }

    pub async fn get_notification_config(&self, bucket: &str) -> Result<Option<NotificationConfiguration>> {
        let bm = match self.get_config(bucket).await {
            Ok((bm, _)) => bm.notification_config.clone(),
            Err(err) => {
                if err == Error::ConfigNotFound {
                    None
                } else {
                    return Err(err);
                }
            }
        };

        Ok(bm)
    }

    pub async fn get_sse_config(&self, bucket: &str) -> Result<(ServerSideEncryptionConfiguration, OffsetDateTime)> {
        let (bm, _) = self.get_config(bucket).await?;

        if let Some(config) = &bm.sse_config {
            Ok((config.clone(), bm.encryption_config_updated_at))
        } else {
            Err(Error::ConfigNotFound)
        }
    }

    pub async fn get_cors_config(&self, bucket: &str) -> Result<(CORSConfiguration, OffsetDateTime)> {
        let (bm, _) = self.get_config(bucket).await?;

        if let Some(config) = &bm.cors_config {
            Ok((config.clone(), bm.cors_config_updated_at))
        } else {
            Err(Error::ConfigNotFound)
        }
    }

    pub async fn get_website_config(&self, bucket: &str) -> Result<(WebsiteConfiguration, OffsetDateTime)> {
        let (bm, _) = self.get_config(bucket).await?;

        if let Some(config) = &bm.website_config {
            Ok((config.clone(), bm.website_config_updated_at))
        } else {
            Err(Error::ConfigNotFound)
        }
    }

    pub async fn get_logging_config(&self, bucket: &str) -> Result<(BucketLoggingStatus, OffsetDateTime)> {
        let (bm, _) = self.get_config(bucket).await?;

        if let Some(config) = &bm.logging_config {
            Ok((config.clone(), bm.logging_config_updated_at))
        } else {
            Err(Error::ConfigNotFound)
        }
    }

    pub async fn get_accelerate_config(&self, bucket: &str) -> Result<(AccelerateConfiguration, OffsetDateTime)> {
        let (bm, _) = self.get_config(bucket).await?;

        if let Some(config) = &bm.accelerate_config {
            Ok((config.clone(), bm.accelerate_config_updated_at))
        } else {
            Err(Error::ConfigNotFound)
        }
    }

    pub async fn get_request_payment_config(&self, bucket: &str) -> Result<(RequestPaymentConfiguration, OffsetDateTime)> {
        let (bm, _) = self.get_config(bucket).await?;

        if let Some(config) = &bm.request_payment_config {
            Ok((config.clone(), bm.request_payment_config_updated_at))
        } else {
            Err(Error::ConfigNotFound)
        }
    }

    pub async fn created_at(&self, bucket: &str) -> Result<OffsetDateTime> {
        let bm = match self.get_config(bucket).await {
            Ok((bm, _)) => bm.created,
            Err(err) => {
                return Err(err);
            }
        };

        Ok(bm)
    }

    pub async fn get_quota_config(&self, bucket: &str) -> Result<(BucketQuota, OffsetDateTime)> {
        let (bm, _) = self.get_config(bucket).await?;

        if let Some(config) = &bm.quota_config {
            Ok((config.clone(), bm.quota_config_updated_at))
        } else {
            Err(Error::ConfigNotFound)
        }
    }

    pub async fn get_replication_config(&self, bucket: &str) -> Result<(ReplicationConfiguration, OffsetDateTime)> {
        let (bm, _) = self.get_config(bucket).await?;

        if let Some(config) = &bm.replication_config {
            Ok((config.clone(), bm.replication_config_updated_at))
        } else {
            Err(Error::ConfigNotFound)
        }
    }

    pub async fn get_bucket_targets_config(&self, bucket: &str) -> Result<BucketTargets> {
        let (bm, _) = self.get_config(bucket).await?;

        if let Some(config) = &bm.bucket_target_config {
            Ok(config.clone())
        } else {
            Err(Error::ConfigNotFound)
        }
    }
}

/// Test-only fixture shared with sibling modules (e.g. the quota checker
/// tests): a 4-disk `ECStore` on an isolated instance context, so tests
/// exercising the metadata system never touch ambient process state.
#[cfg(test)]
pub(crate) mod test_support {
    use super::*;
    use crate::disk::endpoint::Endpoint;
    use crate::layout::endpoints::{EndpointServerPools, Endpoints, PoolEndpoints};
    use crate::runtime::instance::InstanceContext;
    use crate::store::init_local_disks_with_instance_ctx;

    pub(crate) async fn isolated_store_over_temp_disks() -> (Vec<tempfile::TempDir>, Arc<ECStore>) {
        let mut dirs = Vec::with_capacity(4);
        let mut endpoints = Vec::with_capacity(4);
        for disk_idx in 0..4 {
            let dir = tempfile::tempdir().expect("tempdir should be created");
            let mut endpoint =
                Endpoint::try_from(dir.path().to_str().expect("tempdir path should be utf8")).expect("endpoint should parse");
            endpoint.set_pool_index(0);
            endpoint.set_set_index(0);
            endpoint.set_disk_index(disk_idx);
            dirs.push(dir);
            endpoints.push(endpoint);
        }
        let endpoint_pools = EndpointServerPools(vec![PoolEndpoints {
            legacy: false,
            set_count: 1,
            drives_per_set: 4,
            endpoints: Endpoints::from(endpoints),
            cmd_line: "metadata-sys-cache-test".to_string(),
            platform: "test".to_string(),
        }]);
        let instance_ctx = Arc::new(InstanceContext::new());
        init_local_disks_with_instance_ctx(&instance_ctx, endpoint_pools.clone())
            .await
            .expect("local disks should initialize");
        let ecstore = ECStore::new_with_instance_ctx(
            "127.0.0.1:0".parse().expect("test address"),
            endpoint_pools,
            CancellationToken::new(),
            instance_ctx,
        )
        .await
        .expect("ECStore should initialize");
        (dirs, ecstore)
    }
}

#[cfg(test)]
mod tests {
    use super::test_support::isolated_store_over_temp_disks;
    use super::*;
    use crate::bucket::target::{BucketTarget, BucketTargetType, Credentials};
    use serial_test::serial;
    use tokio::time::timeout;

    /// Pins the fail-closed caching contract of the lazy `get_config` path
    /// and the refresh no-replace rule: fabricated defaults are returned but
    /// never served by the map-only `get()`, persisted metadata is cached on
    /// lazy load (superseding a recorded absence), a refresh-load miss never
    /// replaces an existing entry or heals a deleted bucket, and initial load
    /// still heals buckets discovered from storage.
    #[tokio::test]
    async fn get_config_never_caches_fabricated_defaults_as_authoritative() {
        let (dirs, ecstore) = isolated_store_over_temp_disks().await;
        let sys = Arc::new(BucketMetadataSys::new(ecstore));

        // (a) Miss: the fabricated default is returned but not cached.
        let (bm, _) = sys
            .get_config("absent-bucket")
            .await
            .expect("fabricated default should be returned");
        assert!(bm.object_lock_config_xml.is_empty());
        assert!(
            sys.get("absent-bucket").await.is_err(),
            "a fabricated default must never be served by the map-only get()"
        );

        // The repeat lookup is served from the negative cache, same answer.
        let (bm, _) = sys
            .get_config("absent-bucket")
            .await
            .expect("negative-cached default should be returned");
        assert!(bm.object_lock_config_xml.is_empty());
        assert!(sys.get("absent-bucket").await.is_err());

        // (b) Persisting real metadata supersedes the recorded absence, and a
        // lazy reload after a map wipe re-caches it.
        let mut persisted = BucketMetadata::new("absent-bucket");
        persisted.policy_config_json = b"persisted-marker".to_vec();
        sys.persist_and_set(persisted).await.expect("metadata should persist");
        for dir in &dirs {
            std::fs::create_dir_all(dir.path().join("absent-bucket")).expect("persisted bucket directory should be created");
        }
        sys.metadata_map.write().await.clear();
        let _ = sys
            .get_config("absent-bucket")
            .await
            .expect("persisted metadata should lazily reload");
        let cached = sys
            .get("absent-bucket")
            .await
            .expect("lazily loaded persisted metadata must be cached");
        assert_eq!(cached.policy_config_json, b"persisted-marker".to_vec());

        // (c) Persisted metadata left behind after physical deletion must not
        // be lazily republished as a live bucket generation.
        let mut deleted_lazy = BucketMetadata::new("deleted-lazy-bucket");
        deleted_lazy.policy_config_json = b"stale-generation".to_vec();
        sys.persist_and_set(deleted_lazy)
            .await
            .expect("stale metadata should persist");
        sys.metadata_map.write().await.remove("deleted-lazy-bucket");
        assert!(
            sys.get_config("deleted-lazy-bucket").await.is_err(),
            "lazy load must fail when the physical bucket no longer exists"
        );
        assert!(sys.get("deleted-lazy-bucket").await.is_err());

        // (d) The namespace generation fence must be acquired before lazy
        // metadata IO, so a writer can replace the generation atomically.
        let fenced_bucket = "fenced-lazy-bucket";
        for dir in &dirs {
            std::fs::create_dir_all(dir.path().join(fenced_bucket)).unwrap();
        }
        let mut old_fenced = BucketMetadata::new(fenced_bucket);
        old_fenced.policy_config_json = b"old-fenced-generation".to_vec();
        sys.persist_and_set(old_fenced).await.unwrap();
        sys.metadata_map.write().await.remove(fenced_bucket);
        sys.lazy_load_lock_probe.store(true, std::sync::atomic::Ordering::Relaxed);
        let (loaded, _) = sys.get_config(fenced_bucket).await.unwrap();
        sys.lazy_load_lock_probe.store(false, std::sync::atomic::Ordering::Relaxed);
        assert_eq!(loaded.policy_config_json, b"old-fenced-generation".to_vec());

        // (e) A refresh-load miss for a bucket that still exists must not
        // replace an existing entry with a fabricated default.
        let mut kept = BucketMetadata::new("kept-bucket");
        kept.policy_config_json = b"kept-marker".to_vec();
        sys.set("kept-bucket".to_string(), Arc::new(kept)).await;
        for dir in &dirs {
            std::fs::create_dir_all(dir.path().join("kept-bucket")).expect("kept bucket directory should be created");
        }
        let mut failed = HashSet::new();
        let refresh_targets = vec!["kept-bucket".to_string()];
        sys.concurrent_load(&refresh_targets, &mut failed, MetadataLoadMode::Refresh)
            .await;
        let kept = sys
            .get("kept-bucket")
            .await
            .expect("existing entry must survive a refresh miss");
        assert_eq!(
            kept.policy_config_json,
            b"kept-marker".to_vec(),
            "a fabricated refresh default must not replace real metadata"
        );

        // (f) A stale cache entry for a physically deleted bucket must not
        // recreate the bucket during periodic refresh.
        sys.set("deleted-bucket".to_string(), Arc::new(BucketMetadata::new("deleted-bucket")))
            .await;
        let deleted_targets = vec!["deleted-bucket".to_string()];
        sys.concurrent_load(&deleted_targets, &mut failed, MetadataLoadMode::Refresh)
            .await;
        assert!(
            dirs.iter().all(|dir| !dir.path().join("deleted-bucket").exists()),
            "periodic refresh must not recreate a bucket from stale cached metadata"
        );

        // (g) Metadata loaded for an old bucket generation must not replace
        // metadata published by delete plus same-name recreation.
        let old = Arc::new(BucketMetadata::new("recreated-bucket"));
        sys.set("recreated-bucket".to_string(), Arc::clone(&old)).await;
        let mut recreated = BucketMetadata::new("recreated-bucket");
        recreated.policy_config_json = b"new-generation".to_vec();
        sys.set("recreated-bucket".to_string(), Arc::new(recreated)).await;
        let mut stale = BucketMetadata::new("recreated-bucket");
        stale.policy_config_json = b"old-generation".to_vec();
        sys.publish_refresh_if_unchanged("recreated-bucket", Some(&old), stale, true)
            .await;
        assert_eq!(sys.get("recreated-bucket").await.unwrap().policy_config_json, b"new-generation".to_vec());

        // (f) Refresh retains periodic healing for a partially missing bucket.
        sys.set("partial-bucket".to_string(), Arc::new(BucketMetadata::new("partial-bucket")))
            .await;
        for dir in dirs.iter().take(3) {
            std::fs::create_dir_all(dir.path().join("partial-bucket")).unwrap();
        }
        sys.concurrent_load(&["partial-bucket".to_string()], &mut failed, MetadataLoadMode::Refresh)
            .await;
        assert!(dirs.iter().all(|dir| dir.path().join("partial-bucket").is_dir()));

        // (g) Initial discovery retains the historical unconditional heal.
        let initial_targets = vec!["initial-bucket".to_string()];
        sys.concurrent_load(&initial_targets, &mut failed, MetadataLoadMode::Initial)
            .await;
        assert!(
            dirs.iter().all(|dir| dir.path().join("initial-bucket").is_dir()),
            "initial load must heal buckets discovered from storage"
        );
    }

    #[tokio::test]
    async fn get_bucket_policy_rejects_malformed_cached_policy() {
        let (_dirs, ecstore) = isolated_store_over_temp_disks().await;
        let sys = BucketMetadataSys::new(ecstore);
        let mut metadata = BucketMetadata::new("malformed-policy");
        metadata.policy_config_json = b"{".to_vec();
        sys.set("malformed-policy".to_string(), Arc::new(metadata)).await;

        let err = sys
            .get_bucket_policy("malformed-policy")
            .await
            .expect_err("malformed persisted policy must not be treated as missing");

        assert!(matches!(err, Error::Io(_)), "malformed persisted policy must surface its parse failure");
    }
    /// A tagging rewrite through `update_config_with` (the Swift metadata
    /// POST path) is persisted: it survives a metadata reload from disk, and
    /// an emptied rewrite clears the config in the cached copy too instead of
    /// leaving stale parsed tags behind.
    #[tokio::test]
    async fn update_config_with_persists_tagging_rewrite_across_disk_reload() {
        use crate::bucket::metadata::BUCKET_TAGGING_CONFIG;
        use crate::storage_api_contracts::bucket::MakeBucketOptions;
        use s3s::dto::Tag;

        let (_dirs, ecstore) = isolated_store_over_temp_disks().await;

        let bucket = "swift-tagging-bucket";
        ecstore
            .peer_sys
            .make_bucket(bucket, &MakeBucketOptions::default())
            .await
            .expect("bucket volume should be created");
        let mut sys = BucketMetadataSys::new(ecstore);
        sys.persist_and_set(BucketMetadata::new(bucket))
            .await
            .expect("initial metadata should persist");

        let tagging = Tagging {
            tag_set: vec![Tag {
                key: Some("swift-meta-color".to_string()),
                value: Some("blue".to_string()),
            }],
        };
        let xml = crate::bucket::utils::serialize::<Tagging>(&tagging).expect("tagging should serialize");
        sys.update_config_with(bucket, BUCKET_TAGGING_CONFIG, move |bm| {
            assert!(bm.tagging_config.is_none(), "rewrite must see the on-disk state");
            Ok(xml)
        })
        .await
        .expect("tagging rewrite should persist");

        // Simulate the disk-truth reload that used to lose Swift writes: drop
        // the cached entry and lazily re-load from the metadata file.
        sys.metadata_map.write().await.clear();
        let (tags, _) = sys
            .get_tagging_config(bucket)
            .await
            .expect("tagging must survive a reload from disk");
        assert_eq!(tags.tag_set.len(), 1);
        assert_eq!(tags.tag_set[0].key.as_deref(), Some("swift-meta-color"));
        assert_eq!(tags.tag_set[0].value.as_deref(), Some("blue"));

        // An emptied rewrite clears the config everywhere.
        sys.update_config_with(bucket, BUCKET_TAGGING_CONFIG, |bm| {
            assert!(bm.tagging_config.is_some(), "rewrite must see the persisted tags");
            Ok(Vec::new())
        })
        .await
        .expect("clearing rewrite should persist");
        assert_eq!(
            sys.get_tagging_config(bucket).await.unwrap_err(),
            Error::ConfigNotFound,
            "cleared tagging must not be served from the cache"
        );
        sys.metadata_map.write().await.clear();
        assert_eq!(
            sys.get_tagging_config(bucket).await.unwrap_err(),
            Error::ConfigNotFound,
            "cleared tagging must not reappear after a reload from disk"
        );
    }

    /// The load and the persisted write share one write guard, so concurrent
    /// rewrites of the same config compose instead of clobbering each other.
    /// Moving the load outside that guard loses all but the last tag.
    #[tokio::test]
    async fn concurrent_update_config_with_calls_do_not_lose_writes() {
        use crate::bucket::metadata::BUCKET_TAGGING_CONFIG;
        use s3s::dto::Tag;

        let (_dirs, ecstore) = isolated_store_over_temp_disks().await;
        let sys = Arc::new(RwLock::new(BucketMetadataSys::new(ecstore)));

        let bucket = "swift-tagging-concurrent";
        sys.read()
            .await
            .persist_and_set(BucketMetadata::new(bucket))
            .await
            .expect("initial metadata should persist");

        const WRITERS: usize = 8;
        let mut handles = Vec::with_capacity(WRITERS);
        for idx in 0..WRITERS {
            let sys = sys.clone();
            handles.push(tokio::spawn(async move {
                sys.write()
                    .await
                    .update_config_with(bucket, BUCKET_TAGGING_CONFIG, move |bm| {
                        // Each writer merges its own tag onto whatever is
                        // currently persisted — the Swift rewrite shape.
                        let mut tagging = bm.tagging_config.clone().unwrap_or_else(|| Tagging { tag_set: vec![] });
                        tagging.tag_set.push(Tag {
                            key: Some(format!("swift-meta-key{idx}")),
                            value: Some(idx.to_string()),
                        });
                        crate::bucket::utils::serialize::<Tagging>(&tagging).map_err(|e| Error::other(e.to_string()))
                    })
                    .await
            }));
        }

        for handle in handles {
            handle
                .await
                .expect("writer task should join")
                .expect("rewrite should persist");
        }

        let (tags, _) = sys
            .read()
            .await
            .get_tagging_config(bucket)
            .await
            .expect("tagging should be readable");
        assert_eq!(tags.tag_set.len(), WRITERS, "every concurrent rewrite must survive: {tags:?}");
    }

    /// Pins the peer reload-notification contract (`reload_from_store`, the
    /// LoadBucketMetadata RPC path): only metadata actually read from
    /// persisted storage enters the cache. A load miss errors out and leaves
    /// the cache untouched — it must neither install a fabricated default
    /// for an unknown bucket nor replace an existing entry, since a
    /// transient ConfigNotFound during the notification would otherwise
    /// downgrade a lock-enabled bucket to an authoritative "no Object Lock"
    /// default and disable the batch-delete retention gate on this peer.
    #[tokio::test]
    async fn peer_reload_never_caches_fabricated_defaults_as_authoritative() {
        let (_dirs, ecstore) = isolated_store_over_temp_disks().await;
        let sys = BucketMetadataSys::new(ecstore.clone());

        // (a) Miss with no cached entry: the reload fails and installs nothing.
        let err = sys
            .reload_from_store("reload-bucket")
            .await
            .expect_err("a reload miss must be reported to the notifying peer");
        assert!(
            err.to_string().contains("no persisted bucket metadata readable"),
            "the miss must surface through the dedicated non-persisted branch, got: {err}"
        );
        assert!(
            sys.get("reload-bucket").await.is_err(),
            "a reload miss must not install a fabricated default"
        );

        // (b) Miss with an existing entry: the reload fails and the entry
        // (standing in for a lock-enabled bucket's metadata) survives intact.
        let mut kept = BucketMetadata::new("reload-bucket");
        kept.object_lock_config_xml = b"<ObjectLockConfiguration/>".to_vec();
        sys.set("reload-bucket".to_string(), Arc::new(kept)).await;
        assert!(sys.reload_from_store("reload-bucket").await.is_err());
        let cached = sys
            .get("reload-bucket")
            .await
            .expect("existing entry must survive a reload miss");
        assert_eq!(
            cached.object_lock_config_xml,
            b"<ObjectLockConfiguration/>".to_vec(),
            "a reload miss must not replace the cached entry with a fabricated default"
        );

        // (c) Persisted metadata reloads over a stale cached entry: the
        // reload converges the cache to disk truth.
        let mut persisted = BucketMetadata::new("reload-bucket");
        persisted.policy_config_json = b"persisted-marker".to_vec();
        sys.persist_and_set(persisted).await.expect("metadata should persist");
        let mut stale = BucketMetadata::new("reload-bucket");
        stale.policy_config_json = b"stale-cache-marker".to_vec();
        sys.set("reload-bucket".to_string(), Arc::new(stale)).await;
        sys.reload_from_store("reload-bucket")
            .await
            .expect("persisted metadata should reload");
        let cached = sys
            .get("reload-bucket")
            .await
            .expect("reloaded persisted metadata must be cached");
        assert_eq!(
            cached.policy_config_json,
            b"persisted-marker".to_vec(),
            "a reload must converge the cache to the persisted disk state"
        );
    }

    fn target(bucket: &str, id: &str) -> BucketTarget {
        BucketTarget {
            source_bucket: bucket.to_string(),
            endpoint: format!("{id}.example.com:9000"),
            credentials: Some(Credentials {
                access_key: "access".to_string(),
                secret_key: "secret".to_string(),
                ..Default::default()
            }),
            target_bucket: format!("{bucket}-{id}"),
            arn: format!("arn:rustfs:replication:us-east-1:{bucket}:{id}"),
            target_type: BucketTargetType::ReplicationService,
            region: "us-east-1".to_string(),
            ..Default::default()
        }
    }

    #[tokio::test]
    #[serial]
    async fn metadata_reload_syncs_bucket_target_sys() {
        let bucket = "metadata-reload-targets";
        let target_sys = BucketTargetSys::get();
        target_sys.delete(bucket).await;

        let mut bm = BucketMetadata::new(bucket);
        bm.bucket_target_config = Some(BucketTargets {
            targets: vec![target(bucket, "fresh")],
        });

        sync_bucket_target_sys(bucket, &bm).await;

        let targets = target_sys
            .list_bucket_targets(bucket)
            .await
            .expect("target sync should publish bucket targets");
        assert_eq!(targets.targets.len(), 1);
        assert_eq!(targets.targets[0].arn, format!("arn:rustfs:replication:us-east-1:{bucket}:fresh"));

        target_sys.delete(bucket).await;
    }

    #[tokio::test]
    #[serial]
    async fn metadata_reload_clears_stale_bucket_targets_when_config_is_removed() {
        let bucket = "metadata-clear-targets";
        let target_sys = BucketTargetSys::get();
        target_sys.delete(bucket).await;
        target_sys
            .targets_map
            .write()
            .await
            .insert(bucket.to_string(), vec![target(bucket, "stale")]);

        let bm = BucketMetadata::new(bucket);
        sync_bucket_target_sys(bucket, &bm).await;

        assert!(target_sys.list_bucket_targets(bucket).await.is_err());
        target_sys.delete(bucket).await;
    }

    /// HP-5b (rustfs/backlog#938): installing bucket metadata publishes the
    /// durability override to the disk-layer registry, and clearing the
    /// config (or an invalid payload) withdraws it.
    #[test]
    fn metadata_sync_publishes_and_clears_durability_override() {
        use crate::disk::local::{DurabilityMode, bucket_durability};

        let bucket = "metadata-sync-durability";

        let mut bm = BucketMetadata::new(bucket);
        bm.durability_config_json = br#"{"mode":"relaxed"}"#.to_vec();
        sync_bucket_durability(bucket, &bm);
        assert_eq!(bucket_durability::lookup(bucket), Some(DurabilityMode::Relaxed));

        // Metadata without the config entry clears the override.
        let bm = BucketMetadata::new(bucket);
        sync_bucket_durability(bucket, &bm);
        assert_eq!(bucket_durability::lookup(bucket), None);

        // Invalid payloads degrade to "no override", never to a tier.
        let mut bm = BucketMetadata::new(bucket);
        bm.durability_config_json = br#"{"mode":"bogus"}"#.to_vec();
        sync_bucket_durability(bucket, &bm);
        assert_eq!(bucket_durability::lookup(bucket), None);

        // Cache removal clears the override too.
        let mut bm = BucketMetadata::new(bucket);
        bm.durability_config_json = br#"{"mode":"none"}"#.to_vec();
        sync_bucket_durability(bucket, &bm);
        assert_eq!(bucket_durability::lookup(bucket), Some(DurabilityMode::None));
        clear_bucket_durability(bucket);
        assert_eq!(bucket_durability::lookup(bucket), None);
    }

    #[tokio::test]
    async fn refresh_wait_exits_when_cancelled() {
        let cancel_token = CancellationToken::new();
        cancel_token.cancel();

        let should_refresh = timeout(
            Duration::from_millis(100),
            wait_refresh_interval_or_cancel(&cancel_token, Duration::from_secs(60)),
        )
        .await
        .expect("cancelled refresh wait should not sleep until the interval");

        assert!(!should_refresh);
    }
}