void main() {
  print('Hello, World!');
}

// Variables can be declared using the var or type name syntax

var age = 25; // inferred int created with var
int count = 0; // explicit int declaration
double pi = 3.14; // double
num value = 42; // generic numeric type
String name = 'Alice'; // single quotes
String message = "Hello, $name!"; // double quotes with string interpolation
bool isRaining = true; // booleans are declared using the bool keyword
dynamic dynamicVar = 'hello'; // dynamic type can hold any value and its type determined at runtime
final companyName = 'Acme Inc.'; // final keyword creates a variable that can be set only once
const PI = 3.14159; // const keyword creates a compile-time constant

// Arithmetic operators
var sum = 10 + 20; // addition
var difference = 40 - 30; // subtraction
var product = 2 * 5; // multiplication
var quotient = 15 / 3; // division
var remainder = 20 % 3; // modulus

// Comparison operators
var isEqual = (5 == 5); // equality
var notEqual = (5 != 6); // inequality
var greaterThan = (5 > 3); // greater than
var lessThan = (5 < 7); // less than
var greaterOrEqual = (5 >= 5); // greater than or equal to
var lessOrEqual = (5 <= 5); // less than or equal to

// Logical operators
var and = true && false; // logical and
var or = true || false; // logical or
var not = !true; // logical not

// Assignment operators
var x = 10; // simple assignment
x += 5; // addition assignment (same as x = x + 5)
x -= 2; // subtraction assignment (same as x = x - 2)
x *= 3; // multiplication assignment (same as x = x * 3)
x /= 2; // division assignment (same as x = x / 2)
x %= 4; // modulus assignment (same as x = x % 4)

// Conditional operator
var isEven = (x % 2 == 0) ? true : false; // if-else shorthand

// Single-line comments start with //
// This is a single-line comment

// Multi-line comments start with /* and end with */
/*
This is a multi-line comment
It can span multiple lines
*/

// Documentation comments are used to generate documentation for libraries, classes, functions, and variables
/// This is a documentation comment for a class.
/// It should describe what the class does and its properties and methods.
class MyClass {
  int myProperty;
  
  /// This is a documentation comment for a method.
  /// It should describe what the method does and its parameters.
  void myMethod(int param) {
    // method code here
  }
}

// Metadata provides additional information about the code to tools and other programs

// Metadata provides additional information about the code to tools and other programs

// Metadata can be added to classes, methods, variables, and parameters using the @ symbol

// Common metadata includes:
// - @deprecated: indicates that a method or variable is no longer recommended for use
// - @override: indicates that a method is intended to override a method from a superclass or interface
// - @immutable: indicates that a class or property is read-only
// - @proxy: indicates that a class should be treated as a dynamic proxy

@deprecated
void myDeprecatedFunction() {
  // deprecated function code here
}

class MyClass {
  @override
  void myMethod() {
    // method code here
  }
}

@immutable
class MyImmutableClass {
  final int myProperty;
  
  const MyImmutableClass(this.myProperty);
}

@proxy
class MyDynamicClass {
  // proxy code here
}

// Dart code is organized into libraries, which are collections of related code

// Libraries are defined using the 'library' keyword, followed by the name of the library

library my_library;

// Code from other libraries can be accessed using the 'import' keyword

import 'dart:math'; // import a core Dart library
import 'package:flutter/material.dart'; // import a package from pub.dev

// The 'as' keyword can be used to give an imported library a different name
import 'package:flutter/cupertino.dart' as cupertino;

// The 'show' and 'hide' keywords can be used to selectively import or hide parts of a library
import 'package:my_package/my_module.dart' show myFunction;
import 'package:my_package/my_module.dart' hide myPrivateFunction;

// Code can also be exported from a library using the 'export' keyword
export 'my_other_library.dart';

// Libraries can have a part directive to include source code from other files
part 'my_file.dart';

// Dart provides several ways to handle errors and exceptions

// Using try-catch blocks to handle exceptions
try {
  var result = 42 ~/ 0; // throws an IntegerDivisionByZeroException
} catch (e) {
  print("An exception occurred: $e"); // prints "An exception occurred: IntegerDivisionByZeroException"
}

// Using on clauses to handle specific exceptions
try {
  var result = 42 ~/ 0; // throws an IntegerDivisionByZeroException
} on IntegerDivisionByZeroException {
  print("Cannot divide by zero");
}

// Using finally clauses to execute code after try-catch blocks
try {
  var result = 42 ~/ 0; // throws an IntegerDivisionByZeroException
} catch (e) {
  print("An exception occurred: $e");
} finally {
  print("This code always runs");
}

// Using rethrow to propagate an exception to the calling function
void riskyFunction() {
  try {
    var result = 42 ~/ 0; // throws an IntegerDivisionByZeroException
  } catch (e) {
    // rethrows the exception to the calling function
    rethrow;
  }
}

// Using assert statements to check for errors during development
void printNumber(int number) {
  assert(number >= 0, "The number must be greater than or equal to zero");
  print(number);
}

// Dart is an object-oriented language, and classes are a fundamental building block

// Defining a class
class Person {
  String name;
  int age;

  // A constructor with named parameters
  Person({required this.name, required this.age});

  // A named constructor
  Person.fromJson(Map<String, dynamic> json) {
    name = json['name'];
    age = json['age'];
  }

  // A method that returns a string
  String greet() {
    return "Hello, my name is $name and I am $age years old";
  }
}

// Inheriting from a class
class Employee extends Person {
  String department;

  // A constructor that calls the super constructor
  Employee({required String name, required int age, required this.department})
      : super(name: name, age: age);

  // Overriding a method from the parent class
  @override
  String greet() {
    return "Hello, my name is $name, I am $age years old, and I work in $department";
  }
}

// Creating objects from classes
var person = Person(name: "Alice", age: 25);
var employee = Employee(name: "Bob", age: 30, department: "Sales");

// Calling methods on objects
print(person.greet()); // prints "Hello, my name is Alice and I am 25 years old"
print(employee.greet()); // prints "Hello, my name is Bob, I am 30 years old, and I work in Sales"

// Define a class to be extended
class Person {
  String name;
  int age;

  Person({required this.name, required this.age});

  String greet() {
    return "Hello, my name is $name and I am $age years old";
  }
}

// Define an extension to add a new method to Person
extension on Person {
  String introduce(String city) {
    return "Hi, my name is $name and I am from $city";
  }
}

void main() {
  var person = Person(name: "Alice", age: 25);
  print(person.introduce("New York")); // prints "Hi, my name is Alice and I am from New York"
}

// An enum is a special kind of class used to represent a fixed number of values

enum Flavor {
  vanilla,
  chocolate,
  strawberry,
  mint,
}

// Enums can have properties and methods just like classes
extension FlavorExtensions on Flavor {
  String get name {
    return this.toString().split('.').last;
  }

  bool get isSweet {
    switch (this) {
      case Flavor.vanilla:
      case Flavor.chocolate:
        return true;
      case Flavor.strawberry:
      case Flavor.mint:
        return false;
    }
  }
}

// Enums can be used like any other type in Dart
void printFlavorInfo(Flavor flavor) {
  print("The flavor is ${flavor.name}");
  print("Is it sweet? ${flavor.isSweet}");
}

// Example usage
void main() {
  var myFlavor = Flavor.chocolate;
  printFlavorInfo(myFlavor);
}

// A mixin is a way to reuse a class's code in multiple class hierarchies

// Defining a mixin
mixin Dancer {
void dance() {
print("Dancing...");
}
}

// Defining a class that uses the mixin
class Person with Dancer {
String name;
int age;

// A constructor with named parameters
Person({required this.name, required this.age});

// A method that returns a string
String greet() {
return "Hello, my name is $name and I am $age years old";
}
}

// Creating an object from the class
var person = Person(name: "Alice", age: 25);

// Calling a method on the object that was defined in the mixin
person.dance(); // prints "Dancing..."

// A callable class is one that can be invoked as a function
class Greeting {
  String message;
  
  // The constructor sets the message property
  Greeting(this.message);
  
  // The call() method allows instances of this class to be called as functions
  String call(String name) {
    return "$message, $name!";
  }
}

// Example usage
void main() {
  var hello = Greeting("Hello");
  var goodbye = Greeting("Goodbye");
  
  // Invoke the objects as functions
  print(hello("Alice")); // prints "Hello, Alice!"
  print(goodbye("Bob")); // prints "Goodbye, Bob!"
}

void main() {
  // Declaring nullable variables with the "?" operator
  String? name;
  int? age;

  // Attempting to assign null to non-nullable variables causes an error
  // String name;
  // int age;

  // Using the "!" operator to assert that a nullable variable is not null
  name = "Alice";
  age = 25;
  print("Hello, my name is ${name!} and I am ${age!} years old");

  // Using the "?? " operator to provide a default value for a nullable variable
  String? jobTitle;
  String message = "Hello";
  message += jobTitle ?? "there";
  print(message);

  // Using the "late" keyword to indicate that a non-nullable variable will be assigned later
  late String favoriteColor;
  favoriteColor = "blue";
  print("My favorite color is $favoriteColor");

  // Using the "required" keyword in constructors to indicate non-nullability
  final person = Person(name: "Bob", age: 30);
  print("Hello, my name is ${person.name} and I am ${person.age} years old");
}

class Person {
  final String name;
  final int age;

  Person({required this.name, required this.age});
}