public struct Point
{
    public double X { get; set; }
    public double Y { get; set; }

    public Point(double x, double y)
    {
        X = x;
        Y = y;
    }

    public double DistanceFromOrigin()
    {
        return Math.Sqrt(X * X + Y * Y);
    }

    public override string ToString()
    {
        return $"({X}, {Y})";
    }
}

// Використання
Point p1 = new Point(3, 4);
Point p2 = p1; // Копія значення, а не посилання!
p2.X = 10;

Console.WriteLine(p1); // (3, 4) - p1 не змінився
Console.WriteLine(p2); // (10, 4)

// Гарний приклад використання struct - невеликий immutable тип
public readonly struct Color
{
    public byte R { get; }
    public byte G { get; }
    public byte B { get; }

    public Color(byte r, byte g, byte b)
    {
        R = r;
        G = g;
        B = b;
    }
}

// Поганий приклад - занадто великий для struct
public struct HugeData // ❌ Краще використати class
{
    public double[] Data { get; set; } // Масив з 1000 елементів
    public string Description { get; set; }
    // ... багато полів
}

public ref struct SpanExample
{
    private Span<int> _numbers;

    public SpanExample(Span<int> numbers)
    {
        _numbers = numbers;
    }

    // ref struct має суворі обмеження:
    // ❌ Не може бути полем класу
    // ❌ Не може реалізовувати інтерфейси
    // ❌ Не може бути boxing (перетворення в object)
    // ❌ Не може бути типом параметра async методу
}

public enum OrderStatus
{
    Pending,      // 0 (за замовчуванням)
    Processing,   // 1
    Shipped,      // 2
    Delivered,    // 3
    Cancelled     // 4
}

// Використання
OrderStatus status = OrderStatus.Pending;

if (status == OrderStatus.Delivered)
{
    Console.WriteLine("Замовлення доставлено!");
}

// Конвертація в int
int statusCode = (int)status; // 0

// Конвертація з int
OrderStatus newStatus = (OrderStatus)2; // Shipped

// Використання ushort для економії пам'яті
public enum ErrorCode : ushort
{
    None = 0,
    NotFound = 404,
    Unauthorized = 401,
    InternalServerError = 500
}

// Великі значення - використання long
public enum LargeValues : long
{
    SmallValue = 1,
    HugeValue = 9_223_372_036_854_775_807 // long.MaxValue
}

[Flags]
public enum FilePermissions
{
    None = 0,           // 0000
    Read = 1,           // 0001
    Write = 2,          // 0010
    Execute = 4,        // 0100
    Delete = 8,         // 1000
    ReadWrite = Read | Write,              // 0011 (3)
    FullControl = Read | Write | Execute | Delete  // 1111 (15)
}

// Використання
FilePermissions userPermissions = FilePermissions.Read | FilePermissions.Write;

// Перевірка наявності прапорця
if (userPermissions.HasFlag(FilePermissions.Read))
{
    Console.WriteLine("Користувач може читати файл");
}

// Додавання прапорця
userPermissions |= FilePermissions.Execute;

// Видалення прапорця
userPermissions &= ~FilePermissions.Write;

// Перевірка через бітову операцію (швидше)
bool canWrite = (userPermissions & FilePermissions.Write) == FilePermissions.Write;

// Positional syntax (компактний синтаксис)
public record Person(string FirstName, string LastName, int Age);

// Еквівалентно:
public record Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
    public int Age { get; init; }

    public Person(string firstName, string lastName, int age)
    {
        FirstName = firstName;
        LastName = lastName;
        Age = age;
    }
}

// Використання
Person person1 = new("John", "Doe", 30);
Person person2 = new("John", "Doe", 30);

Console.WriteLine(person1 == person2); // True - value equality!

public record Person(string FirstName, string LastName, int Age);

Person person = new("John", "Doe", 30);

// Створення копії зі зміненим віком
Person olderPerson = person with { Age = 31 };

Console.WriteLine(person);       // Person { FirstName = John, LastName = Doe, Age = 30 }
Console.WriteLine(olderPerson);  // Person { FirstName = John, LastName = Doe, Age = 31 }

// person залишився незмінним!

// Можна змінювати кілька властивостей
Person different = person with
{
    FirstName = "Jane",
    Age = 25
};

// Оголошення tuple
(string Name, int Age) person = ("Alice", 25);

// Доступ до елементів
Console.WriteLine(person.Name); // Alice
Console.WriteLine(person.Age);  // 25

// Без імен (доступ через Item1, Item2...)
(string, int) unnamed = ("Bob", 30);
Console.WriteLine(unnamed.Item1); // Bob

// Tuple literal
var point = (X: 3.0, Y: 4.0);

public (int Min, int Max, double Average) AnalyzeNumbers(int[] numbers)
{
    if (numbers.Length == 0)
    {
        return (0, 0, 0);
    }

    int min = numbers.Min();
    int max = numbers.Max();
    double avg = numbers.Average();

    return (min, max, avg);
}

// Використання
int[] data = { 5, 2, 8, 1, 9 };
var result = AnalyzeNumbers(data);

Console.WriteLine($"Min: {result.Min}");         // 1
Console.WriteLine($"Max: {result.Max}");         // 9
Console.WriteLine($"Avg: {result.Average}");     // 5

// Повний приклад deconstructon
(string Name, int Age) GetPerson() => ("Alice", 25);

// Deconstruct в нові змінні
var (name, age) = GetPerson();
Console.WriteLine($"{name} is {age} years old");

// Deconstruct в існуючі змінні
string personName;
int personAge;
(personName, personAge) = GetPerson();

// Використання discard (_) для ігнорування значень
var (_, onlyAge) = GetPerson(); // Ігноруємо ім'я
Console.WriteLine($"Age: {onlyAge}");

// Deconstruction в foreach
var people = new[]
{
    ("Alice", 25),
    ("Bob", 30)
};

foreach (var (n, a) in people)
{
    Console.WriteLine($"{n}: {a}");
}

// Створення анонімного типу
var person = new
{
    Name = "Alice",
    Age = 25,
    City = "Kyiv"
};

Console.WriteLine(person.Name);  // Alice
Console.WriteLine(person.Age);   // 25

// Тип відомий тільки компілятору
// person.Name = "Bob"; // ❌ Помилка - read-only

public record Product(string Name, decimal Price, string Category);

List<Product> products = new()
{
    new("Laptop", 1200m, "Electronics"),
    new("Mouse", 25m, "Electronics"),
    new("Desk", 300m, "Furniture")
};

// Проекція в анонімний тип
var result = products
    .Where(p => p.Category == "Electronics")
    .Select(p => new
    {
        ProductName = p.Name,
        PriceInUah = p.Price * 40, // Конвертація в гривні
        Discount = p.Price > 1000 ? 10 : 5
    });

foreach (var item in result)
{
    Console.WriteLine($"{item.ProductName}: {item.PriceInUah} UAH (Discount: {item.Discount}%)");
}

var person = new { Name = "Alice", Age = 25 };

// Створення копії зі зміненою властивістю
var olderPerson = person with { Age = 26 };

Console.WriteLine(person);       // { Name = Alice, Age = 25 }
Console.WriteLine(olderPerson);  // { Name = Alice, Age = 26 }

// Два способи оголошення - еквівалентні
Nullable<int> age1 = null;
int? age2 = null; // Скорочений синтаксис (рекомендується)

// Присвоєння значення
age2 = 25;

// Перевірка наявності значення
if (age2.HasValue)
{
    Console.WriteLine($"Age: {age2.Value}");
}

// Безпечний доступ
Console.WriteLine(age2.GetValueOrDefault()); // 25
Console.WriteLine(age2.GetValueOrDefault(18)); // 25 (або 18, якщо null)

// Null-coalescing operator
int definiteAge = age2 ?? 18; // Якщо age2 == null, то 18

// Увімкнення NRT у файлі
#nullable enable

// Non-nullable reference type
string name = "Alice";
// name = null; // ⚠️ Попередження компілятора

// Nullable reference type
string? nullableName = null; // OK

// Compiler warning якщо не перевірити на null
void PrintLength(string? input)
{
    // Console.WriteLine(input.Length); // ⚠️ Попередження

    // ✅ Правильно - перевірка на null
    if (input != null)
    {
        Console.WriteLine(input.Length);
    }

    // Або з null-conditional operator
    Console.WriteLine(input?.Length);
}

string? name = null;
string? city = "Kyiv";

// ?? - Null-coalescing
string displayName = name ?? "Guest"; // "Guest"

// ??= - Null-coalescing assignment
name ??= "Default"; // name тепер "Default"

// ?. - Null-conditional member access
int? nameLength = name?.Length; // 7 (довжина "Default")
int? nullLength = ((string?)null)?.Length; // null

// ?[] - Null-conditional indexing
int[] numbers = { 1, 2, 3 };
int? first = numbers?[0]; // 1
int? nullArrayFirst = ((int[]?)null)?[0]; // null

// ! - Null-forgiving operator (використовуйте обережно!)
string definitelyNotNull = name!; // Компілятор не попереджає
string riskyAccess = name!.ToUpper(); // "DEFAULT"

// База - sealed щоб запобігти розширенню ззовні
public abstract record PaymentMethod;

// Варіанти
public record Cash(decimal Amount) : PaymentMethod;
public record CreditCard(string CardNumber, string Cvv) : PaymentMethod;
public record BankTransfer(string AccountNumber) : PaymentMethod;

// Використання з pattern matching
public static string ProcessPayment(PaymentMethod payment)
{
    return payment switch
    {
        Cash { Amount: var amount } =>
            $"Cash payment: {amount:C}",

        CreditCard { CardNumber: var number } =>
            $"Card payment: {number[^4..]} (last 4 digits)",

        BankTransfer { AccountNumber: var account } =>
            $"Bank transfer from: {account}",

        _ => throw new ArgumentException("Unknown payment method")
    };
}

// Використання
PaymentMethod payment1 = new Cash(100m);
PaymentMethod payment2 = new CreditCard("1234-5678-9012-3456", "123");

Console.WriteLine(ProcessPayment(payment1));
// Cash payment: $100.00

Console.WriteLine(ProcessPayment(payment2));
// Card payment: 3456 (last 4 digits)

using OneOf;

// Визначення union type
public class Result : OneOfBase<Success, Error>
{
    public Result(OneOf<Success, Error> input) : base(input) { }
}

public record Success(string Message);
public record Error(string ErrorMessage, int Code);

// Метод, що повертає union
public Result DivideNumbers(int a, int b)
{
    if (b == 0)
    {
        return new Error("Division by zero", 400);
    }

    return new Success($"Result: {a / b}");
}

// Pattern matching з OneOf
Result result = DivideNumbers(10, 2);

string output = result.Match(
    success => $"✓ {success.Message}",
    error => $"✗ Error {error.Code}: {error.ErrorMessage}"
);

Console.WriteLine(output); // ✓ Result: 5