# install openjdk 11, you probably need 21 for Burp, too.
sudo apt install msopenjdk-11
git clone https://github.com/fwcd/kotlin-language-server
cd kotlin-language-server
./gradlew :server:installDist
mv ~/.vscode-server/data/User/globalStorage/fwcd.kotlin/langServerInstall/server server-backup
# assuming /kotlin-language-server is where you built the server
cp -r ~/kotlin-language-server/server/build/install/server ~/.vscode-server/data/User/globalStorage/fwcd.kotlin/langServerInstall/

"kotlin.languageServer.path":
    "~/.vscode-server/data/User/globalStorage/fwcd.kotlin/langServerInstall/server/bin/kotlin-language-server"

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
Content-Length: 127

{"jsonrpc":"2.0","method":"window/logMessage","params":{"type":3,"message":"main      Kotlin Language Server: Version 1.3.14"}}Content-Length: 108

{"jsonrpc":"2.0","method":"window/logMessage","params":{"type":3,"message":"main      Connected to client"}}

fun divide(a: Int, b: Int): Result<Double> {
  return when (b) {
    0 -> Result.failure(ArithmeticException("Division by zero"))
    else -> Result.success(a.toDouble() / b)
  }
}

// Simple default value - returns the success value, or 0.0 for failure.
val result = divide(10, 2).getOrElse { 0.0 }
println(result) // 5.0

// Handle error and provide fallback - the lambda receives the exception for
// custom handling
val safeResult = divide(10, 0).getOrElse { exception ->
  println("Error: ${exception.message}")
  Double.NaN // Return NaN for division by zero
}

// Returns the success value or null if it failed - enables null-safety patterns
val result = divide(10, 2).getOrNull()
if (result != null) {
    println("Success: $result")
} else {
    println("Operation failed")
}

// With elvis operator - provides default value when result is null
val safeResult = divide(10, 0).getOrNull() ?: 0.0

// Unwraps success value or throws the original exception - use with try/catch
try {
    val result = divide(10, 2).getOrThrow()
    println("Result: $result")
} catch (e: Exception) {
    println("Caught exception: ${e.message}")
}

// Direct propagation - throws the original exception
val result = divide(10, 0).getOrThrow()

// Propagate via getOrElse lambda
val safeResult = divide(10, 0).getOrElse { exception ->
    println("Logging error before re-throwing")
    throw exception
}

// Most idiomatic - return Result and let caller decide
fun processData(): Result<Double> {
  return divide(10, 0)
    .map { it * 2 }     // Transform if successful
    .mapCatching { value ->
      if (value < 0) throw IllegalStateException("Negative result")
      value
    }
}

// Caller handles the final Result
val finalResult = processData().getOrThrow() // or .getOrElse { ... }

// Pattern match on Result type to handle success and failure cases differently
when (val result = divide(10, 0)) {
  is Result.Success -> {
    println("Success: ${result.getOrNull()}")
  }
  is Result.Failure -> {
    val exception = result.exceptionOrNull()
    println("Failed: ${exception?.message}")
  }
}

// Execute side effects (logging, etc.) without consuming the Result - chainable
divide(10, 2)
  .onSuccess { value -> 
    println("Division successful: $value")
  }
  .onFailure { exception ->
    println("Division failed: ${exception.message}")
  }

// Using Kotlin's default 'it' parameter - more concise
divide(10, 2)
  .onSuccess { println("Division successful: $it") }  // 'it' = success value
  .onFailure { println("Error: ${it.message}") }      // 'it' = exception

// Using explicit parameter names - more readable for complex lambdas
divide(10, 2)
  .onSuccess { value -> println("Division successful: $value") }
  .onFailure { exception -> println("Error: ${exception.message}") }

// Chaining side effects with other operations - the Result flows through unchanged
val finalResult = divide(10, 2)
  .onSuccess { println("Step 1: Division = $it") }
  .map { it * 3 }
  .onSuccess { println("Step 2: Multiplication = $it") }
  .mapCatching { value ->
    if (value > 10) value else throw IllegalArgumentException("Value too small")
  }
  .onSuccess { println("Step 3: Validation passed = $it") }
  .onFailure { println("Error occurred: ${it.message}") }
  .getOrElse { 0.0 }

// Check Result status without consuming the value - useful for conditional logic
val result = divide(10, 0)

if (result.isSuccess) {
  println("Operation succeeded")
} else if (result.isFailure) {
  println("Operation failed")
}

val result = divide(20, 4)
  .map { it * 2 }  // Transform success value
  .map { it.toInt() }  // Chain transformations
  .getOrElse { -1 }

println(result) // 10

// mapCatching for operations that might throw
val chainedResult = divide(10, 2)
  .mapCatching { value ->
    if (value > 3) value else throw IllegalArgumentException("Too small")
  }
  .getOrElse { 0.0 }

fun getUserById(id: Int): Result<User> {
  return Database.query("SELECT * FROM users WHERE id = ?", id)
    .mapCatching { rows ->
      rows.firstOrNull() ?: throw NoSuchElementException("User not found")
    }
    .mapCatching { row ->
      User(
        id = row["id"] as Int,
        name = row["name"] as String,
        email = row["email"] as String
      )
    }
}

// Usage
val user = getUserById(123)
  .onFailure { Log.toError("Failed to get user: ${it.message}") }
  .getOrElse { User.ANONYMOUS }