@Composable
fun UserProfile() {
    Column(
        modifier = Modifier.padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally // Центрируем всё по ширине
    ) {
        Text(text = "Алексей", style = MaterialTheme.typography.headlineSmall)
        Text(text = "@prizrak_dev", color = Color.Gray)
        Spacer(modifier = Modifier.height(12.dp)) // Пустое пространство
        Button(onClick = { /* ... */ }) { Text("Написать") }
    }
}

@Composable
fun MessageItem() {
    Row(
        modifier = Modifier
            .fillMaxWidth()
            .padding(8.dp),
        verticalAlignment = Alignment.CenterVertically // Выравниваем по центру высоты
    ) {
        Icon(Icons.Default.Email, contentDescription = null)
        Spacer(modifier = Modifier.width(8.dp)) // Отступ
        Text(text = "Новое сообщение")
    }
}

@Composable
fun ProfileWithBadge() {
    Box(contentAlignment = Alignment.TopEnd) {
        // Нижний слой
        Image(painter = painterResource(id = R.drawable.avatar), 
              contentDescription = "Аватар", 
              modifier = Modifier.size(64.dp))
        
        // Верхний слой (поверх аватара)
        Box(
            modifier = Modifier
                .size(16.dp)
                .background(Color.Red, CircleShape)
                .border(2.dp, Color.White, CircleShape)
        )
    }
}

@Composable
fun ChatHistory(messages: List<String>) {
    LazyColumn(
        modifier = Modifier.fillMaxSize(),
        contentPadding = PaddingValues(bottom = 70.dp) // Отступ под поле ввода
    ) {
        items(messages) { msg ->
            Text(text = msg, modifier = Modifier.padding(8.dp))
        }
    }
}

@Composable
fun HomeScreen() {
    Scaffold(
        topBar = { Text("Rush Messenger", Modifier.fillMaxWidth().padding(16.dp)) },
        floatingActionButton = {
            FloatingActionButton(onClick = {}) { Icon(Icons.Default.Add, null) }
        }
    ) { innerPadding -> 
        // Основной контент. Scaffold сам передает отступы, чтобы контент не ушел под FAB.
        LazyColumn(contentPadding = innerPadding) {
            items(100) { Text("Сообщение #$it") }
        }
    }
}

@Composable
fun ComplexCard() {
    ConstraintLayout(modifier = Modifier.fillMaxWidth().padding(16.dp)) {
        val (title, subtitle, button) = createRefs()

        Text("Важный заголовок", Modifier.constrainAs(title) {
            top.linkTo(parent.top)
            start.linkTo(parent.start)
        })

        Text("Описание", Modifier.constrainAs(subtitle) {
            top.linkTo(title.bottom, 8.dp)
            start.linkTo(title.start)
            end.linkTo(button.start, 8.dp) // Текст не заходит на кнопку
        })

        Button(onClick = {}, Modifier.constrainAs(button) {
            end.linkTo(parent.end)
            top.linkTo(title.top)
            bottom.linkTo(title.bottom)
        }) {
            Text("Действие")
        }
    }
}

@Composable
fun MyOwnColumn(content: @Composable () -> Unit) {
    Layout(content = content) { measurables, constraints ->
        val placeables = measurables.map { it.measure(constraints) }
        var height = placeables.sumOf { it.height }
        
        layout(constraints.maxWidth, height) {
            var y = 0
            placeables.forEach { placeable ->
                placeable.place(x = 0, y = y)
                y += placeable.height
            }
        }
    }
}

object NotificationIds {
    fun forMessage(thingId: Long, postId: Long): Int =
        "msg_${thingId}_${postId}".hashCode()
}

manager.notify(tag = chatId, id = messageId.hashCode(), notification)

fun cancelChatNotifications(chatId: String) {
    val manager = NotificationManagerCompat.from(context)
    manager.activeNotifications
        .filter { it.tag == chatId }
        .forEach { manager.cancel(it.tag, it.id) }
}

val pendingIntent = PendingIntent.getActivity(
    context,
    messageId.hashCode(),          // уникален для каждого сообщения
    intent,
    PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
)

$text = preg_replace_callback(
    '/\[url(.*?)\](.*?)\[\/url\]/is',
    function($match) use ($this) {
        return $this->_link($match[1], $match[2]);
    },
$text);

$text = preg_replace_callback(
    '/\[url(.*?)\](.*?)\[\/url\]/is',
    fn($m) => $this->_link($m[1], $m[2]),
$text);

function($match) use ($this) {
    return $this->process($match[1]);
}

fn($m) => $this->process($m[1])

function($match) use ($prefix, $config) {
    return $this->replace($prefix, $config, $match[1]);
}

fn($m) => $this->replace($prefix, $config, $m[1])

$pattern = '/\[' . $tag . ':(.*?)\]/is';

$text = preg_replace_callback(
    $pattern,
    function($match) use ($tag, $this) {
        return $this->handleTag($tag, $match[1]);
    },
$text);

$pattern = '/\[' . preg_quote($tag, '/') . ':(.*?)\]/is';

$text = preg_replace_callback(
    $pattern,
    fn($m) => $this->handleTag($tag, $m[1]),
$text);

// [url]текст[/url]
$text = preg_replace_callback(
    '/\[url(.*?)\](.*?)\[\/url\]/is',
    fn($m) => $this->_renderLink($m[1], $m[2]),
$text);

// [img]путь[/img]
$text = preg_replace_callback(
    '/\[img\](.*?)\[\/img\]/is',
    fn($m) => $this->_renderImage($m[1]),
$text);

// [tag:param] — динамический тег
$tag = 'att';
$pattern = '/\[' . preg_quote($tag, '/') . ':(.*?)\]/is';

$text = preg_replace_callback(
    $pattern,
    fn($m) => $this->_handleTag($tag, $m[1]),
$text);

val timeZone = TimeZone.getDefault()
val timeZoneId = timeZone.id // например: "Europe/Moscow"
val offset = timeZone.rawOffset / (1000 * 60 * 60) // смещение в часах

import java.time.ZoneId

val zoneId = ZoneId.systemDefault()
val zoneIdString = zoneId.toString() // например: "Europe/Moscow"

import java.util.Calendar

val calendar = Calendar.getInstance()
val timeZone = calendar.timeZone
val offset = timeZone.getRawOffset()

import java.time.LocalDateTime
import java.time.ZoneId

val currentTime = LocalDateTime.now(ZoneId.systemDefault())

fun getUserTimeZone(): String {
    return ZoneId.systemDefault().toString()
}

fun getTimeZoneOffset(): Int {
    val zone = TimeZone.getDefault()
    return zone.getRawOffset() / (1000 * 60 * 60)
}

fun main() {
    val zoneId = ZoneId.systemDefault()
    println("Часовой пояс: $zoneId")
    
    val timeZone = TimeZone.getDefault()
    println("ID часового пояса: ${timeZone.id}")
    println("Смещение от UTC: ${timeZone.getRawOffset() / (1000 * 60 * 60)} часов")
    
    val currentTime = LocalDateTime.now(zoneId)
    println("Текущее время: $currentTime")
}

println([value])

println("Hello, World!")

val a = 10
val b = 20
println(a + b) // Выведет число 30

val firstName = "John"
val lastName = "Doe"
println("$firstName $lastName") // Выведет John Doe

data class Person(val name: String, val age: Int)
val person = Person("Alice", 30)
println(person) // Выведет Person(name=Alice, age=30)

System.setOut(PrintStream(FileOutputStream("output.txt")))
println("This will be written to output.txt")

print("No newline here ")
print("Still no newline")

setBackgroundColor(ContextCompat.getColor(context, R.color.my_color))
setImageResource(R.drawable.ic_launcher_background)

style="@style/Widget.MaterialComponents.Button.OutlinedButton.Icon"
colorPrimary="@color/material_on_primary_emphasis_high_type"

setBackgroundColor(ContextCompat.getColor(context, com.google.android.material.R.color.design_default_color_secondary))

@Composable
fun MyScreen() {
    Text(text = stringResource(R.string.welcome_message))
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        val welcomeMessage = getString(R.string.welcome_message)
        Toast.makeText(this, welcomeMessage, Toast.LENGTH_SHORT).show()
    }
}

someAsyncOperation(
    onSuccess = { result ->
        // Обработка успешного результата
    },
    onError = { exception ->
        // Обработка ошибки
    }
)

apiService.getUser(userId)
    .enqueue(object : Callback<User> {
        override fun onResponse(call: Call<User>, response: Response<User>) {
            if (response.isSuccessful) {
                onSuccess(response.body()!!)
            } else {
                onError(HttpException(response))
            }
        }

        override fun onFailure(call: Call<User>, t: Throwable) {
            onError(t)
        }
    })

scope.launch {
    val deferred = async {
        fetchDataFromNetwork()
    }

    try {
        val result = deferred.await()
        onSuccess(result)
    } catch (e: Exception) {
        onError(e)
    }
}

class DataLoader {
    fun loadData(
        onSuccess: (List<String>) -> Unit,
        onError: (Throwable) -> Unit
    ) {
        scope.launch {
            try {
                val data = fetchFromServer()
                onSuccess(data)
            } catch (e: IOException) {
                onError(e)
            }
        }
    }
}

// Использование:
dataLoader.loadData(
    onSuccess = { data -> 
        println("Данные загружены: $data")
    },
    onError = { error ->
        println("Ошибка: ${error.message}")
    }
)

onError = { e -> 
    Log.e("Network", "Ошибка загрузки", e)
}

sealed class NetworkError {
    data class HttpError(val code: Int) : NetworkError()
    object Timeout : NetworkError()
}

onError = { error ->
    when (error) {
        is NetworkError.HttpError -> showHttpError(error.code)
        is NetworkError.Timeout -> showTimeoutMessage()
    }
}

onSuccess = { user ->
    saveToCache(user)
    updateUI(user)
    trackAnalytics("user_loaded")
}

fun fetchData(): Result<Data> { ... }

result.fold(
    onSuccess = { /* ... */ },
    onFailure = { /* ... */ }
)