Advanced Flutter,
Dart & design patterns

abstract class Animal {
  final String name;
  const Animal(this.name);
}

class Dog extends Animal {
  const Dog(super.name);
  void bark() => print('Woof!');
}

// 1. Covariance: استخدام نوع أكثر تحديداً بدلاً من نوع عام
abstract class AnimalTrainer {
  // استخدام covariant يخبر Dart بالسماح بنوع فرعي وارث من Animal
  void train(covariant Animal animal);
}

class DogTrainer extends AnimalTrainer {
  @override
  void train(Dog animal) {
    animal.bark(); // هنا نقدر نستخدم دوال الـ Dog بأمان
  }
}

// 2. Contravariance: استخدام دالة عامة في سياق خاص
typedef DogHandler = void Function(Dog dog);

void processDogEvent(Dog dog, DogHandler handler) {
  handler(dog);
}

// دالة عامة تتعامل مع أي Animal
void generalAnimalHandler(Animal animal) {
  print('Handling animal: ${animal.name}');
}

void main() {
  final dog = Dog('Buddy');
  
  // Contravariance: الدالة العامة (Animal -> void) 
  // مقبولة وتعمل بنجاح في مكان الدالة الخاصة (Dog -> void)
  processDogEvent(dog, generalAnimalHandler);
}

abstract class Animal {
  final String name;
  const Animal(this.name);
  void makeSound();
}

class Dog extends Animal {
  const Dog(super.name);
  @override
  void makeSound() => print('Woof!');
}

class Cat extends Animal {
  const Cat(super.name);
  @override
  void makeSound() => print('Meow!');
}

// T extends Animal: يقبل Animal أو أي نوع وارث منه فقط
class Box<T extends Animal> {
  final T item;
  const Box(this.item);

  void inspect() {
    print('Box contains: ${item.name}');
    item.makeSound(); // استدعاء آمن تماماً وقت الـ Compile time
  }
}

void main() {
  final dogBox = Box(Dog('Buddy')); // صحيح
  dogBox.inspect();

  final catBox = Box(Cat('Milo'));  // صحيح
  catBox.inspect();

  // Box<String>('Text'); // Compile Error: String does not extend Animal
}

abstract class Animal {
  final String name;
  const Animal(this.name);
}

// Runner on Animal: الـ Mixin متاح فقط للكلاسات الوارثة من Animal
mixin Runner on Animal {
  void run() => print('$name is running!');
}

mixin Logger {
  void log(String msg) => print('[LOG]: $msg');
}

// دمج أكثر من مكسن
class Dog extends Animal with Runner, Logger {
  Dog(super.name);
}

// حل مشكلة Diamond Problem عبر الـ Linearization
mixin A {
  void execute() => print('Executed from A');
}

mixin B {
  void execute() => print('Executed from B');
}

// في الـ Linearization: B تأتي بعد A لذا فإن B هي التي تنفذ
class Service with A, B {}

void main() {
  final dog = Dog('Rex');
  dog.run(); // من Runner
  dog.log('Online'); // من Logger

  final service = Service();
  service.execute(); // يطبع: "Executed from B" (Linearization)
}

// 1. Extension: إضافة دالة جديدة للـ String بدون تعديل الكود الأساسي
extension StringFormatting on String {
  String capitalize() =>
      isEmpty ? this : '${this[0].toUpperCase()}${substring(1)}';
}

// 2. Extension Type: Zero-Cost Type Wrapper
extension type const UserId(String id) {
  bool get isValid => id.isNotEmpty;
}

extension type const ProductId(String id) {}

void deleteUser(UserId userId) {
  print('User deleted: ${userId.id}');
}

void main() {
  print('flutter'.capitalize()); // يطبع: Flutter

  final user = UserId('usr_101');
  final product = ProductId('prod_909');

  deleteUser(user); // يعمل بنجاح

  // deleteUser(product);
  // Error: The argument type 'ProductId' can't be assigned to parameter 'UserId'
  // حماية كاملة وقت الـ Compile time بدون أي تكلفة Object في الـ Memory!
}

import 'dart:isolate';
import 'dart:convert';

// 1. استخدام Isolate.run للعمليات السريعة والمباشرة
Future<List<String>> parseCatalog(String rawJson) async {
  return await Isolate.run(() {
    final List<dynamic> list = jsonDecode(rawJson);
    return list.map((e) => e.toString()).toList();
  });
}

// 2. التواصل ثنائي الاتجاه (Two-Way Communication عبر Ports)
void workerTask(SendPort mainSendPort) {
  final workerReceivePort = ReceivePort();
  // إرسال الـ Port الخاص بالـ Worker للـ Main Isolate
  mainSendPort.send(workerReceivePort.sendPort);

  workerReceivePort.listen((message) {
    print('Worker received: $message');
    // إرسال النتيجة بعد المعالجة
    mainSendPort.send('Processed: $message');
  });
}

void main() async {
  // استقبال أول رسالة تحتوي على SendPort الخاص بالـ Worker
  final mainReceivePort = ReceivePort();
  await Isolate.spawn(workerTask, mainReceivePort.sendPort);

  final workerSendPort = await mainReceivePort.first as SendPort;
  workerSendPort.send('Heavy Calculation Job');
}

import 'dart:async';

class Message {
  final String text;
  final DateTime timestamp;
  Message(this.text) : timestamp = DateTime.now();
}

// 1. توليد Stream باستخدام async* و yield
Stream<Message> messageStream() async* {
  for (int i = 1; i <= 3; i++) {
    await Future.delayed(const Duration(seconds: 1));
    yield Message('Message #$i');
  }
}

void main() async {
  // 2. Single Subscription Stream (مستمع واحد)
  final singleStream = messageStream();
  
  singleStream.listen(
    (message) => print('Single: ${message.text} at ${message.timestamp}'),
    onError: (error) => print('Error: $error'),
    onDone: () => print('Stream completed!'),
  );

  // 3. Broadcast Stream (أكثر من مستمع)
  final controller = StreamController<int>.broadcast();

  // المشاهد الأول
  controller.stream.listen((val) => print('Viewer 1: $val'));

  // المشاهد الثاني
  controller.stream.listen((val) => print('Viewer 2: $val'));

  controller.add(100);
  controller.add(200);
  await controller.close();
}

import 'dart:async';

// 1. sync* Generator (Lazy Synchronous Iterable)
Iterable<int> countUpTo(int max) sync* {
  for (int i = 1; i <= max; i++) {
    print('Generating synchronous value: $i');
    yield i; // يُنتج القيمة فقط عند طلب الـ Consumer للـ next
  }
}

// 2. async* Generator (Asynchronous Event Stream)
Stream<int> fetchPages() async* {
  for (int page = 1; page <= 3; page++) {
    await Future.delayed(const Duration(milliseconds: 500)); // محاكاة جلب API
    yield page; // ينتج حدث جديد في الـ Stream
  }
}

// 3. yield* Delegation (دمج تسلسل Cache ثم API)
Stream<String> getUserFeed() async* {
  yield* getCachedFeed(); // تفويض أحداث الـ Cache أولاً
  yield* getRemoteFeed(); // ثم تفويض أحداث الـ API
}

Stream<String> getCachedFeed() async* {
  yield 'Cache Item 1';
}

Stream<String> getRemoteFeed() async* {
  await Future.delayed(const Duration(milliseconds: 300));
  yield 'Live Item 2';
}

void main() async {
  // استهلاك sync* عبر for-in (يبدأ التوليد فعلياً مع بداية الـ Loop فقط)
  print('--- sync* Iterable ---');
  for (final num in countUpTo(2)) {
    print('Consumed: $num');
  }

  // استهلاك async* عبر await for
  print('\n--- async* Stream ---');
  await for (final page in fetchPages()) {
    print('Loaded page: $page');
  }

  // استهلاك الـ Delegation عبر yield*
  print('\n--- yield* Delegation ---');
  await for (final feed in getUserFeed()) {
    print('Feed: $feed');
  }
}