// Span<T> оголошений приблизно так:
public ref struct Span<T>
{
    private ref T _pointer;  // "Managed pointer" до першого елемента
    private int _length;     // Кількість елементів

    // ... методи ...
}

Span<int> source = stackalloc int[] { 1, 2, 3, 4, 5 };

// Slicing (створення "підвікна" БЕЗ копіювання)
Span<int> slice = source[1..4]; // {2, 3, 4}
slice[0] = 99; // source тепер {1, 99, 3, 4, 5}

// Fill - заповнення значенням
Span<int> buffer = stackalloc int[100];
buffer.Fill(42); // Всі 100 елементів = 42

// Clear - обнулення
buffer.Clear(); // Всі елементи = 0

// CopyTo - копіювання в інший Span
Span<int> destination = stackalloc int[3];
source[..3].CopyTo(destination); // {1, 99, 3}

// TryCopyTo - безпечне копіювання
if (source.TryCopyTo(destination))
{
    Console.WriteLine("Скопійовано!");
}
else
{
    Console.WriteLine("Destination занадто малий!");
}

// IndexOf, Contains
int index = source.IndexOf(99); // 1
bool has = source.Contains(4);  // true

string data = "Sample Data";
ReadOnlySpan<char> readOnly = data.AsSpan();

// readOnly[0] = 'X'; // ❌ Compiler error!

// Приймаємо тільки readonly
void ProcessData(ReadOnlySpan<char> input)
{
    // Можемо читати
    char first = input[0];

    // Не можемо писати
    // input[0] = 'A'; // Error!
}

// Можна передати як Span, так і ReadOnlySpan
Span<char> mutable = stackalloc char[10];
ProcessData(mutable); // ✅ Implicit conversion

// ✅ Працює!
async Task ProcessAsync(Memory<byte> buffer)
{
    // Отримуємо Span локально
    Span<byte> span = buffer.Span;

    // Маніпуляції з даними (синхронно)
    span.Fill(0);

    // Async операція
    await Task.Delay(100);

    // Знову отримуємо Span після await
    Span<byte> span2 = buffer.Span;
    span2[0] = 42;
}

// Виклик:
byte[] data = new byte[1024];
Memory<byte> memory = data;
await ProcessAsync(memory);

void ProcessSmallBuffer()
{
    // Виділення 256 байт на стеку
    Span<byte> buffer = stackalloc byte[256];

    // Bounds checking автоматично!
    buffer[0] = 1;
    buffer[255] = 255;
    // buffer[256] = 0; // ✅ IndexOutOfRangeException (безпечно!)

    // Використання buffer...
    DoWork(buffer);

    // При виході з методу пам'ять автоматично "звільняється"
    // (насправді просто відновлюється stack pointer)
}

void DoWork(Span<byte> data)
{
    // Приймає будь-яке джерело: stackalloc, array, pool
    data.Fill(42);
}

unsafe void DangerousStackalloc()
{
    // Старий підхід - потребує unsafe!
    int* buffer = stackalloc int[10];

    buffer[0] = 1;
    buffer[9] = 9;
    buffer[100] = 0; // ❌ ЖАХ! Undefined behavior, можливо crash!

    // Немає bounds checking
    // Немає GC tracking
    // Легко зламати пам'ять
}

void ProcessBuffer(int size)
{
    const int StackallocThreshold = 256;

    // Малий розмір → stack
    if (size <= StackallocThreshold)
    {
        Span<byte> buffer = stackalloc byte[StackallocThreshold];
        Span<byte> actualBuffer = buffer[..size];
        DoWork(actualBuffer);
    }
    // Великий розмір → pool
    else
    {
        byte[] rented = ArrayPool<byte>.Shared.Rent(size);
        try
        {
            Span<byte> buffer = rented.AsSpan(0, size);
            DoWork(buffer);
        }
        finally
        {
            ArrayPool<byte>.Shared.Return(rented);
        }
    }
}

void DoWork(Span<byte> buffer)
{
    // Єдиний метод для обох випадків!
    buffer.Fill(0xFF);
}

int[] numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

// Традиційний спосіб доступу з кінця
int last = numbers[numbers.Length - 1];     // 9
int secondLast = numbers[numbers.Length - 2]; // 8

// Новий спосіб з Index
int last = numbers[^1];  // 9
int secondLast = numbers[^2]; // 8
int first = numbers[^10]; // 0

// Index як тип
Index lastIndex = ^1;
int value = numbers[lastIndex]; // 9

int[] numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

// Діапазони
int[] range1 = numbers[2..5];    // [2, 3, 4]
int[] range2 = numbers[..3];     // [0, 1, 2] (від початку до 3)
int[] range3 = numbers[7..];     // [7, 8, 9] (від 7 до кінця)
int[] range4 = numbers[^3..];    // [7, 8, 9] (останні 3)
int[] range5 = numbers[..^2];    // [0, 1, 2, 3, 4, 5, 6, 7] (без останніх 2)
int[] all = numbers[..];         // Вся копія масиву

// Range як тип
Range middle = 2..5;
int[] slice = numbers[middle]; // [2, 3, 4]

// ✅ Arrays
int[] arr = [1, 2, 3, 4, 5];
int[] slice = arr[1..3];

// ✅ Span/Memory
Span<int> span = arr;
Span<int> spanSlice = span[1..3];

// ✅ String
string text = "Hello, World!";
string hello = text[..5]; // "Hello"

// ❌ List НЕ ПІДТРИМУЄ ranges напряму (потребує GetRange)
List<int> list = [1, 2, 3, 4, 5];
// var slice = list[1..3]; // Compiler error!
List<int> listSlice = list.GetRange(1, 2); // [2, 3]

void ParseCsv(ReadOnlySpan<char> line)
{
    while (line.Length > 0)
    {
        int comma = line.IndexOf(',');

        ReadOnlySpan<char> token = comma >= 0
            ? line[..comma]
            : line;

        ProcessToken(token); // БЕЗ створення нових string!

        if (comma < 0) break;
        line = line[(comma + 1)..]; // Залишок
    }
}

void ProcessToken(ReadOnlySpan<char> token)
{
    Console.WriteLine(token.ToString()); // ToString тільки коли РЕАЛЬНО потрібен string
}

// Використання:
string csvLine = "Name,Age,City";
ParseCsv(csvLine);

// Старий спосіб (з алокаціями)
string FormatOld(int id, string name, double salary)
{
    return $"ID:{id}, Name:{name}, Salary:{salary:C}";
    // Або через StringBuilder - також алокація
}

// Новий спосіб (zero-allocation)
bool TryFormatNew(int id, ReadOnlySpan<char> name, double salary, Span<char> destination, out int written)
{
    Span<char> buffer = destination;
    int pos = 0;

    // "ID:"
    "ID:".AsSpan().CopyTo(buffer[pos..]);
    pos += 3;

    // {id}
    if (!id.TryFormat(buffer[pos..], out int idLen))
        goto fail;
    pos += idLen;

    // ", Name:"
    ", Name:".AsSpan().CopyTo(buffer[pos..]);
    pos += 8;

    // {name}
    name.CopyTo(buffer[pos..]);
    pos += name.Length;

    // ", Salary:"
    ", Salary:".AsSpan().CopyTo(buffer[pos..]);
    pos += 10;

    // {salary:C}
    if (!salary.TryFormat(buffer[pos..], out int salLen, "C"))
        goto fail;
    pos += salLen;

    written = pos;
    return true;

fail:
    written = 0;
    return false;
}

// Використання:
Span<char> buffer = stackalloc char[256];
if (TryFormatNew(42, "Alice", 75000.50, buffer, out int len))
{
    string result = buffer[..len].ToString(); // Одна алокація в кінці
    Console.WriteLine(result);
}