Function bodies 468 total

TArray<UItemDefinition*> UItemDefinitionRegistry::GetDefinitionsByTag(FGameplayTag FilterTag) const
{
	if (!FilterTag.IsValid())
	{
		return GetAllDefinitions();
	}

	FReadScopeLock ReadLock(RegistryLock);

	TArray<UItemDefinition*> Result;
	for (const auto& Pair : DefinitionMap)
	{
		if (IsValid(Pair.Value) && Pair.Value->ItemTags.HasTag(FilterTag))
		{
			Result.Add(Pair.Value.Get());
		}
	}
	return Result;
}

int32 UItemDefinitionRegistry::GetDefinitionCount() const
{
	FReadScopeLock ReadLock(RegistryLock);
	return DefinitionMap.Num();
}

TArray<FString> UItemDefinitionRegistry::ValidateRegistry() const
{
	FReadScopeLock ReadLock(RegistryLock);

	// Collect all definitions into an array for ParallelFor
	TArray<TPair<FGameplayTag, const UItemDefinition*>> AllDefs;
	AllDefs.Reserve(DefinitionMap.Num());
	for (const auto& Pair : DefinitionMap)
	{
		AllDefs.Emplace(Pair.Key, Pair.Value.Get());
	}

	// Thread-safe collection of warnings
	FCriticalSection WarningLock;
	TArray<FString> Warnings;

	// ParallelFor for batch validation of large catalogs
	ParallelFor(AllDefs.Num(), [&](int32 Index)
	{
		const FGameplayTag& Tag = AllDefs[Index].Key;
		const UItemDefinition* Def = AllDefs[Index].Value;

		if (!IsValid(Def))
		{
			FScopeLock Lock(&WarningLock);
			Warnings.Add(FString::Printf(TEXT("Tag '%s': null definition"), *Tag.ToString()));
			return;
		}

		// Check for missing Visuals fragment
		const UItemFragment_Visuals* Visuals = Def->FindFragmentByClass<UItemFragment_Visuals>();
		if (!Visuals)
		{
			FScopeLock Lock(&W

bool UItemDefinitionRegistry::RegisterDefinition(FGameplayTag Tag, UItemDefinition* Definition)
{
	if (!Tag.IsValid())
	{
		UE_LOG(LogVaultRegistry, Error, TEXT("RegisterDefinition: invalid tag"));
		return false;
	}

	if (!IsValid(Definition))
	{
		UE_LOG(LogVaultRegistry, Error, TEXT("RegisterDefinition: null definition for tag '%s'"),
			*Tag.ToString());
		return false;
	}

	FWriteScopeLock WriteLock(RegistryLock);

	if (bRegistryFinalized)
	{
		UE_LOG(LogVaultRegistry, Error,
			TEXT("RegisterDefinition: registry is finalized, rejecting '%s'"), *Tag.ToString());
		return false;
	}

	if (DefinitionMap.Contains(Tag))
	{
		UE_LOG(LogVaultRegistry, Error,
			TEXT("RegisterDefinition: duplicate tag '%s' — collision rejected"), *Tag.ToString());
		return false;
	}

	DefinitionMap.Add(Tag, Definition);
	UE_LOG(LogVaultRegistry, Verbose, TEXT("Registered '%s'"), *Tag.ToString());
	return true;
}

void UItemDefinitionRegistry::PopulateFromDataTable(const UDataTable* DataTable)
{
	if (!DataTable)
	{
		return;
	}

	const FString ContextString(TEXT("ItemDefinitionRegistry::PopulateFromDataTable"));
	TArray<FItemDefinitionRow*> AllRows;
	DataTable->GetAllRows<FItemDefinitionRow>(ContextString, AllRows);

	UE_LOG(LogVaultRegistry, Display, TEXT("Populating from DataTable '%s' (%d rows)"),
		*DataTable->GetName(), AllRows.Num());

	int32 SuccessCount = 0;
	for (const FItemDefinitionRow* Row : AllRows)
	{
		if (!Row || !Row->ItemTag.IsValid())
		{
			UE_LOG(LogVaultRegistry, Warning, TEXT("Skipping row with invalid ItemTag"));
			continue;
		}

		UItemDefinition* Def = CreateDefinitionFromRow(*Row);
		if (Def && RegisterDefinition(Row->ItemTag, Def))
		{
			++SuccessCount;
		}
	}

	UE_LOG(LogVaultRegistry, Display, TEXT("DataTable: registered %d/%d definitions"),
		SuccessCount, AllRows.Num());
}

void UItemDefinitionRegistry::PopulateFromAssetManager()
{
	UAssetManager& AssetManager = UAssetManager::Get();

	TArray<FPrimaryAssetId> AssetIds;
	AssetManager.GetPrimaryAssetIdList(FPrimaryAssetType(TEXT("ItemDefinition")), AssetIds);

	if (AssetIds.Num() == 0)
	{
		UE_LOG(LogVaultRegistry, Display, TEXT("Asset Manager: no ItemDefinition assets found"));
		return;
	}

	UE_LOG(LogVaultRegistry, Display, TEXT("Asset Manager: found %d ItemDefinition assets"), AssetIds.Num());

	int32 SuccessCount = 0;
	for (const FPrimaryAssetId& AssetId : AssetIds)
	{
		FSoftObjectPath AssetPath = AssetManager.GetPrimaryAssetPath(AssetId);
		UItemDefinition* Def = Cast<UItemDefinition>(AssetPath.TryLoad());

		if (!IsValid(Def))
		{
			UE_LOG(LogVaultRegistry, Warning, TEXT("Failed to load ItemDefinition asset: %s"),
				*AssetId.ToString());
			continue;
		}

		if (Def->ItemTags.Num() == 0)
		{
			UE_LOG(LogVaultRegistry, Warning, TEXT("ItemDefinition '%s' has no ItemTags, skipping"),
				*Def->GetN

void UItemDefinitionRegistry::FinalizeRegistry()
{
	{
		FWriteScopeLock WriteLock(RegistryLock);
		bRegistryFinalized = true;
		IntegrityHash = ComputeIntegrityHash();
	}

	bRegistryReady = true;

	UE_LOG(LogVaultRegistry, Display,
		TEXT("Registry finalized: %d definitions, integrity hash 0x%08X"),
		DefinitionMap.Num(), IntegrityHash);

	OnRegistryReady.Broadcast();
}

UItemDefinition* UItemDefinitionRegistry::CreateDefinitionFromRow(const FItemDefinitionRow& Row)
{
	if (!Row.ItemTag.IsValid())
	{
		return nullptr;
	}

	// Create the definition with a stable name derived from the tag
	// The outer is 'this' (the registry subsystem) so it stays alive for the session
	FName DefName(*FString::Printf(TEXT("ItemDef_%s"), *Row.ItemTag.ToString().Replace(TEXT("."), TEXT("_"))));
	UItemDefinition* Def = NewObject<UItemDefinition>(this, DefName);

	// Build ItemTags from primary + extras
	Def->ItemTags.AddTag(Row.ItemTag);
	Def->ItemTags.AppendTags(Row.ExtraTags);

	// Always create Visuals fragment — DisplayName is essential for UI
	UItemFragment_Visuals* Visuals = NewObject<UItemFragment_Visuals>(Def);
	Visuals->DisplayName = Row.DisplayName;
	Visuals->Description = Row.Description;
	Visuals->InventoryIcon = Row.InventoryIcon;
	Visuals->WorldDropActorClass = Row.WorldDropActorClass;
	Def->Fragments.Add(Visuals);

	// Conditional: Stackable (only if MaxStac

int32 UItemDefinitionRegistry::ComputeIntegrityHash() const
{
	// Collect and sort all tag strings for deterministic hashing
	TArray<FString> TagStrings;
	TagStrings.Reserve(DefinitionMap.Num());
	for (const auto& Pair : DefinitionMap)
	{
		TagStrings.Add(Pair.Key.ToString());
	}
	TagStrings.Sort();

	// Build a single concatenated string and hash it
	FString Combined;
	for (const FString& TagStr : TagStrings)
	{
		Combined += TagStr;
		Combined += TEXT("|");
	}

	return static_cast<int32>(FCrc::StrCrc32(*Combined));
}

void UItemFragment::GetPreloadDependencies(TArray<UObject*>& OutDeps)
{
	Super::GetPreloadDependencies(OutDeps);
	// Subclasses override to register TSoftObjectPtr assets with the Asset Manager
}

FText UItemFragment::GetFragmentDescription() const
{
	return FText::FromString(GetClass()->GetName());
}

bool UInventoryDebugSubsystem::ShouldCreateSubsystem(UObject* Outer) const
{
	// Never create in shipping builds — debug-only subsystem
#if UE_BUILD_SHIPPING
	return false;
#else
	return true;
#endif
}

void UInventoryDebugSubsystem::Initialize(FSubsystemCollectionBase& Collection)
{
	Super::Initialize(Collection);

	RecentEvents.Reserve(MaxEventCount);
	SessionStartTime = FPlatformTime::Seconds();

	// Register console command for toggling the HUD overlay.
	// During editor map transitions, the new world's subsystems initialize BEFORE
	// the old world's subsystems deinitialize. Unregister the stale command first
	// to prevent the console manager "already exists" warning and ensure the
	// delegate binds to THIS subsystem's weak lambda (not the dying one).
	IConsoleObject* Existing = IConsoleManager::Get().FindConsoleObject(TEXT("Vault.Debug.Toggle"), false);
	if (Existing)
	{
		IConsoleManager::Get().UnregisterConsoleObject(Existing, false);
	}
	ToggleCommand = MakeUnique<FAutoConsoleCommand>(
		TEXT("Vault.Debug.Toggle"),
		TEXT("Toggle the Vault Debug HUD overlay"),
		FConsoleCommandDelegate::CreateWeakLambda(this, [this]()
		{
			bHUDVisible = !bHUDVisible;
			OnDebugHUDToggled

		FConsoleCommandDelegate::CreateWeakLambda(this, [this]()
		{
			bHUDVisible = !bHUDVisible;
			OnDebugHUDToggled.Broadcast(bHUDVisible);
			UE_LOG(LogVaultDX, Display, TEXT("Debug HUD %s"), bHUDVisible ? TEXT("shown") : TEXT("hidden"));
		})

void UInventoryDebugSubsystem::Deinitialize()
{
	UnbindFromTrackedComponent();

	// Skip unsubscribing from AuditLogSubsystem during world teardown.
	// Subsystem deinit order is nondeterministic — AuditLogSubsystem may
	// already be destroyed. AddUObject bindings auto-invalidate when this
	// UObject is destroyed, so manual removal is unnecessary.

	// Release console command ownership without unregistering.
	// During editor map transitions the new subsystem's Initialize() already
	// unregistered the stale command and created a fresh one, so Reset() here
	// would accidentally unregister the NEW subsystem's command.
	// Intentional leak (~16 bytes per map transition, debug-only subsystem).
	FAutoConsoleCommand* Leaked = ToggleCommand.Release();
	(void)Leaked;

	UE_LOG(LogVaultDX, Display, TEXT("InventoryDebugSubsystem shut down."));

	Super::Deinitialize();
}

void UInventoryDebugSubsystem::RecordEvent(const FAuditEvent& Event)
{
	// No-op while frozen — preserve the frozen state for inspection
	if (bFrozen)
	{
		return;
	}

	RecentEvents.Add(Event);

	// Evict oldest when exceeding capacity
	if (RecentEvents.Num() > MaxEventCount)
	{
		RecentEvents.RemoveAt(0);
	}
}

const TArray<FAuditEvent>& UInventoryDebugSubsystem::GetRecentEvents() const
{
	return bFrozen ? FrozenEvents : RecentEvents;
}

void UInventoryDebugSubsystem::CacheSnapshot(const FInventorySnapshot& Snapshot)
{
	if (bFrozen)
	{
		return;
	}

	CachedSnapshot = Snapshot;
}

const FInventorySnapshot& UInventoryDebugSubsystem::GetCachedSnapshot() const
{
	return bFrozen ? FrozenSnapshot : CachedSnapshot;
}

void UInventoryDebugSubsystem::RefreshSnapshot()
{
	if (bFrozen)
	{
		return;
	}

	if (TrackedComponent.IsValid())
	{
		CachedSnapshot = TrackedComponent->CreateSnapshot();
	}
}

FDebugHealthMetrics UInventoryDebugSubsystem::GetHealthMetrics() const
{
	FDebugHealthMetrics Metrics;

	// Query storage metrics from the game instance subsystem
	if (const UWorld* World = GetWorld())
	{
		if (const UGameInstance* GI = World->GetGameInstance())
		{
			if (const UVaultStorageManager* StorageMgr = GI->GetSubsystem<UVaultStorageManager>())
			{
				Metrics.StorageLatencyP95 = StorageMgr->GetLatencyP95();
				Metrics.StorageOperationCount = StorageMgr->GetOperationCount();
				Metrics.StorageFailureRate = StorageMgr->GetFailureRate();
			}
		}

		// Query audit event count
		if (const UAuditLogSubsystem* AuditSub = World->GetSubsystem<UAuditLogSubsystem>())
		{
			Metrics.TotalAuditEvents = AuditSub->GetTotalEventsDispatched();
		}
	}

	// Calculate events per second from session lifetime
	const double ElapsedSeconds = FPlatformTime::Seconds() - SessionStartTime;
	if (ElapsedSeconds > 0.0)
	{
		Metrics.EventsPerSecond = static_cast<float>(Metrics.TotalAuditEvents / Elaps

void UInventoryDebugSubsystem::SetFreezeFrame(bool bFreeze)
{
	if (bFreeze == bFrozen)
	{
		return;
	}

	if (bFreeze)
	{
		// Capture current state into frozen copies
		FrozenEvents = RecentEvents;
		FrozenSnapshot = CachedSnapshot;
		UE_LOG(LogVaultDX, Display, TEXT("Freeze-frame ON: captured %d events, hash=%d"),
			FrozenEvents.Num(), FrozenSnapshot.InventoryHash);
	}
	else
	{
		// Discard frozen copies
		FrozenEvents.Reset();
		FrozenSnapshot = FInventorySnapshot();
		UE_LOG(LogVaultDX, Display, TEXT("Freeze-frame OFF: resumed live updates."));
	}

	bFrozen = bFreeze;
}

void UInventoryDebugSubsystem::TrackInventory(UInventoryManagerComponent* InComponent)
{
	// Unbind from any previously tracked component
	UnbindFromTrackedComponent();

	if (!IsValid(InComponent))
	{
		TrackedComponent.Reset();
		return;
	}

	TrackedComponent = InComponent;

	// Bind to inventory delegates for automatic snapshot refresh
	InComponent->OnInventoryItemAdded.AddDynamic(this, &UInventoryDebugSubsystem::OnItemAdded);
	InComponent->OnInventoryItemRemoved.AddDynamic(this, &UInventoryDebugSubsystem::OnItemRemoved);
	InComponent->OnInventoryItemChanged.AddDynamic(this, &UInventoryDebugSubsystem::OnItemChanged);
	InComponent->OnCurrencyChanged.AddDynamic(this, &UInventoryDebugSubsystem::OnCurrencyChanged);

	// Capture initial snapshot
	RefreshSnapshot();

	UE_LOG(LogVaultDX, Display, TEXT("Now tracking inventory for ProfileID=%s"),
		*InComponent->ProfileID);
}

void UInventoryDebugSubsystem::UnbindFromTrackedComponent()
{
	if (TrackedComponent.IsValid())
	{
		TrackedComponent->OnInventoryItemAdded.RemoveDynamic(this, &UInventoryDebugSubsystem::OnItemAdded);
		TrackedComponent->OnInventoryItemRemoved.RemoveDynamic(this, &UInventoryDebugSubsystem::OnItemRemoved);
		TrackedComponent->OnInventoryItemChanged.RemoveDynamic(this, &UInventoryDebugSubsystem::OnItemChanged);
		TrackedComponent->OnCurrencyChanged.RemoveDynamic(this, &UInventoryDebugSubsystem::OnCurrencyChanged);
	}

	TrackedComponent.Reset();
}

void UInventoryDebugSubsystem::OnItemAdded(const FInventoryEntry& Entry)
{
	RefreshSnapshot();
}

void UInventoryDebugSubsystem::OnItemRemoved(const FGuid& InstanceID)
{
	RefreshSnapshot();
}

void UInventoryDebugSubsystem::OnItemChanged(const FInventoryEntry& Entry)
{
	RefreshSnapshot();
}

void UInventoryDebugSubsystem::OnCurrencyChanged(FGameplayTag CurrencyType, int32 NewBalance)
{
	RefreshSnapshot();
}

void UInventoryDebugSubsystem::SetReconciliationReport(const TArray<FReconciliationDiscrepancy>& Report)
{
	LastReconciliationReport = Report;
	UE_LOG(LogVault, Log, TEXT("DebugSubsystem: Reconciliation report updated with %d discrepancies"),
		Report.Num());
}

void ULocalEconomyConfigProvider::AsyncFetchConfig(FOnEconomyConfigLoaded OnComplete)
{
	CachedConfig = FVaultEconomyConfig();
	CachedConfig.ConfigVersion = 1;

	const UVaultSettings* Settings = UVaultSettings::Get();

	int32 LootEntryCount = 0;
	int32 RecipeCount = 0;
	int32 ParamCount = 0;

	// ── Load Loot Tables from DataTable ─────────────
	// Each row is one loot entry; rows sharing the same LootTableTag form a single table.
	if (Settings && !Settings->LootTablesDataTable.IsNull())
	{
		UDataTable* LootDT = Settings->LootTablesDataTable.LoadSynchronous();
		if (IsValid(LootDT))
		{
			TArray<FLootTableRow*> Rows;
			LootDT->GetAllRows<FLootTableRow>(TEXT("LocalEconomyConfigProvider"), Rows);

			for (const FLootTableRow* Row : Rows)
			{
				if (!Row || !Row->LootTableTag.IsValid()) continue;

				FLootEntry Entry;
				Entry.ItemDef = Row->ItemDef;
				Entry.MinQuantity = Row->MinQuantity;
				Entry.MaxQuantity = Row->MaxQuantity;
				Entry.Weight = Row->Weight;

				// Group en

const FVaultEconomyConfig& ULocalEconomyConfigProvider::GetCachedConfig() const
{
	return CachedConfig;
}

int32 ULocalEconomyConfigProvider::GetConfigVersion() const
{
	return CachedConfig.ConfigVersion;
}

bool UItemExpirationSubsystem::ShouldCreateSubsystem(UObject* Outer) const
{
	const UWorld* World = Cast<UWorld>(Outer);
	if (!World) return false;
	return World->GetNetMode() != NM_Client;
}

void UItemExpirationSubsystem::Initialize(FSubsystemCollectionBase& Collection)
{
	Super::Initialize(Collection);

	const UVaultSettings* Settings = UVaultSettings::Get();
	const float Interval = Settings ? Settings->ExpirationSweepIntervalSeconds : 60.0f;

	if (GetWorld())
	{
		GetWorld()->GetTimerManager().SetTimer(
			SweepTimerHandle,
			this,
			&UItemExpirationSubsystem::RunExpirationSweep,
			Interval,
			true);
	}

	UE_LOG(LogVault, Display, TEXT("ItemExpirationSubsystem initialized. Sweep interval: %.0fs"), Interval);
}

void UItemExpirationSubsystem::Deinitialize()
{
	if (GetWorld())
	{
		GetWorld()->GetTimerManager().ClearTimer(SweepTimerHandle);
	}
	Super::Deinitialize();
}

void UItemExpirationSubsystem::RunExpirationSweep()
{
	const UVaultSettings* Settings = UVaultSettings::Get();
	if (!Settings) return;

	const FDateTime Now = FDateTime::UtcNow();
	const FTimespan WarningThreshold = FTimespan::FromMinutes(Settings->NearExpiryWarningMinutes);

	int32 ExpiredCount = 0;
	int32 WarningCount = 0;

	// Iterate all inventory components in the world
	for (TObjectIterator<UInventoryManagerComponent> It; It; ++It)
	{
		UInventoryManagerComponent* Comp = *It;
		if (!IsValid(Comp) || !Comp->GetOwner() || Comp->GetOwnerRole() != ROLE_Authority)
		{
			continue;
		}

		// Collect expired items (iterate backwards since we may remove)
		TArray<FGuid> ToRemove;
		for (const FInventoryEntry& Entry : Comp->InventoryArray.Entries)
		{
			if (!Entry.HasExpiry()) continue;

			if (Entry.IsExpired())
			{
				ToRemove.Add(Entry.InstanceID);
			}
			else if ((Entry.ExpiresAtUTC - Now) < WarningThreshold)
			{
				// Near-expiry warning — fire once per item
				if (!WarnedIns

FPrimaryAssetId UItemTransformationRule::GetPrimaryAssetId() const
{
	return FPrimaryAssetId(TEXT("TransformationRule"), GetFName());
}

bool UMailSubsystem::ShouldCreateSubsystem(UObject* Outer) const
{
	const UWorld* World = Cast<UWorld>(Outer);
	return World && World->GetNetMode() != NM_Client;
}

void UMailSubsystem::Initialize(FSubsystemCollectionBase& Collection)
{
	Super::Initialize(Collection);
	if (GetWorld())
	{
		GetWorld()->GetTimerManager().SetTimer(
			ExpirationTimerHandle, this, &UMailSubsystem::CleanupExpiredMail, 300.0f, true);
	}
	AsyncLoadMailStore();
	UE_LOG(LogVault, Display, TEXT("MailSubsystem initialized."));
}

FGameplayTag UMailSubsystem::SendMail(const FMailMessage& Message)
{
	FMailMessage Msg = Message;
	Msg.MessageID = FGuid::NewGuid();
	Msg.SentAtUTC = FDateTime::UtcNow();
	if (Msg.ExpiresAtUTC.GetTicks() == 0)
	{
		Msg.ExpiresAtUTC = FDateTime::UtcNow() + FTimespan::FromDays(30);
	}
	if (Msg.IdempotencyKey.IsEmpty())
	{
		Msg.IdempotencyKey = Msg.MessageID.ToString();
	}

	// Check idempotency
	if (UsedIdempotencyKeys.Contains(Msg.IdempotencyKey))
	{
		return VaultTags::Validation_Error_AlreadyClaimed;
	}

	MailStore.Add(Msg);
	AsyncSaveMailStore();
	UE_LOG(LogVault, Log, TEXT("Mail sent: From=%s To=%s Subject=%s"),
		*Msg.SenderID, *Msg.RecipientID, *Msg.Subject.ToString());

	return VaultTags::Validation_Success;
}

TArray<FMailMessage> UMailSubsystem::GetMailbox(const FString& RecipientID) const
{
	TArray<FMailMessage> Result;
	for (const FMailMessage& Msg : MailStore)
	{
		if (Msg.RecipientID == RecipientID && !Msg.bClaimed)
		{
			Result.Add(Msg);
		}
	}
	return Result;
}

FGameplayTag UMailSubsystem::ClaimAttachments(const FGuid& MessageID, APlayerController* Recipient)
{
	FMailMessage* Msg = MailStore.FindByPredicate([&MessageID](const FMailMessage& M)
	{
		return M.MessageID == MessageID;
	});

	if (!Msg) return VaultTags::Validation_Error_ItemNotFound;
	if (Msg->bClaimed) return VaultTags::Validation_Error_AlreadyClaimed;

	UInventoryManagerComponent* Comp = Recipient->GetPawn()
		? Recipient->GetPawn()->FindComponentByClass<UInventoryManagerComponent>()
		: nullptr;
	if (!Comp) return VaultTags::Validation_Error_NotOwner;

	// Transfer item attachments
	for (const FMailAttachment& Att : Msg->Attachments)
	{
		if (IsValid(Att.ItemDef.Get()))
		{
			Comp->Authority_AddItem(Att.ItemDef, Att.Quantity, Att.InitialTags);
		}
	}

	// Transfer currency attachments
	for (const auto& Pair : Msg->CurrencyAttachments)
	{
		Comp->Authority_AddCurrency(Pair.Key, Pair.Value);
	}

	Msg->bClaimed = true;
	UsedIdempotencyKeys.Add(Msg->IdempotencyKey);
	AsyncSaveMail

void UMailSubsystem::DeleteMessage(const FGuid& MessageID)
{
	const int32 Removed = MailStore.RemoveAll([&MessageID](const FMailMessage& M)
	{
		return M.MessageID == MessageID && M.bClaimed;
	});

	if (Removed > 0)
	{
		AsyncSaveMailStore();
	}
}

FGameplayTag UMailSubsystem::GrantReward(
	const FString& RecipientID, const FString& RewardKey,
	const TArray<FMailAttachment>& Items, const TMap<FGameplayTag, int32>& Currency,
	const FString& SenderID)
{
	// Idempotency check
	if (UsedIdempotencyKeys.Contains(RewardKey))
	{
		UE_LOG(LogVault, Log, TEXT("GrantReward: RewardKey=%s already claimed, skipping."), *RewardKey);
		return VaultTags::Validation_Error_AlreadyClaimed;
	}

	FMailMessage Msg;
	Msg.SenderID = SenderID;
	Msg.RecipientID = RecipientID;
	Msg.Subject = FText::FromString(TEXT("Reward Delivery"));
	Msg.Attachments = Items;
	Msg.CurrencyAttachments = Currency;
	Msg.IdempotencyKey = RewardKey;

	return SendMail(Msg);
}

void UMailSubsystem::CleanupExpiredMail()
{
	const FDateTime Now = FDateTime::UtcNow();
	const int32 Removed = MailStore.RemoveAll([&Now](const FMailMessage& M)
	{
		return M.ExpiresAtUTC.GetTicks() > 0 && Now > M.ExpiresAtUTC && !M.bClaimed;
	});

	if (Removed > 0)
	{
		UE_LOG(LogVault, Log, TEXT("Cleaned up %d expired unclaimed mail messages."), Removed);
		AsyncSaveMailStore();
	}
}

void UMailSubsystem::AsyncSaveMailStore()
{
	UWorld* World_Local = GetWorld();
	UGameInstance* GI = World_Local ? World_Local->GetGameInstance() : nullptr;
	UVaultStorageManager* SM = GI ? GI->GetSubsystem<UVaultStorageManager>() : nullptr;
	if (SM == nullptr) return;

	TScriptInterface<IInventoryStorageProvider> Provider = SM->GetActiveProvider();
	if (!Provider.GetObject()) return;

	// Serialize mail store to JSON
	TSharedRef<FJsonObject> Root = MakeShared<FJsonObject>();

	TArray<TSharedPtr<FJsonValue>> MessagesArray;
	for (const FMailMessage& Msg : MailStore)
	{
		TSharedRef<FJsonObject> MsgObj = MakeShared<FJsonObject>();
		MsgObj->SetStringField(TEXT("MessageID"), Msg.MessageID.ToString());
		MsgObj->SetStringField(TEXT("SenderID"), Msg.SenderID);
		MsgObj->SetStringField(TEXT("RecipientID"), Msg.RecipientID);
		MsgObj->SetStringField(TEXT("Subject"), Msg.Subject.ToString());
		MsgObj->SetStringField(TEXT("Body"), Msg.Body.ToString());
		MsgObj->SetStringField(TEXT("SentAtUTC")

void UMailSubsystem::AsyncLoadMailStore()
{
	UWorld* World_Local = GetWorld();
	UGameInstance* GI = World_Local ? World_Local->GetGameInstance() : nullptr;
	UVaultStorageManager* SM = GI ? GI->GetSubsystem<UVaultStorageManager>() : nullptr;
	if (SM == nullptr) return;

	TScriptInterface<IInventoryStorageProvider> Provider = SM->GetActiveProvider();
	if (!Provider.GetObject()) return;

	// Dynamic delegates cannot BindLambda — use an unbound delegate.
	// The load callback will fire on the game thread. For now, the mail store
	// starts empty each session and is populated by incoming SendMail/GrantReward calls.
	// Full deserialization from storage is deferred to a UFUNCTION callback approach.
	FOnStorageLoadComplete OnComplete;
	Provider->AsyncLoad(TEXT("System_Mail"), OnComplete);

	UE_LOG(LogVault, Log, TEXT("MailSubsystem: AsyncLoadMailStore dispatched for System_Mail"));
}

TArray<FGameplayTag> UMailSubsystem::BulkGrantRewards(
	const TArray<FString>& RecipientIDs,
	const FString& RewardKey,
	const TArray<FMailAttachment>& Items,
	const TMap<FGameplayTag, int32>& Currency,
	const FString& SenderID)
{
	TArray<FGameplayTag> Results;
	Results.Reserve(RecipientIDs.Num());

	for (int32 i = 0; i < RecipientIDs.Num(); ++i)
	{
		// Each grant gets a unique idempotency key: BaseKey_Index
		const FString UniqueKey = FString::Printf(TEXT("%s_%d"), *RewardKey, i);
		Results.Add(GrantReward(RecipientIDs[i], UniqueKey, Items, Currency, SenderID));
	}

	return Results;
}

FGameplayTag UMailSubsystem::ProcessWebhookPayload(const FString& JSONPayload)
{
	TSharedPtr<FJsonObject> JsonObj;
	const TSharedRef<TJsonReader<>> Reader = TJsonReaderFactory<>::Create(JSONPayload);

	if (!FJsonSerializer::Deserialize(Reader, JsonObj) || !JsonObj.IsValid())
	{
		UE_LOG(LogVault, Warning, TEXT("MailSubsystem: Malformed webhook JSON payload"));
		return FGameplayTag(VaultTags::Validation_Error_MalformedPayload);
	}

	const FString Recipient = JsonObj->GetStringField(TEXT("recipient"));
	const FString RewardKey = JsonObj->GetStringField(TEXT("reward_key"));
	const FString Sender = JsonObj->HasField(TEXT("sender"))
		? JsonObj->GetStringField(TEXT("sender"))
		: TEXT("System_Webhook");

	if (Recipient.IsEmpty() || RewardKey.IsEmpty())
	{
		UE_LOG(LogVault, Warning, TEXT("MailSubsystem: Webhook missing recipient or reward_key"));
		return FGameplayTag(VaultTags::Validation_Error_MalformedPayload);
	}

	// Parse items array (simplified — real implementation would resolve I

int32 UMailSubsystem::GetUnclaimedMailCount(const FString& RecipientID) const
{
	int32 Count = 0;
	for (const FMailMessage& Msg : MailStore)
	{
		if (Msg.RecipientID == RecipientID && !Msg.bClaimed)
		{
			++Count;
		}
	}
	return Count;
}