// 1. Create ViewModel
class CounterViewModel extends ObservableObject {
  final counter = ObservableProperty<int>(0);
  late final incrementCommand = RelayCommand(() => counter.value++);
}

// 2. Provide ViewModel with FairyScope
void main() => runApp(
  FairyScope(
    viewModel: (_) => CounterViewModel(),
    child: MyApp(),
  ),
);

// 3. Bind UI
Bind<CounterViewModel, int>(
  bind: (vm) => vm.counter,
  builder: (context, value, update) => Text('$value'),
)

Command<CounterViewModel>(
  command: (vm) => vm.incrementCommand,
  builder: (context, execute, canExecute, isRunning) =>
    ElevatedButton(
      onPressed: canExecute ? execute : null,
      child: Text('Increment'),
    ),
)

class UserViewModel extends ObservableObject {
  final name = ObservableProperty<String>('');
  final age = ObservableProperty<int>(0);
  
  void updateName(String newName) {
    name.value = newName;  // UI automatically rebuilds
  }
}

class TodoViewModel extends ObservableObject {
  final todos = ObservableProperty.list<Todo>([]);
  final cache = ObservableProperty.map<String, Data>({});
  final tags = ObservableProperty.set<String>({});
  
  void addTodo(Todo todo) {
    todos.value.add(todo);       // ✅ Triggers rebuild
    cache.value[todo.id] = todo; // ✅ Triggers rebuild
  }
}

class CartViewModel extends ObservableObject {
  final price = ObservableProperty<double>(10.0);
  final quantity = ObservableProperty<int>(2);
  
  late final total = ComputedProperty<double>(
    () => price.value * quantity.value,
    [price, quantity],  // Dependencies
    this,               // Parent for auto-disposal
  );
}

late final incrementCommand = RelayCommand(
  () => count.value++,
  canExecute: () => count.value < 100,
);

late final fetchCommand = AsyncRelayCommand(
  () async => data.value = await api.fetchItems(),
);
// fetchCommand.isRunning tracks loading state automatically

// Sync with parameter
late final deleteCommand = RelayCommand.param<String>(
  (id) => todos.value.removeWhere((t) => t.id == id),
  canExecute: (id) => id.isNotEmpty,
);

// Async with parameter
late final loadCommand = AsyncRelayCommand.param<String>(
  (userId) async => user.value = await api.fetchUser(userId),
);

late final saveCommand = AsyncRelayCommand(
  _save,
  onError: (e, stack) => error.value = 'Save failed: $e',
);

MyViewModel() {
  _dispose = selected.propertyChanged(() {
    deleteCommand.notifyCanExecuteChanged();
  });
}

// Two-way binding
Bind<UserViewModel, String>(
  bind: (vm) => vm.name,  // Returns property
  builder: (context, value, update) => TextField(
    controller: TextEditingController(text: value),
    onChanged: update,
  ),
)

// One-way binding
Bind<UserViewModel, String>(
  bind: (vm) => vm.name.value,  // Returns value
  builder: (context, value, _) => Text(value),
)

Bind.viewModel<UserViewModel>(
  builder: (context, vm) => Column(
    children: [
      Text(vm.firstName.value),
      Text(vm.lastName.value),
    ],
  ),
)

Command<MyViewModel>(
  command: (vm) => vm.saveCommand,
  builder: (context, execute, canExecute, isRunning) {
    if (isRunning) return CircularProgressIndicator();
    return ElevatedButton(
      onPressed: canExecute ? execute : null,
      child: Text('Save'),
    );
  },
)

Command.param<TodoViewModel, String>(
  command: (vm) => vm.deleteCommand,
  builder: (context, execute, canExecute, isRunning) => IconButton(
    onPressed: canExecute(todoId) ? () => execute(todoId) : null,
    icon: Icon(Icons.delete),
  ),
)

FairyScope(
  viewModel: (_) => ProfileViewModel(),
  child: ProfilePage(),
)

// Access in widgets
final vm = Fairy.of<UserViewModel>(context);

FairyScope(
  viewModel: (locator) => ProfileViewModel(
    api: locator.get<ApiService>(),       // Global (FairyLocator)
    appVM: locator.get<AppViewModel>(),   // Parent scope
  ),
  child: ProfilePage(),
)

// Multiple VMs can depend on each other
FairyScope(
  viewModels: [
    (_) => UserViewModel(),
    (locator) => SettingsViewModel(
      userVM: locator.get<UserViewModel>(),  // Same scope
    ),
  ],
  child: DashboardPage(),
)

void main() {
  FairyLocator.registerSingleton<ApiService>(ApiService());
  runApp(MyApp());
}

showDialog(
  context: context,
  builder: (_) => FairyBridge(
    context: context,
    child: AlertDialog(content: /* Bind widgets work here */),
  ),
);

tags.value = ['flutter', 'dart'];           // No rebuild (same contents)
tags.value = ['flutter', 'dart', 'web'];    // Rebuilds (different)
matrix.value = [[1, 2], [3, 4]];            // No rebuild (nested equality!)

class User {
  final String id;
  final String name;
  
  @override
  bool operator ==(Object other) => other is User && id == other.id;
  
  @override
  int get hashCode => id.hashCode;
}

class DashboardViewModel extends ObservableObject {
  final _userVM = UserViewModel();
  VoidCallback? _listener;
  
  DashboardViewModel() {
    _listener = _userVM.name.propertyChanged(() {
      print('User name changed: ${_userVM.name.value}');
    });
  }
  
  @override
  void dispose() {
    _listener?.call();
    _userVM.dispose();
    super.dispose();
  }
}

late final displayName = ComputedProperty<String>(
  () => '${_userVM.name.value} (${_userVM.email.value})',
  [_userVM.name, _userVM.email],
  this,
);

class User {
  final String id;
  final List<String> tags;
  
  @override
  bool operator ==(Object other) =>
      other is User && id == other.id && Equals.listEquals(tags, other.tags);
  
  @override
  int get hashCode => id.hashCode ^ Equals.listHash(tags);
}

class MyService with Disposable {
  void doSomething() {
    throwIfDisposed();  // Throws if disposed
  }
}

final _disposables = DisposableBag();
_disposables.add(property.propertyChanged(() => /* ... */));
_disposables.dispose();  // Disposes all

@override
void dispose() {
  childVM.dispose();
  super.dispose();
}

// ❌ MEMORY LEAK
viewModel.propertyChanged(() { });

// ✅ CORRECT
final dispose = viewModel.propertyChanged(() { });
// Later: dispose();

late final selectCommand = AsyncRelayCommand.param<String>(
  (id) async {
    selectedId.value = id;
    await api.saveSelection(id);  // Slow — blocks next tap
  },
);

late final selectCommand = AsyncRelayCommand.param<String>(
  (id) async {
    selectedId.value = id;             // Instant UI update
    unawaited(_persistSelection(id));  // Fire-and-forget slow work
  },
);

test('counter increments', () {
  final vm = CounterViewModel();
  vm.incrementCommand.execute();
  expect(vm.counter.value, 1);
  vm.dispose();
});