SELECT employees.name, departments.name
FROM employees
INNER JOIN departments ON employees.department_id = departments.id;

for each row in employees:
    for each row in departments:
        if row.employees.department_id == row.departments.id:
            yield (row.employees.name, row.departments.name)

hash_table = {}
for each row in departments:
    hash_table[row.id] = row.name
for each row in employees:
    if row.department_id in hash_table:
        yield (row.name, hash_table[row.department_id])

sorted_employees = sort(employees, key=lambda x: x.department_id)
sorted_departments = sort(departments, key=lambda x: x.id)
i, j = 0, 0
while i < len(sorted_employees) and j < len(sorted_departments):
    if sorted_employees[i].department_id == sorted_departments[j].id:
        yield (sorted_employees[i].name, sorted_departments[j].name)
        i += 1
        j += 1
    elif sorted_employees[i].department_id < sorted_departments[j].id:
        i += 1
    else:
        j += 1

class MyViewModel : ViewModel() {
    var counter: Int = 0  // Переменная, которая сохраняется при повороте экрана
}

class MainActivity : AppCompatActivity() {
    private lateinit var viewModel: MyViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        viewModel = ViewModelProvider(this).get(MyViewModel::class.java)

        // Теперь viewModel.counter сохранится при повороте экрана
    }
}

class MainActivity : AppCompatActivity() {
    private var counter: Int = 0  // Значение, которое мы хотим сохранить

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Восстанавливаем данные, если они есть
        counter = savedInstanceState?.getInt("counter_key") ?: 0
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putInt("counter_key", counter)  // Сохраняем значение перед уничтожением Activity
    }
}

@Entity
data class Note(
    @PrimaryKey(autoGenerate = true) val id: Long = 0,
    val title: String,
    val content: String // Здесь хранится Markdown-текст
)

@Dao
interface NoteDao {
    @Insert
    suspend fun insert(note: Note)

    @Query("SELECT * FROM Note WHERE id = :id")
    suspend fun getNote(id: Long): Note?
}

fun saveMarkdownToFile(context: Context, filename: String, content: String) {
    val file = File(context.filesDir, filename)
    file.writeText(content, Charsets.UTF_8)
}

fun readMarkdownFromFile(context: Context, filename: String): String {
    val file = File(context.filesDir, filename)
    return if (file.exists()) file.readText(Charsets.UTF_8) else ""
}

{
  "title": "Android Markdown Guide",
  "content": [
    {
      "type": "header",
      "level": 1,
      "text": "Введение"
    },
    {
      "type": "paragraph",
      "text": "Markdown — это простой язык разметки..."
    },
    {
      "type": "list",
      "items": [
        "Простота",
        "Гибкость",
        "Совместимость"
      ]
    }
  ]
}

@Entity
data class MarkdownNote(
    @PrimaryKey(autoGenerate = true) val id: Long = 0,
    val title: String,
    val jsonContent: String // Храним JSON-структуру
)

class MarkdownConverter {
    @TypeConverter
    fun fromJson(value: String): List<MarkdownBlock> {
        return Gson().fromJson(value, object : TypeToken<List<MarkdownBlock>>() {}.type)
    }

    @TypeConverter
    fun toJson(content: List<MarkdownBlock>): String {
        return Gson().toJson(content)
    }
}

fun parseMarkdownToJson(markdown: String): String {
    val document = Parser.builder().build().parse(markdown)
    val blocks = mutableListOf<MarkdownBlock>()

    document.children.forEach { node ->
        when (node) {
            is Heading -> blocks.add(MarkdownBlock("header", node.level, node.text.toString()))
            is Paragraph -> blocks.add(MarkdownBlock("paragraph", text = node.text.toString()))
            is BulletList -> {
                val items = node.children.map { it.text.toString() }
                blocks.add(MarkdownBlock("list", items = items))
            }
        }
    }
    return Gson().toJson(blocks)
}

fun convertMarkdownToHtml(markdown: String): String {
    val renderer = HtmlRenderer.builder().build()
    val document = Parser.builder().build().parse(markdown)
    return renderer.render(document)
}

@Entity
data class HtmlNote(
    @PrimaryKey(autoGenerate = true) val id: Long = 0,
    val title: String,
    val htmlContent: String
)

data class User(val name: String)

fun main() {
    val user1 = User("Alice")
    val user2 = User("Alice")

    println(user1 == user2) // true (структурное сравнение)
    println(user1 === user2) // false (сравнение ссылок)
}

val str1 = "Hello"
val str2 = "Hello"
println(str1 == str2)  // true (содержимое одинаковое)
println(str1 === str2) // true (Kotlin кеширует строки)

val obj1 = String("Hello".toCharArray()) 
val obj2 = String("Hello".toCharArray()) 
println(obj1 == obj2)  // true (содержимое одинаковое)
println(obj1 === obj2) // false (разные объекты в памяти)

class Person(val name: String)

fun main() {
    val p1 = Person("Bob")
    val p2 = Person("Bob")

    println(p1 == p2)  // false (equals() не переопределён, сравниваются ссылки)
}

class Person(val name: String) {
    override fun equals(other: Any?): Boolean {
        return other is Person && other.name == this.name
    }
}

fun main() {
    val p1 = Person("Bob")
    val p2 = Person("Bob")

    println(p1 == p2)  // true (equals() сравнивает содержимое)
}

val a: String? = null
val b: String? = "Hello"

println(a == b)  // false (без NPE)
println(a == null) // true

a?.equals(b) ?: (b === null)

// Расширение класса String для проверки, пуста ли строка или состоит из пробелов
fun String.isNullOrBlank(): Boolean {
    return this == null || this.trim().isEmpty()
}

// Использование расширения
val myString = "  "
println(myString.isNullOrBlank()) // Выведет: true

// Расширение стандартного типа String для добавления метода инвертирования строки
extension String {
    func reversedString() -> String {
        return String(self.reversed())
    }
}

let myString = "Hello"
print(myString.reversedString()) // Выведет: "olleH"

val intent = Intent(this, SecondActivity::class.java)
startActivity(intent)

supportFragmentManager.beginTransaction()
    .replace(R.id.container, SecondFragment())
    .addToBackStack(null)
    .commit()

findNavController().navigate(R.id.action_firstFragment_to_secondFragment)

bottomNavigationView.setOnNavigationItemSelectedListener { item ->
    when (item.itemId) {
        R.id.home -> replaceFragment(HomeFragment())
        R.id.profile -> replaceFragment(ProfileFragment())
    }
    true
}

drawerLayout.openDrawer(GravityCompat.START)

<intent-filter>
    <action android:name="android.intent.action.VIEW"/>
    <data android:scheme="myapp" android:host="profile"/>
</intent-filter>

NavHost(navController, startDestination = "home") {
    composable("home") { HomeScreen(navController) }
    composable("profile") { ProfileScreen(navController) }
}

class SingleLiveEvent<T> : MutableLiveData<T>() {
    private val pending = AtomicBoolean(false)

    override fun observe(owner: LifecycleOwner, observer: Observer<in T>) {
        super.observe(owner) { value ->
            if (pending.compareAndSet(true, false)) {
                observer.onChanged(value)
            }
        }
    }

    override fun setValue(value: T?) {
        pending.set(true)
        super.setValue(value)
    }
}

class MyViewModel : ViewModel() {
    val eventShowToast = SingleLiveEvent<String>()

    fun onButtonClicked() {
        eventShowToast.value = "Привет, это Toast!"
    }
}

viewModel.eventShowToast.observe(viewLifecycleOwner) { message ->
    Toast.makeText(requireContext(), message, Toast.LENGTH_SHORT).show()
}

class MyViewModel : ViewModel() {
    private val _events = MutableSharedFlow<UiEvent>()
    val events = _events.asSharedFlow()

    fun onButtonClicked() {
        viewModelScope.launch {
            _events.emit(UiEvent.ShowToast("Привет, это Toast!"))
        }
    }
}

sealed class UiEvent {
    data class ShowToast(val message: String) : UiEvent()
    object NavigateToNextScreen : UiEvent()
}

lifecycleScope.launchWhenStarted {
    viewModel.events.collect { event ->
        when (event) {
            is UiEvent.ShowToast -> Toast.makeText(context, event.iss.onessage, Toast.LENGTH_SHORT).show()
            is UiEvent.NavigateToNextScreen -> findNavController().navigate(R.id.nextFragment)
        }
    }
}

class EventWrapper<out T>(private val content: T) {
    private var hasBeenHandled = false

    fun getContentIfNotHandled(): T? {
        return if (hasBeenHandled) null else {
            hasBeenHandled = true
            content
        }
    }
}

data class UiState(val message: EventWrapper<String>? = null)

class MyViewModel : ViewModel() {
    private val _state = MutableStateFlow(UiState())
    val state = _state.asStateFlow()

    fun onButtonClicked() {
        _state.value = UiState(message = EventWrapper("Привет, это Toast!"))
    }
}

viewModel.state.collect { state ->
    state.message?.getContentIfNotHandled()?.let { message ->
        Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
    }
}

class AuthInterceptor(private val tokenProvider: TokenProvider) : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        val request = chain.request().newBuilder()
            .addHeader("Authorization", "Bearer ${tokenProvider.getToken()}")
            .addHeader("Accept", "application/json") 
            .build()
        return chain.proceed(request)
    }
}

val okHttpClient = OkHttpClient.Builder()
    .addInterceptor(AuthInterceptor(tokenProvider))
    .build()

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .client(okHttpClient)
    .addConverterFactory(GsonConverterFactory.create())
    .build()

class QueryInterceptor : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        val originalRequest = chain.request()
        val originalUrl = originalRequest.url

        val newUrl = originalUrl.newBuilder()
            .addQueryParameter("api_key", "YOUR_API_KEY")
            .build()

        val newRequest = originalRequest.newBuilder()
            .url(newUrl)
            .build()

        return chain.proceed(newRequest)
    }
}

val okHttpClient = OkHttpClient.Builder()
    .addInterceptor(QueryInterceptor())
    .build()

class AuthenticatorInterceptor(private val tokenProvider: TokenProvider) : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        var request = chain.request()
        var response = chain.proceed(request)

        if (response.code == 401) {
            // Получаем новый токен
            val newToken = tokenProvider.refreshToken()

            // Делаем новый запрос с обновлённым токеном
            val newRequest = request.newBuilder()
                .header("Authorization", "Bearer $newToken")
                .build()

            response.close() // Закрываем старый ответ
            response = chain.proceed(newRequest) // Повторяем запрос
        }

        return response
    }
}

val okHttpClient = OkHttpClient.Builder()
    .addInterceptor(AuthenticatorInterceptor(tokenProvider))
    .build()

val loggingInterceptor = HttpLoggingInterceptor().apply {
    level = HttpLoggingInterceptor.Level.BODY
}

val okHttpClient = OkHttpClient.Builder()
    .addInterceptor(loggingInterceptor)
    .build()

class BaseUrlInterceptor(private val urlProvider: UrlProvider) : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        val originalRequest = chain.request()
        val newUrl = urlProvider.getBaseUrl() + originalRequest.url.encodedPath

        val newRequest = originalRequest.newBuilder()
            .url(newUrl)
            .build()

        return chain.proceed(newRequest)
    }
}

val okHttpClient = OkHttpClient.Builder()
    .addInterceptor(BaseUrlInterceptor(urlProvider))
    .build()