// Person -> Car -> Insurance
public class Person {
    private Car car;
    public Car getCar() { return car; }
}
public class Car {
    private Insurance insurance;
    public Insurance getInsurance() { return insurance; }
}
public class Insurance {
    private String name;
    public String getName() { return name; }
}
// -----------------------------------
// 다음과 같이 자동차 보험 이름을 가져오려고 했을때,
// 무슨 문제가 있을까?
public String getCarInsuranceName(Person person) {
    return person.getCar().getInsurance().getName();
}

// 시도 1
// 하나라도 null 참조가 있으면 "Unknown" 리턴 
public String getCarInsuranceName(Person person) {
    if (person != null) {
        Car car = person.getCar();
        if (car != null) {
            Insurance insurance = car.getInsurance();
            if (insurance != null) {
                return insurance.getName();
            }
        }
    }
    return "Unknown";
}

// ---------------------------------------
// 시도 2
public String getCarInsuranceName(Person person) {
    if (person == null) {
        return "Unknown";
    }
    Car car = person.getCar();
    if (car == null) {
        return "Unknown";
    }
    Insurance insurance = car.getInsurance();
    if (insurance == null) {
        return "Unknown";
    }
    return insurance.getName();
}

// BEFORE
public class Person {
    private Car car;
    public Car getCar() { return car; }
}
public class Car {
    private Insurance insurance;
    public Insurance getInsurance() { return insurance; }
}
public class Insurance {
    private String name;
    public String getName() { return name; }
}
// ---------------------------------------------------------
// AFTER
public class Person2 {
    private Optional<Car> car; 
    public Optional<Car> getCar() { return car; }
}
public class Car2 {
    private Optional<Insurance> insurance;
    public Optional<Insurance> getInsurance() { return insurance; }
}
public class Insurance2 {
    private String name;
    public String getName() { return name; } // 보험 객체 존재시 이름이 반드시 있어야함으로, 리턴형이 Optional이 아니다.
}

// 1 빈 Optional 객체 만들기
Optional<Car2> optCar1 = Optional.empty();

// 2 null이 아닌 값으로 Optional 만들기
// null 이 아님을 확실할 경우 
Optional<Car2> optCar2 = Optional.of(car);

// 3 null값으로 Optional 만들기
Optional<Ca2r> optCar3 = Optional.ofNullable(car);

// BEFORE
String name = null;
if(insurance != null){
    name = insurance.getName();
}

// AFTER
// 보험 객체를 Optional로 만들고, 
// Optional로 감싸진 객체의 getName을 실행한다. 
// 보험 객체가 널이면 name에는 Optional empty가 들어가고 
// 값이 있을 경우 name에는 값이 들어간다. 
Optional<Insurance> optInsurance = Optional.ofNullable(insurance);
Optional<String> name = optInsurance.map(Insurance::getName);
// ------------------------------------
// 보험 이름: aaaa로
Insurance insurance1 = new Insurance("aaaa"); 
Optional<Insurance> optInsurance1 = Optional.ofNullable(insurance1);
Optional<String> 보험1 = optInsurance1.map(Insurance::getName);

// // 보험 이름: 지정 x
Insurance insurance2 = new Insurance();
Optional<Insurance> optInsurance2 = Optional.ofNullable(insurance2);
Optional<String> 보험2 = optInsurance2.map(Insurance::getName);

System.out.println(보험1); // 결과: Optional[aaaa]
System.out.println(보험2); // 결과: Optional.empty

// 컴파일 에러 예시
// map -> map -> map 을 호출하는데, Optional<Optional<Optional<Car>>> 이렇게 중첩된다
Optional<Person2> optPerson = Optional.of(person2);
Optional<String> name =
    optPerson.map(Person2::getCar)
    .map(Car2::getInsurance)
    .map(Insurance2::getName);

// 스트림의 flatMap과 비슷하게, 옵셔널에서 flatMap 사용하면 중첩이 풀리면서 일차원으로 만들어진다. 

// null 체크하는 if문 없이 코드 간결
public String getCarInsuranceName(Optional<Person> person) {
    return person.flatMap(Person::getCar) //  Optional을 이용한 참조 체인
        .flatMap(Car::getInsurance)
        .map(Insurance::getName)
        .orElse("Unknown"); //  값이 없다면
}
// ------------------------------------------
// 실행 예시
// 차 없는 사람 생성 
Person2 person = new Person2(Optional.empty()); 
Optional<Person2> optPerson = Optional.of(person);
System.out.println(getCarInsuranceName3(optPerson)); 
// 결과: Unknown

// 사람들이 가입한 보험회사 이름들을 리턴
 public static Set<String> getCarInsuranceNames(List<Person2> persons) {
     return persons.stream()
         .map(Person2::getCar) // 어떤 사람은 자동차를 가지지 않을 수도 있다.
         .map(optCar -> optCar.flatMap(Car2::getInsurance))
         .map(optIns -> optIns.map(Insurance2::getName))
         .flatMap(Optional::stream)
         .collect(Collectors.toSet()); // 중복 제거 기능도
 }

// ------------------------------------------------
System.out.println(getCarInsuranceNames(personList)); // [a, b, c]

// 총 7명 중에, 차 있는 4명 중 1명만 빼고 보험을 들었고 (보험명: a,b,c), 다른 3명은 차가 없다.
 static List<Person2> personList = List.of(
     new Person2(Optional.of(new Car2(Optional.of(new Insurance2("a"))))),
     new Person2(Optional.of(new Car2(Optional.of(new Insurance2("b"))))),
     new Person2(Optional.of(new Car2(Optional.of(new Insurance2("c"))))),
     new Person2(Optional.of(new Car2(Optional.empty())))),
     new Person2(Optional.empty()),
     new Person2(Optional.empty()),
     new Person2(Optional.empty())
 );

// ifPresentOrElse 예시
Optional<Integer> op = Optional.empty();
try {
    op.ifPresentOrElse(
        (value) -> {
            System.out.println( "Value is present, its: " + value);
        },
        () -> {
            System.out.println("Value is empty");
        });
} catch (Exception e) {
    System.out.println(e);
}
// 결과: Value is empty

// 사람에 따라 보험료 다를테니,
// 가장 저렴한 보험료 찾기
public Insurance findCheapestInsurance(Person person, Car car) {
    // 로직: 다양한 보험회사가 제공하는 서비스 조회 후 모든 결과 데이터 비교
    return cheapestCompany;
}

// 아래 구현 코드는 null 확인 코드와 크게 다른 점이 없다.
// 퀴즈: 개선해 보자
public Optional<Insurance> nullSafeFindCheapestInsurance (
 	   Optional<Person> person, Optional<Car> car) {
    if (person.isPresent() && car.isPresent()) {
        return Optional.of(findCheapestInsurance(person.get(), car.get()));
    } else {
        return Optional.empty();
    }
}

public Optional<Insurance> nullSafeFindCheapestInsurance(
    Optional<Person> person, Optional<Car> car) {
    return person.flatMap(p -> car.map(c -> findCheapestInsurance(p, c)));
}

// 보험회사 이름 CambridgeInsurance인지 확인 
Insurance insurance = ...;
if(insurance != null && "CambridgeInsurance".equals(insurance.getName())){
    System.out.println("ok");
}

// Optional으로 재구현 
Optional<Insurance> optInsurance = ...;
optInsurance.filter(insurance ->
                    "CambridgeInsurance".equals(insurance.getName()))
    .ifPresent(x -> System.out.println("ok"));]

public String getCarInsuranceName(Optional<Person> person, int minAge)

public String getCarInsuranceName(Optional<Person> person, int minAge) {
    return person.filter(p -> p.getAge() >= minAge)
        .flatMap(Person::getCar)
        .flatMap(Car::getInsurance)
        .map(Insurance::getName)
        .orElse("Unknown");
}

Object value = map.get("key");
// ------------------------------------
// get의 시그니처를 고칠 순 없지만, 받은값을 감쌀 수 있다. 
Optional<Object> value = Optional.ofNullable(map.get("key"));

// 이와 같은 유틸리티 클래스르 많이 만들자!
public static Optional<Integer> stringToInt(String s) {
    try {
        return Optional.of(Integer.parseInt(s));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
}

// stringToInt("hello") -> 에러 나지 않는다. 옵셔널의 empty를 받는다.

// 프로그램 설정 인수로 프로퍼티 전달 예제 
// 키를 주고 안에 값이 양수인것만 값을 가져오자. otherwise 0
@Test
public void testMap() {
    Properties props = new Properties();
    props.setProperty("a", "5");
    props.setProperty("b", "true");
    props.setProperty("c", "-3");

    assertEquals(5, readDurationImperative(props, "a"));
    assertEquals(0, readDurationImperative(props, "b"));
    assertEquals(0, readDurationImperative(props, "c"));
    assertEquals(0, readDurationImperative(props, "d"));
}

public static int readDurationImperative(Properties props, String name) {
    String value = props.getProperty(name);
    if (value != null) {
        try {
            int i = Integer.parseInt(value);
            if (i > 0) { // 양수 인지 확인 
                return i;
            }
        } catch (NumberFormatException nfe) { // 숫자 아닐 경우 
        }
    }
    return 0;
}

@Test
public void testMap() {
    Properties props = new Properties();
    props.setProperty("a", "5");
    props.setProperty("b", "true");
    props.setProperty("c", "-3");

    assertEquals(5, readDurationWithOptional(props, "a"));
    assertEquals(0, readDurationWithOptional(props, "b"));
    assertEquals(0, readDurationWithOptional(props, "c"));
    assertEquals(0, readDurationWithOptional(props, "d"));
}

public static int readDurationWithOptional(Properties props, String name) {
    return Optional.ofNullable(props.getProperty(name))
        .flatMap(OptionalUtility::stringToInt)
        .filter(i -> i > 0)
        .orElse(0);
}