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");
    }

}