package de.hdmstuttgart.movietracker.model   // like Java, but a file may contain several classes and functions

import kotlinx.coroutines.flow.Flow

fun main() {                       // top-level function, no class needed
    val title = "Dr. No"           // read-only (like final), type String is inferred
    var year = 1962                // mutable, type Int
    year += 1
    val poster: String? = null     // explicit type when it cannot be inferred (here: nullable)

    println("$title ($year)")                     // string template: $variable
    println("Title length: ${title.length}")     // ${expression}
}

// if returns a value, there is no ternary operator
val label = if (movies.isEmpty()) "No movies saved" else "${movies.size} movies"

fun maxOf(a: Int, b: Int) = if (a > b) a else b

// when replaces switch: no break, no fall-through, any type, ranges, else is required for expressions
val decade = when (movie.year.toInt()) {
    in 1962..1969 -> "Sixties"
    in 1970..1979 -> "Seventies"
    1995, 1997 -> "Brosnan years"
    else -> "Later"
}

// when without argument replaces an if / else-if chain (typical in Compose)
when {
    uiState.isLoading -> LinearProgressIndicator()
    uiState.errorMessage != null -> Text(text = uiState.errorMessage)
    else -> MovieList(movieList = uiState.movieList, onMovieClick = onMovieClick)
}

val titles = listOf("Dr. No", "From Russia with Love", "Goldfinger")

for (title in titles) println(title)                 // for-each, there is no C-style for (int i = 0; ...)

for (index in titles.indices) {                      // iterate over the indices
    println("$index: ${titles[index]}")
}

for ((index, title) in titles.withIndex()) {         // index and element at once
    println("$index: $title")
}

for (i in 1..5) print(i)               // 12345  inclusive range
for (i in 1..<5) print(i)              // 1234   end exclusive (also: until)
for (i in 5 downTo 1 step 2) print(i)  // 531

val year = 1964
if (year in 1962..1967) println("Connery era")       // in checks membership

var title: String = "Dr. No"
title = null                          // compile error: String is not nullable

var poster: String? = null            // nullable type
poster.length                         // compile error: poster might be null
poster?.length                        // safe call: Int?, null if poster is null
poster?.length ?: 0                   // Elvis operator: default value when null
poster!!.length                       // not-null assertion: throws NPE if null, avoid it

if (poster != null) println(poster.length)     // smart cast: poster is String inside the block

// SearchViewModel: OMDb omits "Search" when nothing was found, so SearchResponse.search is List<Movie>?
val movies: List<Movie> = response.search ?: emptyList()

// let runs the block only when the value is not null (SearchScreen)
searchUiState.errorMessage?.let { message ->
    Text(text = message, color = MaterialTheme.colorScheme.error)
}

// primary constructor and properties in one line, getters and setters are generated
class OfflineMovieRepository(private val movieDao: MovieDao)

class SearchUiState(val movieList: List<Movie>, var isLoading: Boolean = false)

val state = SearchUiState(emptyList())   // no `new`
println(state.movieList.size)            // property access calls the getter
state.isLoading = true                   // assignment calls the setter (only var has one)

// Classes are final by default. Inheritance and interfaces use `:`, overriding needs `override`
class HomeViewModel(private val movieRepository: MovieRepository) : ViewModel() {
    override fun onCleared() { /* ... */ }
}

interface MovieRepository {
    fun getAllMovies(): Flow<List<Movie>>          // abstract by default
}

open class Shape                                    // `open` allows subclassing
class Circle(val radius: Double) : Shape()

// model/Movie.kt (Room and Gson annotations left out)
data class Movie(
    val imdbId: String,
    val title: String,
    val year: String,
    val poster: String
)

val drNo = Movie("tt0055928", "Dr. No", "1962", "https://...")
println(drNo)                                   // Movie(imdbId=tt0055928, title=Dr. No, year=1962, poster=...)
drNo == Movie("tt0055928", "Dr. No", "1962", "https://...")   // true: == calls equals(), === compares references
val remake = drNo.copy(year = "2026")           // copy with some properties changed
val (id, title) = drNo                          // destructuring via component1(), component2()

// object: a singleton, created on first access. Replaces a class with a private constructor + static instance
object Routes {
    const val HOME = "home"
    const val SEARCH = "search"
}
navController.navigate(Routes.SEARCH)

// companion object: the "static" part of a class (MovieDatabase.kt)
abstract class MovieDatabase : RoomDatabase() {
    companion object {
        const val DATABASE_NAME = "movie_database"

        fun getDatabase(context: Context): MovieDatabase { /* ... */ }
    }
}
val db = MovieDatabase.getDatabase(context)     // called like a static method

enum class SortOrder { TITLE, YEAR }      // like Java enums, may have properties and functions

// sealed: all implementations are known at compile time, `when` needs no else branch
sealed interface SearchUiState {
    data object Loading : SearchUiState
    data class Success(val movieList: List<Movie>) : SearchUiState
    data class Error(val message: String) : SearchUiState
}

@Composable
fun SearchResult(uiState: SearchUiState, onMovieClick: (Movie) -> Unit) {
    when (uiState) {
        is SearchUiState.Loading -> LinearProgressIndicator()
        is SearchUiState.Success -> MovieList(movieList = uiState.movieList, onMovieClick = onMovieClick)
        is SearchUiState.Error -> Text(text = uiState.message)    // smart cast to Error
    }
}

// default values replace overloaded methods
@Composable
fun MovieItem(movie: Movie, onMovieClick: (Movie) -> Unit, modifier: Modifier = Modifier) { /* ... */ }

MovieItem(movie, onMovieClick)                                      // modifier uses its default
MovieItem(movie = movie, onMovieClick = onMovieClick)               // named arguments
MovieItem(movie, onMovieClick, modifier = Modifier.padding(8.dp))   // positional, then named

// Every Compose function works like this. Text() has 15 parameters, you name the two you need:
Text(text = movie.title, style = MaterialTheme.typography.titleMedium)

// single-expression function: no braces, no return, type can be inferred
fun sum(a: Int, b: Int) = a + b
override fun getAllMovies(): Flow<List<Movie>> = movieDao.getAllMovies()

fun deleteMovie(movie: Movie): Unit { /* ... */ }    // Unit is void and can be omitted

// Add a function to an existing class without inheriting from it. `this` is the receiver object
fun String.toYearOrNull(): Int? = take(4).toIntOrNull()

"1962".toYearOrNull()         // 1962
"N/A".toYearOrNull()          // null

// ui/AppViewModelProvider.kt: a readable name for a long cast
fun CreationExtras.movieTrackerApplication(): MovieTrackerApplication =
    (this[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY] as MovieTrackerApplication)

// used when the ViewModels are created
val Factory = viewModelFactory {
    initializer {
        HomeViewModel(movieTrackerApplication().container.movieRepository)
    }
}

// A function type: takes a Movie, returns nothing (Unit)
val onMovieClick: (Movie) -> Unit = { movie -> println(movie.title) }
onMovieClick(drNo)                               // call it like a function

val titles = movies.map { it.title }             // `it` is the implicit name of a single parameter

// Higher-order function: a function that takes a function as parameter (ui/composables/MovieList.kt)
@Composable
fun MovieList(movieList: List<Movie>, onMovieClick: (Movie) -> Unit) { /* ... */ }

MovieList(movieList = movies, onMovieClick = { movie -> viewModel.deleteMovie(movie) })
MovieList(movieList = movies, onMovieClick = viewModel::deleteMovie)   // function reference

var counter = 0
val increment: () -> Unit = { counter++ }        // lambdas may modify captured vars (no "effectively final")

// If the last parameter is a function, the lambda may be written after the parentheses
Button(onClick = { counter++ }, content = { Text("Button") })
Button(onClick = { counter++ }) { Text("Button") }               // same call

// If the lambda is the only argument, the parentheses may be omitted
val connery = movies.filter({ it.actor == "Sean Connery" })
val connery = movies.filter { it.actor == "Sean Connery" }       // same call

// A Compose UI is nested function calls with trailing lambdas
Column(modifier = Modifier.padding(16.dp)) {        // content: @Composable () -> Unit
    Text(text = "Clicked $counter times")
    Button(onClick = { counter++ }) {
        Text(text = "Button")
    }
}

LazyColumn {                                        // content: LazyListScope.() -> Unit
    items(items = movieList) { movie ->             // items() is a function of LazyListScope
        MovieItem(movie = movie, onMovieClick = onMovieClick)
    }
}

val bondMovies = listOf(                             // List<Movie>: read-only interface
    Movie("Dr. No", "1962", "Sean Connery"),         // Movie(title, year, actor) of assignment 2
    Movie("Goldfinger", "1964", "Sean Connery"),
    Movie("GoldenEye", "1995", "Pierce Brosnan")
)
val watched = mutableListOf<Movie>()                 // MutableList<Movie>
watched.add(bondMovies[0])
watched += bondMovies[1]                             // operator overloading: plusAssign

bondMovies.filter { it.title.contains(searchText, ignoreCase = true) }   // List<Movie>
bondMovies.map { it.title }                          // List<String>
bondMovies.first { it.year == "1964" }               // Goldfinger, throws if nothing matches
bondMovies.firstOrNull { it.year == "2000" }         // null instead of an exception
bondMovies.any { it.actor == "Pierce Brosnan" }      // true
bondMovies.sortedBy { it.year }                      // new sorted list, the original is untouched
bondMovies.groupBy { it.actor }                      // Map<String, List<Movie>>
bondMovies.forEach { println(it.title) }

val routes = mapOf("home" to "Home", "search" to "Search")   // Map<String, String>, `to` creates a Pair

// apply: configure and return the object (app/build.gradle.kts reads the API key from local.properties)
val localProperties = Properties().apply {
    load(rootProject.file("local.properties").inputStream())
}

// also: do something on the side, return the object (MovieDatabase.getDatabase)
Room.databaseBuilder(context, MovieDatabase::class.java, DATABASE_NAME)
    .build()
    .also { instance = it }

// let: only for non-null values
response.error?.let { message -> Log.w("Search", message) }

// with: several calls on one object
with(movie) { println("$title ($year)") }

// `by` forwards get and set of a property to a delegate object

// lazy: computed on first access, then cached (MovieTrackerApplication.kt)
override val movieRepository: MovieRepository by lazy {
    OfflineMovieRepository(MovieDatabase.getDatabase(context).movieDao())
}

// Compose: MutableState<Int> stores the value in .value ...
val counterState = remember { mutableStateOf(0) }
counterState.value++

// ... the delegate reads and writes .value for you, counter looks like a plain Int
var counter by remember { mutableStateOf(0) }       // needs import androidx.compose.runtime.getValue / setValue
counter++                                           // becomes counterState.value = counterState.value + 1

// Android: a ViewModel, created lazily and scoped to the Activity
private val viewModel: HomeViewModel by viewModels()

// A suspend function can pause and resume later without blocking a thread.
// It may only be called from another suspend function or from a coroutine.
@Dao
interface MovieDao {
    @Insert(onConflict = OnConflictStrategy.IGNORE)
    suspend fun insert(movie: Movie)                    // Room runs the query on a background thread
}

interface MovieApi {
    @GET("/")
    suspend fun searchMovies(@Query("s") searchString: String): SearchResponse   // Retrofit does the HTTP call
}

// A coroutine is started with launch { } inside a scope. viewModelScope is cancelled with the ViewModel.
class SearchViewModel(private val movieRepository: MovieRepository) : ViewModel() {
    fun saveMovie(movie: Movie) {
        viewModelScope.launch {
            movieRepository.insert(movie)    // reads like sequential code, the UI thread is never blocked
        }
    }
}

// Kotlin calls Java as if it were Kotlin. Retrofit and Gson are Java libraries (MovieTrackerApplication.kt)
val retrofit = Retrofit.Builder()
    .baseUrl(MovieApi.BASE_URL)
    .addConverterFactory(GsonConverterFactory.create())
    .build()
val api = retrofit.create(MovieApi::class.java)      // Java Class<T> is written ::class.java

// Java getters and setters appear as properties
val clicks = intent.getIntExtra("clicks", 0)         // normal method call
intent.action = Intent.ACTION_VIEW                   // calls setAction(), reading calls getAction()

// Platform types: Java does not tell whether a value may be null
val name = intent.getStringExtra("name")             // type String! -> treat it as String?
val length = name?.length ?: 0

// Java calls Kotlin: top-level functions become static methods of a class <FileName>Kt.
// @JvmStatic, @JvmOverloads and @JvmField fine-tune the generated API.