import cn.hutool.core.lang.Console;
import cn.hutool.core.lang.Opt;
import entity.*;
import org.junit.jupiter.api.Test;

import java.util.Optional;
import java.util.function.Supplier;

/**
 * <a href="https://mp.weixin.qq.com/s/kAo8FjlaHKmMK-CjBK1RpA">参考1</a>
 * <a href="https://juejin.cn/post/6844904154075234318#comment">参考2</a>
 *
 * @author guanyuan.wu.sz
 * @since 2022年8月15日
 */
public class OptionalTest3 {
 @Test
 public void test() {
 User2 user1 = null;
 User2 user2 = new User2("user2", "1", null);

 User2 user3 = Optional.ofNullable(user1).orElse(new User2("user3", "10", null));
 User2 user6 = Optional.ofNullable(user2).orElse(new User2("user3", "10", null));
 Console.log("user3=>{},user6=>{}", user3, user6);

 User2 user4 = Optional.ofNullable(user1).orElse(createUser());
 User2 user5 = Optional.ofNullable(user2).orElse(createUser());

 User2 user7 = Optional.ofNullable(user1).orElseGet(() -> createUser());
 }

 @Test
 void orElseTest() {
 User2 user = new User2("john@gmail.com", "1234");
 Console.log("Using orElse");
 User2 result = Optional.ofNullable(user).orElse(createNewUser());
 Console.log("Using orElseGet");
 User2 result2 = Optional.ofNullable(user).orElseGet(() -> createNewUser());

 Console.log(result);
 Console.log(result2);
 }

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

 @Test
 void orTest() {
 User2 user1 = null;
 Optional<User2> or = Optional.ofNullable(user1).or(() -> Optional.of(new User2("user1", "1")));
 Console.log(or);
 }

 @Test
 public void emptyTest() {
 Optional<String> optEmpty = Optional.empty();
 String s = optEmpty.get();
 Console.log(s);
 }

 @Test
 public void isPresentTest() {
 Person person = new Person();
 person.setAge(2);
 if (Optional.ofNullable(person).isPresent()) {
 //写不为空的逻辑
 System.out.println("不为空");
 } else {
 //写为空的逻辑
 System.out.println("为空");
 }
 }

 @Test
 public void filterTest() {
 Person person = new Person();
 person.setAge(2);
 Optional<Person> optionalPerson = Optional.ofNullable(person).filter(p -> p.getAge() > 50);
 Console.log(optionalPerson);
 }

 @Test
 public void mapTest() {
 Person person = new Person();
 person.setAge(2);
 String optName = Optional.ofNullable(person).map(p -> person.getName()).orElse("name为空");
 Console.log(optName);
 }

 @Test
 public void flatMapTest() {
 Person person = new Person(null, 10);
 person.setAge(2);
 String s = Optional.ofNullable(person)
 .flatMap(p -> Optional.ofNullable(p.getName())).orElse("person2");
 Console.log(s);
 }

 @Test
 public void orElseGetTest() {
 Person person = null;
 Optional<Supplier<Person>> sup = Optional.of(Person::new);
 Optional<Person> person3 = Optional.of(new Person("person3", 3));
 //调用get()方法,此时才会调用对象的构造方法,即获得到真正对象
 Person person1 = Optional.ofNullable(person).orElseGet(sup.get());
 Person person2 = Optional.ofNullable(person).orElseGet(person3::get);
 Person person4 = Optional.ofNullable(person).orElseGet(() -> new Person("person 4", 4));
 Console.log(person1);
 Console.log(person2);
 Console.log(person4);
 }


 @Test
 public void test2() throws Exception {
 User2 user = null;
 String city = getCity(user);
 }

 @Test
 public void test3() throws Exception {
 User2 user = new User2();
 Optional.ofNullable(user)
 .ifPresent(u -> {
 dosomething(u);
 });

 }

 private void dosomething(Object u) {
 System.out.println(u);
 }

 public User2 createUser() {
 System.out.println("createUser executed!");
 User2 user = new User2();
 user.setName("zhangsan");
 return user;
 }


 //public String getCity(User user) throws Exception {
 // if (user != null) {
 // if (user.getAddress() != null) {
 // Address address = user.getAddress();
 // if (address.getCity() != null) {
 // return address.getCity();
 // }
 // }
 // }
 // throw new Exception("取值错误");
 //}

 public String getCity(User2 user) throws Exception {
 return Optional.ofNullable(user)
 .map(User2::getAddress)
 .map(Address2::getCity)
 .orElseThrow(() -> new Exception("取值错误"));
 }

 /*场景1:
 在service层中 查询一个对象,返回之后判断是否为空并做处理

 //查询一个对象
 Member member = memberService.selectByIdNo(request.getCertificateNo());
 //使用ofNullable加orElseThrow做判断和操作
 Optional.ofNullable(member).orElseThrow(() -> new ServiceException("没有查询的相关数据"));*/

 /* 场景2:
 我们可以在dao接口层中定义返回值时就加上Optional
 例如:
 我使用的是jpa,其他也同理

 public interface LocationRepository extends JpaRepository<Location, String> {
 Optional<Location> findLocationById(String id);
 }

 然在是Service中

 public TerminalVO findById(String id) {
 //这个方法在dao层也是用了Optional包装了
 Optional<Terminal> terminalOptional = terminalRepository.findById(id);
 //直接使用isPresent()判断是否为空
 if (terminalOptional.isPresent()) {
 //使用get()方法获取对象值
 Terminal terminal = terminalOptional.get();
 //在实战中,我们已经免去了用set去赋值的繁琐,直接用BeanCopy去赋值
 TerminalVO terminalVO = BeanCopyUtils.copyBean(terminal, TerminalVO.class);
 //调用dao层方法返回包装后的对象
 Optional<Location> location = locationRepository.findLocationById(terminal.getLocationId());
 if (location.isPresent()) {
 terminalVO.setFullName(location.get().getFullName());
 }
 return terminalVO;
 }
 //不要忘记抛出异常
 throw new ServiceException("该终端不存在");
 }*/
}