// Optional Type Overhead
Optional<String> strOpt = null; // Compile OK

Optional<String> strOpt = Optional.empty(); // Compile OK

strOpt = null; // Compile OK

strOpt == null; // Compile OK => true

strOpt = Optional.of("gary"); // Compile OK

strOpt = Optional.ofNullable("gary"); // Compile OK

// cannot direct assign a value
strOpt = "gary"; // Compile error: Type mismatch
  
// cannot direct compare with a value
strOpt.equal("gary"); // Compile error: Type mismatch
  
strOpt.equal(Optional.of("gary")); // Compile OK, true
  

// unwrap and compare the wrapped value
if(strOpt.isPresent()) {
  final String str = strOpt.get();
  return str.equal("gary");
} 
else {
  return false
}

// do something when the wrapped value is not null
strOpt.ifPresent(str -> {
  doSth(str)
});
  
// Easy to be mis-used
// in some case,
// null is a good representation of nothing instead of empty String
String str = strOpt.orElse("");

// throw NullPointerException if the wrapped value is null
String str = strOpt.get();

// pattern matching in Option Type
val usernameOpt: Option[String] = Some("gary")

usernameOpt match {
    case Some("gary") => println("matched gary!")
    case Some("peter") => println("matched peter!")
    case Some(username) => println("found ${username}, but no username is matched")
    case None => println("No username is found")
}

// Kotlin NullableType is different from java.util.Optional or scala.Option
// it is NOT a Value Type

var str: String? = null

str == null // Compile OK! => true 

str = "gary"  // Compile OK! 

str == null // Compile OK! => false
str == "gary" // Copmile OK! => true

// Optional chaining
str?.toUpperCase() == "GARY" // Compile OK! => true
str?.toLowerCase()?.capitalize() == "Gary" // Compile OK! => true

// Default value `?:`
val username = str ?: "N/A" // username is String now!

// Kotlin Smart cast - if
if(str is String) {
   // the Type of str is smart casted to `String`!!!
   println(str.toUpperCase())
}

// Kotlin Smart cast - when
when(str) {
  is String -> println(str.toUpperCase()) 
  else -> println("str is null")
}

// Java 9
final Map<String,Integer> abc = Map.of("a",1, "b", 2, "c", 3);

// Java >= 5
final Map<String,Integer> abc = new HashMap<String, Integer>() {{  
    put("a",1);
    put("b",2);
    put("c",3);
}};

final Integer c = abc.get("c");

// Question: 
// If you are asked to refactor from Map<String,Integer> to Map<String,String>,
// try to estimate the efforts!

// Ugly work around to save time (compared to method overload)
void doSomething(
  @NotNull String fname,
  @NotNull String lname,
  @Nullable String addr,
  @Nullable Gender gender
) {  
  requireNonNull(fname);
  requireNonNull(lname);
  if(addr == null) addr = "N/A";
  if(gender == null) gender = Gender.Unknown;
  // do sth
}
String lastName = "lastName";
String firstName = "firstName";
String gender = Gender.Male;
String address = "address";

// As we know the implementation will provide default value for null
// so we type null in the parameter...
// code-smell? WTF by new comer?
// Question: What is the null suppose to be?
doSomething(firstName,lastName,null,null);  
doSomething(firstName,lastName,address,null);  
doSomething(firstName,lastName,null,gender);  
doSomething(firstName,lastName,address,gender);

// without named paramenter...
// Can you notify the bug when you type out this?
// it is safe to compile but logically error 
// bug: lastName and firstName are swapped
doSomething(lastName,firstName,address, gender); 

// To avoid null and expose a better API
// without default and namged argument, method overloading is the only way
void doSomething(String fname, String lname) {
  doSomething(fname,lname,"N/A", Gender.Unknown);
}
void doSomething(String fname, String lname, String addr) {
  doSomething(fname,lname,addr, Gender.Unknown);
}
void doSomething(String fname, String lname, Gender gender) {
  doSomething(fname,lname,"N/A", gender);
}
void doSomething(String fname, String lname, String addr, Gender gender) {
  // do sth
}

// Question: 
// if you asked to add one more arugment let say "Phone"
// how many overloading is needed?
  

// Default argument
fun doSomething(
  fname: String,
  lname: String,
  addr: String = "N/A",
  gender: Gender = Gender.Unknown
) {
  // do something that really need fname,lname, addr, gender..
}

val firstName = "firstName"
val lastName = "lastName"
val address = "Address"
val gender = Gender.Male

// Normally you can do this
doSomething(firstName, lastName, address, gender) // OK!
doSomething(firstName, lastName, address)  // OK!
doSomething(firstName, lastName)  // OK!

// Fail, compile error! Type mismatch! Expected String type
doSomething(firstName, lastName, gender) 

// It can be solved by Named Argument
// with Named Argument
doSomething(
  fname = firstName,
  lname = lastName,
  addr = address,
  gender = gender
) // OK!

// skip the address (3rd argument)
doSomething(
  fname = firstName,
  lname = lastName,
  gender = gender
) // OK!

// Order is not important!!
doSomething(
  addr = address,
  lname = lastName,
  fname = firstName
) // OK!

// Fail! compile error: lname is required
// because lname has no default value
doSomething(
  addr = address,
  fname = firstName
)

// Ask yourself:
// Is it possible to achieve the same level of conciseness in Java?

// please focus on the function name & declaration 

// As we all know, String is a final class and we can't extend
class StringUtils {
  public static TypeA toTypeA(String str)
}

// Assume TypeA is from third party library that you can't extend
class TypeAUtils {
  public static Double calculateResult(TypeA a) 
}

// Similar to String, you can't extend Double
class DoubleUtils {
  public static Double toTwoDecimalPlace(Double d) 
}

String someString = "someString";

// The execution order is not as same as to our reading direction(top-to-bottom)
// it is difficult to read
final Double typeAResultWithRounding = 
  DoubleUtils.toTwoDecimalPlace(
    TypeAUtils.calculateResult(
      StringUtils.toTypeA(someString)
    )
  );

// flatten it?  better to read but more unnessecary variables are created
final TypeA typeA = StringUtils.toTypeA(someString);
final Double typeAResult = TypeAUtils.calculateResult(typeA);
final Double typeAResultWithRounding = DoubleUtils.toTwoDecimalPlace(typeArResult);
  
// Question: 
// How do a new comer would know to use exactly these three Utils?
// Normally, they would ask someone or implement a duplicate one for their use case.

// Kotlin

// extension, give toTypeA() functionality to String
fun String.toTypeA(): TypeA { 
  return TypeA(str = this)
}

// give calculateResult() functionality to TypeA 
fun TypeA.calculateResult(): Double {
  return this.str.length + 0.123456789
}

// give toTwoDecimalPlace() functionality to Double
fun Double.toTwoDecimalPlace(): Double {
  return BigDecimal(this).setScale(2, RoundingMode.HALF_UP).toDouble()
}
val someString = "someString"

// Better than Utils pattern
// 1. By-design chainning from top-to-bottom which is better for reading
// 2. Extension are statically import(Unlike Swift), extension usages are tracable.
// 3. IDE autocomplete works well to identify extensions on a Type,
val typeAResultwithRounding = someString
                                .toTypeA()
                                .calculateResult()
                                .toTwoDecimalPlace()

// Even new comer would see the extra functionality in the IDE auto-complete list!!

data class User(
  // primary construtor
  val id: UUID,
  val username: String,
  val firstName: String? = null,
  val lastName: String? = null,
  val address: String? = null,
  val isEmailVerified: Boolean = false
) {
  // getter only
  var fullName: String get() {
    return "${firstName} ${lastName}"
  }

  // a function inside a User
  fun doSth() {
    println("do something")
  }
}

// By default, Kotlin has generated very useful constructor for a data class
// with the power of the Named and Default Argument
// We can use it in the following ways

// firstName, lastName, address, isEmailVerified is not required
User(
  id = UUID.randomUUID(),
  username = "garylo123"
)

// but you can still override the default value
val gary = User(
  id = UUID.randomUUID(),
  username = "garylo123",
  firstName = "Gary",
  lastName = "LO",
  address = "HK Somewhere"
)

println(gary.username) // print "garylo123"
println(gary.fullName) // print "Gary LO"

gary.doSth() // print "do something"

// developer-friendly for debuging
println(gary) // print "User(id=229c7b64-7dd3-4b5f-80bd-c88dc15ed13e, username=garylo123, firstName=Gary, lastName=LO, address=HK Somewhere, isEmailVerified=false)"



// Data class provide a handy function .copy for pure immutable object
// if we want to update the address of `gary`, we create a new copy
// original gary won't be mutated 
val updatedUser = gary.copy(address = "Hong Kong Somewhere")

// Only used for holding the Data. 
class MutableJavaDataObject {
  @NotNull UUID id;
  @NotNull String username;
  @Nullable String firstName;
  @Nullable String lastName;
  @Nullable String address;
  bool isEmailVerified = false
}

// Problem?
// 1. All properties are mutable
// 2. No Constructor, how do others know `id` and `username` should NOT be null?
// 3. In Java, One file can only contain one Class.
//    Even a class is just a few line....

// MutableJavaDataObject, https://gist.github.com/gaplo917/deee7a16bf9f60c69cfedb47884820fa

// created by empty contructor
MutableJavaDataObject mjdo = new MutableJavaDataObject();

// assign the value directly
mjdo.id = UUID.randomUUID();
mjdo.address = "Hong Kong";

// printing the class reference is useless in 99% of time
System.out.print(mjdo) // print "MutableJavaDataObject@xxxxxxx"

// bugs? missed to assign the mjdo.username but it is compile time safe


// Question:
// A safer way? Builder pattern? Seriously!? for every data object? 

// Using Kotlin would cost you the same amount of time 
// that you write MutableJavaDataObject (work around),
// but gives much cleaner, robuster and safer `data class`

class User {
    var name: String? = null
      get() {
        println("getting a username = ${field}")
        return field
      }
      set(nName) {
        println("changing to a new username ${nName} from ${field}")
        field = nName 
      }
  
}

fun main() {
    val user = User()
    
    user.name = "Gary LO"
    
    println("We get the username = ${user.name}")
    
    // Expected console output: 
    // changing to a new username Gary LO from null
    // getting a username = Gary LO
    // We get the username = Gary LO
}

// `to` is a infix function to create a Pair<L,R>
val pair = 1 to "one"

// decompose the pair
val (num,str) = pair

val list = listOf(1,2,3,4,5)

// destructing the list
val (a,b,c) = list

println("a = $a, b = $b, c = $c") 
// a = 1, b = 2, c = 3

// already include in kotlin std-lib
val head = list.head
val tail = list.tail

println(head) // 1
println(tail) // [2,3,4,5]

data class User(val id: Int, val name: String, val address: String)

val user = User(id = 1, name = "GARY LO", address = "Hong Kong")

// Destructing order is import!!
val (userId, userName, userAddress) = user

println("id = $userId, name = $userName, address = $userAddress")
// id = 1, name = GARY LO, address = Hong Kong

val list = listOf(1,2,3,4,5)

// destructing the list
val (a,b,c) = list

println("a = $a, b = $b, c = $c") 
// a = 1, b = 2, c = 3

// already include in kotlin std-lib
val head = list.head
val tail = list.tail

println(head) // 1
println(tail) // [2,3,4,5]

// Kotlin - currying function example

fun doCurrying(first: Int): (Int) -> ((Int, Int) -> Int) -> Int {
  return { second -> { f -> f(first,second) } }
}

val add = { a: Int, b: Int -> a + b }
val multiply = { a: Int, b: Int -> a * b }
val minus = { a: Int, b: Int -> a - b }

val curriedFour = doCurrying(4)
val curriedFourFive = curriedFour(5)

curriedFourFive(add) // 9
curriedFourFive(multiply) // 20
curriedFourFive(minus) // -1

// Every Thing is an expression
val input = 1

val result = if(input == 1) "Equal to one" else "Not Equal to One"

val result2 = when(input) {
   1 -> "Equal to one"
   else -> "Not equal to one"
}

val result3 = try {
    input / 0
    "Can be calculated"
  } catch(e: ArithmeticException) {
    "Can't be calculated"
  }

println(result)  // Equal to one
println(result2) // Equal to one
println(result3) // Can't be calculated