[MenuItem("Assets/UniGame/ViewSystem/Create ViewSystem")]

void ExampleFunc(SkinId largeDemoView) {
  await gameViewSystem.OpenWindow<DemoView>(ViewModel, "SmallDemoView");
  await gameViewSystem.OpenWindow<DemoView>(ViewModel, largeDemoView);
}

public class ZenjectViewFactoryProvider : IViewFactoryProvider
{
    public static DiContainer Container { get; set; }
}

//ZenjectViewFactory example
public class ZenjectViewFactory  : IViewFactory
{
    public ViewFactory _viewFactory;
    public DiContainer _container;
    
    public ZenjectViewFactory(DiContainer container,AsyncLazy readyStatus, IViewResourceProvider viewResourceProvider)
    {
        _container = container;
        _viewFactory = new ViewFactory(readyStatus, viewResourceProvider);
    }
    
    public async UniTask<IView> Create(string viewId, 
        string skinTag = "", 
        Transform parent = null, 
        string viewName = null,
        bool stayWorldPosition = false)
    {
        var view = await _viewFactory.Create(viewId, skinTag, parent, viewName, stayWorldPosition);
        if (view == null || view.GameObject == null) return view;
        var viewObject = view.GameObject;
        
        _container.InjectGameObject(viewObject);
        return view;
    }
}

public class HealthBarView : ViewBase<CharacterViewModel>
{
    [SerializeField] private Image healthFill;
    
    protected override UniTask OnInitialize(CharacterViewModel model)
    {
        this.Bind(model.CurrentHealth, UpdateHealthBar);
        return UniTask.CompletedTask;
    }

}

// RECOMMENDED: Using Bind extensions
this.Bind(model.Health, UpdateDisplay);

// ALTERNATIVE: Direct Rx approach (what Bind does internally)
model.Health
    .Subscribe(UpdateDisplay)
    .AddTo(LifeTime);

// Example: Character select screen with Bind extensions

public class CharacterDetailsView : ViewBase<CharacterViewModel>
{
    [SerializeField] private TextMeshProUGUI nameText;
    [SerializeField] private Slider healthSlider;
    
    protected override UniTask OnInitialize(CharacterViewModel model)
    {
        // RECOMMENDED: Using Bind extensions (auto-managed)
        this.Bind(model.Name, nameText)
            .Bind(model.Health, healthSlider);
        
        return UniTask.CompletedTask;
    }
}

// In controller code:
var character1ViewModel = new CharacterViewModel { Name = new("Hero") };
var character2ViewModel = new CharacterViewModel { Name = new("Villain") };

// User selects character 1
await detailsView.RegisterView(character1ViewModel);
// → OnInitialize() bound to character1 stats
// → Subscriptions connected to character1 data

// User selects character 2
await detailsView.RegisterView(character2ViewModel);
// → OnInitialize() called again
// → OLD subscriptions to character1 automatically → DISCONNECTED
// → NEW subscriptions to character2 → CREATED
// → No memory leak, no duplicate subscriptions

// ❌ WRONG - This leaks memory!
public void BadExample(CharacterViewModel model)
{
    model.Health.Subscribe(x => UpdateUI(x));  // Never unsubscribes!
    // If you call this 100 times with different models,
    // you'll have 100 active subscriptions
}

// ✅ CORRECT - Using Bind (fluent API)
public void GoodExampleWithBind(CharacterViewModel model)
{
    this.Bind(model.Health, UpdateUI);
    // Auto-managed lifetime, disconnects on model change
}

// RECOMMENDED: Using Bind extensions
this.Bind(view.SelectStatus(ViewStatus.Hidden), 
    v => Debug.Log($"{v.SourceName} is hidden"));

// ALTERNATIVE: Direct Rx approach
view.Status
    .Where(status => status == ViewStatus.Shown)
    .Subscribe(_ => Debug.Log("View is now visible"))
    .AddTo(lifeTime);

// ALTERNATIVE: Using SelectStatus helper
view.SelectStatus(ViewStatus.Hidden)
    .Subscribe(v => Debug.Log($"{v.SourceName} is hidden"))
    .AddTo(lifeTime);

public class MyView : ViewBase<MyViewModel>
{
    [SerializeField] private Button closeButton;
    
    protected override UniTask OnInitialize(MyViewModel model)
    {
        // Called right after model attachment
        // Status: None → Shown (transitioning)
        
        // Bind button to close command
        this.Bind(closeButton, model.CloseCommand);
        
        // Or with action
        this.Bind(closeButton, Close);
        
        return UniTask.CompletedTask;
    }
    
    protected override UniTask OnShowAction()
    {
        // Called when transitioning to Shown
        // Use for entrance animations
        return PlayEntranceAnimation();
    }
    
    protected override UniTask OnHideAction()
    {
        // Called when transitioning to Hidden  
        // Use for exit animations
        return PlayExitAnimation();
    }
}

// ✅ RECOMMENDED: Static lambda - zero allocation
// Compiler doesn't create display class for closure
this.Bind(model, purchaseStream, static (model, stream) => 
    stream.purchase.Execute(stream));

// ❌ Non-static lambda - closure allocation
// Compiler creates display class to capture variables
this.Bind(model, purchaseStream, (model, stream) => 
    stream.purchase.Execute(stream));

public class PurchaseView : ViewBase<PurchaseViewModel>
{
    [SerializeField] private Button purchaseButton;
    
    protected override UniTask OnInitialize(PurchaseViewModel model)
    {
        // Zero-allocation: static lambda combines two streams
        this.Bind(model, model.PurchaseStream, 
              static (purchaseData,viewModel) => viewModel.purchase.Execute(purchaseData));
        
        return UniTask.CompletedTask;
    }
}

// ✅ Direct method reference - simple binding, zero allocation
this.Bind(model.Health, UpdateUI);

// ✅ Static lambda - complex binding with multiple parameters, zero allocation
this.Bind(model, itemStream, static (item,m) => m.ProcessItem(item));

// ❌ Non-static lambda - allocates closure class
this.Bind(model, itemStream, (item,m) => model.ProcessItemAndReport(item));  
// Captures 'model' in display class - not needed

// Variant 1: View only + callback with data
view.BindData(model, dataStream, action);  // action receives: context

// Variant 2: View + Data + callback with both
view.BindData(model, dataStream, static x => ProcessData(x.Data, x.Source));

// Variant 3: View + Data + Stream value
view.BindData(model, dataStream, static x => x.Data.ProcessItem(x.Source, x.Value));

public class DetailsView : View<SomeViewModel>
{
    protected override UniTask OnInitialize(SomeViewModel model)
    {
        // Zero-allocation: combines stream + view context
        // x.Data = model, x.Source = this (view), x.Value = stream value
        this.BindData(model, model.Id, static x => x.Data.SomeMethod(x.Source))
            .BindData(model, model.Updated, static x => x.Data.SomeMethod(x.Source));
        
        return UniTask.CompletedTask;
    }
}

public class SomeViewModel : ViewModel
{
    public ReactiveProperty<int> Id { get; } = new();
    public ReactiveCommand<Unit> Updated { get; } = new();
}

public Button openChest;

[Serializable]
public class WindowViewModel : ViewModelBase
{
    public ReactiveCommand checkAction = new ReactiveCommand();
    public IReactiveCommand<Unit> ChestAction => checkAction;
}

protected override UniTask OnViewInitialize(WindowViewModel model)
{
    this.Bind(openChest,model.ChestAction);
    
    return UniTask.CompletedTask;
}

public Button openChest;

[Serializable]
public class WindowViewModel : ViewModelBase
{
    public ReactiveCommand checkAction = new ReactiveCommand();
    public IReactiveCommand<Unit> ChestAction => checkAction;
}

protected override UniTask OnViewInitialize(WindowViewModel model)
{
    this.Bind(model.ChestAction,openChest);
    
    return UniTask.CompletedTask;
}

[Serializable]
public class WindowViewModel : ViewModelBase
{
    public ReactiveProperty<string> label = new();
    public ReactiveProperty<string> value = new();
}

public TextMeshProUGUI label;
public TextMeshProUGUI value;

protected override UniTask OnViewInitialize(WindowViewModel model)
{
    this.Bind(model.label,label)
        .Bind(model.value,value);
    
    return UniTask.CompletedTask;
}