import entity.*;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.logging.Logger;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;


/**
 * @Author 伍冠源
 * @Date 2021年5月10日
 * @Description
 */
public class OptionalTest {

 Logger logger = Logger.getGlobal();

 private User createNewUser() {
 logger.info("Creating New User");
 return new User("extra@gmail.com", 1234);
 }

 @Test(expected = NoSuchElementException.class)
 public void whenCreateEmptyOptional_thenNull() {
 Optional<User> emptyOpt = Optional.empty();
 emptyOpt.get();
 }

 @Test(expected = NullPointerException.class)
 public void whenCreateOfEmptyOptional_thenNullPointerException() {
 User user = null;
 Optional<User> opt = Optional.of(user);
// Optional<User> opt = Optional.ofNullable(user);
 }

 @Test
 public void whenCreateOfNullableOptional_thenOk() {
 String name = "John";
 Optional<String> opt = Optional.ofNullable(name);
 assertEquals("John", opt.get());
 }

 @Test
 public void whenCheckIfPresent_thenOk() {
 User user = new User("john@gmail.com", 1234);
 Optional<User> opt = Optional.ofNullable(user);
 assertTrue(opt.isPresent());
// assertEquals(user.getName(), opt.get().getName());
 opt.ifPresent(u -> assertEquals(user.getName(), u.getName()));
 }

 @Test
 public void whenEmptyValue_thenReturnDefault() {
 User user = null;
 User user2 = new User("anna@gmail.com", 1234);
 User result = Optional.ofNullable(user).orElse(user2);

 assertEquals(user2.getName(), result.getName());
 }

 @Test
 public void whenValueNotNull_thenIgnoreDefault() {
 User user = new User("john@gmail.com", 1234);
 User user2 = new User("anna@gmail.com", 5678);
 User result = Optional.ofNullable(user).orElse(user2);

 assertEquals("john@gmail.com", result.getName());
 }

 @Test
 public void givenEmptyValue_whenCompare_thenOk() {
 User user = null;
 logger.info("Using orElse");
 User result = Optional.ofNullable(user).orElse(createNewUser());
 logger.info("Using orElseGet");
 User result2 = Optional.ofNullable(user).orElseGet(() -> createNewUser());
 }

 @Test
 public void givenPresentValue_whenCompare_thenOk() {
 User user = new User("john@gmail.com", 1234);
 logger.info("Using orElse");
 User result = Optional.ofNullable(user).orElse(createNewUser());
 logger.info("Using orElseGet");
 User result2 = Optional.ofNullable(user).orElseGet(() -> createNewUser());
 }

 @Test(expected = IllegalArgumentException.class)
 public void whenThrowException_thenOk() {
 User user = null;
 User result = Optional.ofNullable(user)
 .orElseThrow(() -> new IllegalArgumentException());
 }

 @Test
 public void whenMap_thenOk() {
 User user = new User("anna@gmail.com", 1234);
 String email = Optional.ofNullable(user)
 .map(u -> u.getName()).orElse("default@gmail.com");

 assertEquals(email, user.getName());
 }

 @Test
 public void whenFlatMap_thenOk() {
 User user = new User("anna@gmail.com", 1234);
 user.setPosition("Developer");
 String position = Optional.ofNullable(user)
 .flatMap(u -> u.getPosition()).orElse("default");

 assertEquals(position, user.getPosition().get());
 }

 @Test
 public void whenFilter_thenOk() {
 User user = new User("anna@gmail.com", 1234);
 Optional<User> result = Optional.ofNullable(user)
 .filter(u -> u.getName() != null && u.getName().contains("@"));

 assertTrue(result.isPresent());
 }

 @Test
 public void whenChaining_thenOk() {
 User user = new User("anna@gmail.com", 1234);

// String result = Optional.ofNullable(user)
// .flatMap(u -> u.getAddress())
// .flatMap(a -> a.getCountry())
// .map(c -> c.getIsocode())
// .orElse("default");

 String result = Optional.ofNullable(user)
 .flatMap(User::getAddress)
 .flatMap(Address::getCountry)
 .map(Country::getIsocode)
 .orElse("default");
 assertEquals(result, "default");
 }

 @Test
 public void whenChaining_thenOk2() {
 User2 user2 = new User2("wgy", "25", null);

 String isoCode = Optional.ofNullable(user2)
 .map(User2::getAddress)
 .map(Address2::getCountry)
 .map(Country::getIsocode)
 .orElse("default");
 assertEquals(isoCode, "default");
 }

 @Test
 public void whenChaining_thenOk3() {
 User2 user2 = new User2("wgy", "25", null);
 String isocode = null;
 Optional.ofNullable(user2)
 .map(User2::getAddress)
 .map(Address2::getCountry)
 .map(Country::getIsocode)
 .ifPresent(s -> {
 isocode = s.toUpperCase();
 });
 }

 @Test
 public void whenEmptyStream_thenReturnDefaultOptional() {
 List<User> users = new ArrayList<>();
 User user = users.stream().findFirst().orElse(new User("default", 134));

 assertEquals(user.getName(), "default");
 }

}