// ❌ Traditional approach - tight coupling
public class StoreView : MonoBehaviour 
{
    public StoreManager storeManager;  // Direct reference
    
    void OnUpgradeClick() 
    {
        storeManager.UpgradeStore(storeId);  // Tightly coupled
    }
}

// ✅ Clean EventBus approach - decoupled
public class StoreView : MonoBehaviour 
{
    void OnUpgradeClick() 
    {
        eventBus.Publish(new StoreUpgradeRequested(storeId));  // Decoupled
    }
}

// Only the specific store receives this event
using (EventContext.SetContext("store_123"))
{
    eventBus.Subscribe<StoreUpdated>(OnStoreUpdated);
}

eventBus.Publish(new StoreUpdated("store_123")); // Only goes to store_123

// ✅ This works - same layer
appEventBus.Publish(new StoreUIUpdated());

// ❌ This won't compile - cross-layer
appEventBus.Publish(new StoreDomainEvent()); // Compile error!

using CleanEventBus.Application;
using CleanEventBus.Application.Events;

// Define your events
[TargetedEvent("StoreId")]
public class StoreUpgraded : BaseApplicationEvent
{
    public string StoreId { get; set; }
    public int NewLevel { get; set; }
    public decimal Cost { get; set; }
}

// In your View (UI)
public class StoreView : MonoBehaviour
{
    [SerializeField] private string storeId;
    private IEventBusApplication eventBus;
    
    void Start()
    {
        eventBus = new ApplicationEventBus();
        
        // Subscribe to events for this specific store
        using (EventContext.SetContext(storeId))
        {
            eventBus.Subscribe<StoreUpgraded>(OnStoreUpgraded);
        }
    }
    
    void OnUpgradeButtonClick()
    {
        // Publish upgrade request
        eventBus.Publish(new StoreUpgradeRequested(storeId));
    }
    
    void OnStoreUpgraded(StoreUpgraded evt)
    {
        // Only this store receives this event!
        ShowUpgradeEffect(evt.NewLevel);
        UpdateUI();
    }
}

// In your ViewModel/UseCase
public class UpgradeStoreUseCase
{
    private readonly IEventBusApplication eventBus;
    
    public UpgradeStoreUseCase(IEventBusApplication eventBus)
    {
        this.eventBus = eventBus;
        eventBus.Subscribe<StoreUpgradeRequested>(HandleUpgrade);
    }
    
    void HandleUpgrade(StoreUpgradeRequested request)
    {
        // Business logic here
        var store = storeService.UpgradeStore(request.StoreId);
        
        // Notify UI of success
        eventBus.Publish(new StoreUpgraded(request.StoreId)
        {
            NewLevel = store.Level,
            Cost = store.UpgradeCost
        });
    }
}

// Domain Layer - Business Events
using CleanEventBus.Domain;
using CleanEventBus.Domain.Events;

public class PlayerLeveledUp : BaseDomainEvent
{
    public string PlayerId { get; set; }
    public int NewLevel { get; set; }
    public int ExperienceGained { get; set; }
}

// Application Layer - UI Coordination
using CleanEventBus.Application;
using CleanEventBus.Application.Events;

[TargetedEvent("PlayerId")]
public class PlayerUIUpdateRequired : BaseApplicationEvent
{
    public string PlayerId { get; set; }
    public int Level { get; set; }
    public int Experience { get; set; }
    public List<string> UnlockedFeatures { get; set; }
}

// Usage in Domain Service
public class PlayerService
{
    private readonly IEventBusDomain domainEventBus;
    
    public void GainExperience(string playerId, int experience)
    {
        // Domain logic...
        
        if (playerLeveledUp)
        {
            domainEventBus.Publish(new PlayerLeveledUp 
            { 
                PlayerId = playerId,
                NewLevel = newLevel,
                ExperienceGained = experience
            });
        }
    }
}

// Application Layer - Coordinate between Domain and UI
public class PlayerApplicationService
{
    private readonly IEventBusDomain domainEventBus;
    private readonly IEventBusApplication appEventBus;
    
    public PlayerApplicationService(IEventBusDomain domainEventBus, IEventBusApplication appEventBus)
    {
        this.domainEventBus = domainEventBus;
        this.appEventBus = appEventBus;
        
        // Listen to domain events and coordinate UI updates
        domainEventBus.Subscribe<PlayerLeveledUp>(OnPlayerLeveledUp);
    }
    
    void OnPlayerLeveledUp(PlayerLeveledUp domainEvent)
    {
        // Coordinate UI update
        appEventBus.Publish(new PlayerUIUpdateRequired(domainEvent.PlayerId)
        {
            Level = domainEvent.NewLevel,
            Experience = GetPlayerExperience(domainEvent.PlayerId),
            UnlockedFeatures = GetUnlockedFeatures(domainEvent.PlayerId)
        });
    }
}

// You have 10 store prefabs in your scene
// Each one has a unique storeId: "store_1", "store_2", etc.

// When you publish this event:
eventBus.Publish(new StoreUpgraded("store_5") { NewLevel = 3 });

// Only the store with storeId "store_5" will receive it
// The other 9 stores won't be notified - efficient!

// Global event - all subscribers receive it
public class GamePaused : BaseApplicationEvent
{
    public bool IsPaused { get; set; }
}

eventBus.Publish(new GamePaused { IsPaused = true });
// All UI elements pause

// Targeted event - only specific subscriber receives it  
[TargetedEvent("DialogId")]
public class DialogClosed : BaseApplicationEvent
{
    public string DialogId { get; set; }
    public DialogResult Result { get; set; }
}

eventBus.Publish(new DialogClosed("settings_dialog") { Result = DialogResult.OK });
// Only the settings dialog handler receives this

// Each layer has its own event bus - no mixing!
using CleanEventBus.Domain;     // Business logic events IF needed
using CleanEventBus.Application; // For use cases publish events
using CleanEventBus.Adapter;   // For view models, controllers, presenters

// ✅ This compiles
domainEventBus.Publish(new PlayerLeveledUp());

// ❌ This doesn't compile - prevents architectural violations
domainEventBus.Publish(new UIButtonClicked()); // Compile error!

// Easy to mock and test
var mockEventBus = new Mock<IEventBusApplication>();
var useCase = new MyUseCase(mockEventBus.Object);

// Verify events were published
mockEventBus.Verify(x => x.Publish(It.IsAny<MyEvent>()), Times.Once);

// ✅ Good
public class StoreUpgradeCompleted : BaseApplicationEvent

// ❌ Less clear  
public class StoreEvent : BaseApplicationEvent