// Null checking
object? obj = null;
bool isNull = obj.IsNull();      // Returns true
bool isNotNull = obj.IsNotNull(); // Returns false

// Check if all properties have default values
var obj = new TestClass();
bool allPropsDefault = obj.AllPropertiesDefault(); // Returns true if all properties have default values

// Create a shallow copy of an object
var original = new TestClass { StringProperty = "test", IntProperty = 42 };
var copy = original.Copy(); // Creates a new instance with the same property values

// Parse string to int
object input = "123";
int result = input.Parse<int>(); // Returns 123

// Parse with default value
object invalidInput = "not a number";
int resultWithDefault = invalidInput.Parse<int>(42); // Returns 42

// Parse to enum
object enumInput = "Tuesday";
DayOfWeek day = enumInput.Parse<DayOfWeek>(); // Returns DayOfWeek.Tuesday

// Parse to TimeSpan
object timeInput = "01:30:45";
TimeSpan time = timeInput.Parse<TimeSpan>(); // Returns TimeSpan of 1 hour, 30 minutes, 45 seconds

// Convert collection of objects to array of integers
IEnumerable<object?> input = ["1", "2", "3"];
int[] result = input.ToArray<int>(); // Returns [1, 2, 3]

// Convert to ImmutableArray<T>
ImmutableArray<int> immutableArray = input.ToImmutableArray<int>(); // Returns ImmutableArray with [1, 2, 3]

// Convert to Dictionary<int, string?>
Dictionary<int, string?> dict = items.ToDictionary<TestItem, int, string?, int, string?>(
    item => item.Id,      // Key selector
    item => item.Name     // Value selector
);

// Case conversion
string text = "hello world";
string upper = text.Upper(); // Returns "HELLO WORLD"
string title = text.Title(); // Returns "Hello World"
string capitalized = text.Capitalize(); // Returns "Hello world"

// Text formatting
string name = "john.doe";
string formatted = name.FormatName(); // Returns "John Doe"

// Content filtering
string mixed = "abc123!@#";
string letters = mixed.FilterAlphabetic(); // Returns "abc"
string numbers = mixed.FilterNumber(); // Returns "123"

// Serialize an object to a JSON string
var person = new Person { Id = 1, Name = "John Doe" };
string json = person.Serialize();
// Result: {"id":1,"name":"John Doe"}

// Deserialize from JSON string
string personJson = "{\"id\":1,\"name\":\"John Doe\"}";
Person? deserializedPerson = personJson.Deserialize<Person>();
// Result: Person { Id = 1, Name = "John Doe" }

// Serialize to UTF-8 byte array (more efficient for APIs)
byte[] jsonBytes = person.SerializeToBytes();

// Statistical functions
double min = YANMath.Min(5.2, 3.1, 7.8, 2.4); // Returns 2.4
double max = YANMath.Max(5.2, 3.1, 7.8, 2.4); // Returns 7.8
double avg = YANMath.Average(5.2, 3.1, 7.8, 2.4); // Returns 4.625

// Power functions
double sqrt = 16.0.Sqrt(); // Returns 4.0
double powered = 2.0.Pow(3); // Returns 8.0
double abs = (-5.0).Abs(); // Returns 5.0

// Get week number for a specific date
var date = new DateTime(2023, 6, 15);
int weekNumber = date.GetWeekOfYear(); // Returns 24

// Calculate months between two dates
var date1 = new DateTime(2023, 6, 15);
var date2 = new DateTime(2022, 6, 15);
int monthDiff = YANDateTime.TotalMonth(date1, date2); // Returns 12

// Change time zone for a DateTime
var date = new DateTime(2023, 6, 15, 10, 0, 0);
var convertedDate = date.ChangeTimeZone(0, 3); // UTC to UTC+3, returns 2023-6-15 13:00:00

// Generate random values of various types
int randomInt = YANRandom.GenerateRandom<int>(); // Random int
double boundedDouble = YANRandom.GenerateRandom<double>(-10.5, 10.5); // Random double in range
DateTime randomDate = YANRandom.GenerateRandom<DateTime>(); // Random DateTime
bool randomBool = YANRandom.GenerateRandom<bool>(); // Random boolean

// Generate collections of random values
IEnumerable<int> randomInts = YANRandom.GenerateRandoms<int>(size: 10); // 10 random ints
IEnumerable<double> randomDoubles = YANRandom.GenerateRandoms<double>(-10.5, 10.5, 5); // 5 random doubles in range

// Wait for any task that returns a value greater than 5
var tasks = new[]
{
    Task.FromResult(3),
    Task.FromResult(7),
    Task.FromResult(2),
    Task.FromResult(10)
};

// Using WaitAnyWithCondition - returns as soon as it finds a match
int? result = await tasks.WaitAnyWithCondition(x => x > 5);
Console.WriteLine(result); // Output: 7

// Using WhenAnyWithCondition - waits for tasks to complete until it finds a match
int? anotherResult = await tasks.WhenAnyWithCondition(x => x > 8);
Console.WriteLine(anotherResult); // Output: 10

// Kill all instances of a process with a specific name
await "notepad".KillAllProcessesByName();

// Kill multiple processes using a collection
var processNames = new List<string?>
{
    "notepad",
    "calc",
    "mspaint"
};

await processNames.KillAllProcessesByNames();

// Create a property expression for accessing the Name property on a Person object
var expression = YANExpression.PropertyExpression<Person>("p", "Name");

// Compile and use the expression
var func = expression.Compile();
var person = new Person { Name = "John", Age = 30 };
string name = (string)func(person); // Returns "John"

// Create an ID generator with worker ID 1 and datacenter ID 1
var generator = new IdGenerator(1, 1);

// Generate a numeric ID
long id = generator.NextId();
// Example: 6982190104624234496

// Generate an alphabetic ID (base-26, A-Z)
string alphabeticId = generator.NextIdAlphabetic();
// Example: "BPNHEBKDMGLCQ"

// Generate an alphanumeric ID (base-36, 0-9, A-Z)
string alphanumericId = generator.NextIdAlphanumeric();
// Example: "1Z9DHPKW0S"

// Create a generator with a predefined bit allocation strategy
// MoreDistributed: 10 bits for worker ID (0-1023), 10 bits for datacenter ID (0-1023), 3 bits for sequence (0-7)
var distributedGenerator = new IdGenerator(100, 200, BitAllocationStrategy.MoreDistributed);

// HighVolume: 2 bits for worker ID (0-3), 2 bits for datacenter ID (0-3), 19 bits for sequence (0-524,287)
var highVolumeGenerator = new IdGenerator(1, 1, BitAllocationStrategy.HighVolume);

// Extract components from an ID
var components = IdGenerator.ExtractIdComponents(id);
DateTime timestamp = components.Timestamp;
long workerId = components.WorkerId;
long datacenterId = components.DatacenterId;

// Extract components using the same strategy used to generate the ID
var strategicComponents = IdGenerator.ExtractIdComponents(
    distributedGenerator.NextId(),
    BitAllocationStrategy.MoreDistributed
);

public List<Product> ProcessProductData(string[] rawData)
{
    return rawData
        .Where(line => line.IsNotNullWhiteSpace())
        .Select(line => line.Split(','))
        .Select(parts => new Product
        {
            Id = parts[0].Parse<int>(),
            Name = parts[1].CleanSpace().Capitalize(),
            Price = parts[2].Parse<decimal>(),
            IsAvailable = parts[3].Parse<bool>()
        })
        .Where(p => p.Id > 0 && p.Name.IsNotNullEmpty())
        .ToList();
}

public async Task<WeatherData> GetWeatherFromMultipleProviders(string location)
{
    var providers = new[]
    {
        GetWeatherFromProvider1(location),
        GetWeatherFromProvider2(location),
        GetWeatherFromProvider3(location)
    };

    // Return the first non-null weather data
    return await providers.WaitAnyWithCondition(data => data != null);
}

public bool IsValidCustomer(Customer customer)
{
    // Customer must not be null and must have all required properties set
    return customer.IsNotNull() && 
           !customer.AnyPropertiesDefault(["Name", "Email", "PhoneNumber"]);
}

public Customer PrepareCustomerData(Customer customer)
{
    // Create a copy and normalize the data
    var normalizedCustomer = customer.Copy();

    normalizedCustomer.Name = normalizedCustomer.Name.CleanSpace().FormatName();
    normalizedCustomer.Email = normalizedCustomer.Email.Lower();
    normalizedCustomer.PhoneNumber = normalizedCustomer.PhoneNumber.FilterNumber();
    
    return normalizedCustomer;
}

public class IdService
{
    private readonly IdGenerator _userIdGenerator;
    private readonly IdGenerator _orderIdGenerator;
    private readonly IdGenerator _highVolumeGenerator;
    
    public IdService()
    {
        // Create separate generators for different entity types
        _userIdGenerator = new IdGenerator(1, 1);
        _orderIdGenerator = new IdGenerator(2, 1);
        
        // Create a high-volume generator with custom bit allocation
        // 2 bits for worker ID, 2 bits for datacenter ID, 19 bits for sequence
        _highVolumeGenerator = new IdGenerator(
            workerId: 1,
            datacenterId: 1,
            sequence: 0,
            workerIdBits: 2,
            datacenterIdBits: 2,
            sequenceBits: 19
        );
    }
    
    public string GenerateUserId()
    {
        // Generate a compact alphanumeric ID for users
        return _userIdGenerator.NextIdAlphanumeric();
    }
    
    public long GenerateOrderId()
    {
        // Generate a numeric ID for orders
        return _orderIdGenerator.NextId();
    }
    
    public long GenerateHighVolumeId()
    {
        // Generate an ID optimized for high volume (up to 524,287 IDs per millisecond)
        return _highVolumeGenerator.NextId();
    }
    
    public DateTime GetIdCreationTime(long id)
    {
        // Extract the timestamp from an ID
        var components = IdGenerator.ExtractIdComponents(id);

        return components.Timestamp;
    }
}

public class TestDataGenerator
{
    public List<User> GenerateUsers(int count)
    {
        return YANRandom.GenerateRandoms<int>(size: count)
            .Select(i => new User
            {
                Id = i,
                Name = YANRandom.GenerateRandom<string>(),
                Age = YANRandom.GenerateRandom<int>(18, 80),
                RegistrationDate = YANRandom.GenerateRandom<DateTime>(
                    new DateTime(2020, 1, 1),
                    DateTime.Now
                ),
                IsActive = YANRandom.GenerateRandom<bool>()
            })
            .ToList();
    }
}

public double CalculateStatistics(IEnumerable<double> values)
{
    // Calculate various statistics
    double min = values.Min();
    double max = values.Max();
    double avg = values.Average();
    double sum = values.Sum();
    
    // Apply mathematical transformations
    var transformed = values
        .Select(v => v.Sqrt())
        .Select(v => v.Pow(2))
        .Select(v => v.Round(2))
        .ToList();
    
    return transformed.Average();
}