LibCode

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 = { /* ... */ }
)

$method = $_SERVER['REQUEST_METHOD'];
if ($method === 'GET') {
    // Обработка GET-запроса
} elseif ($method === 'POST') {
    // Обработка POST-запроса
}

if (php_sapi_name() === 'cgi-fcgi' && $_SERVER['REQUEST_METHOD'] === 'POST') {
    // POST-запрос
}

$method = filter_input(INPUT_SERVER, 'REQUEST_METHOD');

switch ($_SERVER['REQUEST_METHOD']) {
    case 'GET':
        // Обработка GET-запроса
        $data = $_GET;
        break;
    
    case 'POST':
        // Обработка POST-запроса
        $data = $_POST;
        break;
    
    default:
        http_response_code(405); // Метод не разрешён
        echo 'Метод запроса не поддерживается';
        break;
}

if (!empty($_POST)) {
    // Вероятно, POST-запрос
}

if (fopen('php://input', 'r')) {
    // Возможно POST-запрос
}

<?php

// Определяем метод запроса
$method = $_SERVER['REQUEST_METHOD'];

// Проверяем допустимость метода
if (!in_array($method, ['GET', 'POST'])) {
    http_response_code(405);
    exit('Метод запроса не поддерживается');
}

// Обработка в зависимости от метода
switch ($method) {
    case 'GET':
        $data = filter_input_array(INPUT_GET, FILTER_SANITIZE_STRING);
        // Логика обработки GET
        break;
    
    case 'POST':
        $data = filter_input_array(INPUT_POST, FILTER_SANITIZE_STRING);
        // Логика обработки POST
        break;
}

{
    "status": "error",
    "message": "Пользователь с таким email уже зарегистрирован.",
    "data": {}
}

header('Content-Type: application/json');
echo json_encode([
    'status' => 'error',
    'message' => 'Ошибка базы данных: '.$stmt->error
]);

http_response_code(400); // Невалидные данные
echo json_encode([
    'status' => 'error',
    'message' => 'Неверный формат данных.'
]);

function respondWithError($code, $message) {
    http_response_code($code);
    header('Content-Type: application/json');
    echo json_encode([
        'status' => 'error',
        'message' => $message
    ]);
    exit;
}

respondWithError(404, 'Запрашиваемый ресурс не найден.');

error_log("Ошибка базы данных: ".$stmt->error);
echo json_encode([
    'status' => 'error',
    'message' => 'Ошибка базы данных.',
]);

echo json_encode([
    'status' => 'error',
    'message' => 'Ошибка при регистрации: '.htmlspecialchars($stmt->error)
]);

// Обработка запроса на регистрацию
$input = file_get_contents('php://input');
$data = json_decode($input, true);

if ($data['method'] !== 'registration') {
    respondWithError(400, 'Недопустимый метод.');
}

// Попытка регистрации пользователя
$sql = 'INSERT INTO users (email, password) VALUES (?, ?)';
$stmt = $mysqli->prepare($sql);

if ($stmt) {
    $stmt->bind_param('ss', $data['email'], $data['password']);

    if ($stmt->execute()) {
        http_response_code(200);
        echo json_encode(['status' => 'ok']);
    } else {
        respondWithError(500, 'Ошибка базы данных: '.$stmt->error);
    }

    $stmt->close();
} else {
    respondWithError(500, 'Ошибка подготовки запроса.');
}

$mysqli->close();

@Composable
fun Greeting(name: String) {
    Text(text = "Hello, $name!")
}

@Composable
fun Content() {
    Greeting(name = "Kotlin")
}

@Composable
fun Counter() {
    var count by remember { mutableStateOf(0) }
    Button(onClick = { count++ }) {
        Text("Count: $count")
    }
}

@Composable
fun SimpleText() {
    Text("Hello, Compose!")
}

@Composable
fun ButtonWithText() {
    Button(onClick = { /* Обработка клика */ }) {
        Text("Click me!")
    }
}

@Composable
fun ComplexUI() {
    Column {
        Text("Title")
        Button(onClick = { /* Обработка клика */ }) {
            Text("Button")
        }
        Image(painter = painterResource(id = R.drawable.image), contentDescription = "Image")
    }
}