import java.util.Comparator;
import java.util.Optional;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

public class CustomComparatorTest {

    static class CustomComparator<T> implements Comparator<T> {

        @Override
        public int compare(T arg0, T arg1) {
            return 0;
        }

        @Override
        public Comparator<T> thenComparing(Comparator<? super T> arg0) {
            return new CustomComparator<>();
        }

    }

    static <T> Optional<Comparator<T>> instanceOfCustomComparator(Comparator<T> comparator) {
        if (comparator instanceof CustomComparator) {
            return Optional.of(comparator);
        } else if (LambdaReflectionUtils.isMethodReference(comparator)) {
            Comparator<T> referencedMethodOwner = LambdaReflectionUtils.getReferencedMethodOwner(comparator);
            return instanceOfCustomComparator(referencedMethodOwner);
        } else if (LambdaReflectionUtils.isReverseComparator(comparator)) {
            Comparator<T> originalComparator = LambdaReflectionUtils.getOriginalComparator(comparator);
            return instanceOfCustomComparator(originalComparator);
        } else if (LambdaReflectionUtils.isThenComparingComparator(comparator)) {
            Comparator<T> firstComparator = LambdaReflectionUtils.getThenComparingFirstComparator(comparator);
            Optional<Comparator<T>> optionalFirstComparator = instanceOfCustomComparator(firstComparator);
            if (optionalFirstComparator.isPresent()) {
                Comparator<T> firstCustomComparator = optionalFirstComparator.get();
                Comparator<T> secondComparator = LambdaReflectionUtils.getThenComparingSecondComparator(comparator);
                Optional<Comparator<T>> optionalSecondComparator = instanceOfCustomComparator(secondComparator);
                if (optionalSecondComparator.isPresent()) {
                    Comparator<T> secondCustomComparator = optionalSecondComparator.get();
                    return Optional.of(firstCustomComparator.thenComparing(secondCustomComparator));
                }
            }
        }
        return Optional.empty();
    }

    @Test
    public void identifiesCustomComparator() {
        CustomComparator<String> comparator = new CustomComparator<>();
        Optional<Comparator<String>> instanceOfCustomComparator = instanceOfCustomComparator(comparator);
        Assertions.assertTrue(instanceOfCustomComparator.isPresent());
        Assertions.assertTrue(instanceOfCustomComparator.get() instanceof CustomComparator);
    }

    @Test
    public void identifiesMethodReference() {
        CustomComparator<String> comparator = new CustomComparator<>();
        Optional<Comparator<String>> instanceOfCustomComparator = instanceOfCustomComparator(comparator::compare);
        Assertions.assertTrue(instanceOfCustomComparator.isPresent());
        Assertions.assertTrue(instanceOfCustomComparator.get() instanceof CustomComparator);
    }

    @Test
    public void identifiesThenComparingWithMethodReference() {
        CustomComparator<String> comparator = new CustomComparator<>();
        Comparator<String> methodReference = comparator::compare;
        Optional<Comparator<String>> instanceOfCustomComparator = instanceOfCustomComparator(
                methodReference.thenComparing(methodReference));
        Assertions.assertTrue(instanceOfCustomComparator.isPresent());
        System.out.println(instanceOfCustomComparator.get().getClass().getName());
        Assertions.assertTrue(instanceOfCustomComparator.get() instanceof CustomComparator);
    }

    @Test
    public void identifiesThenComparingMethodReferenceWithMethodReference() {
        CustomComparator<String> comparator = new CustomComparator<>();
        Comparator<String> methodReference = comparator::compare;
        Optional<Comparator<String>> instanceOfCustomComparator = instanceOfCustomComparator(
                methodReference.thenComparing(methodReference)::compare);
        Assertions.assertTrue(instanceOfCustomComparator.isPresent());
        Assertions.assertTrue(instanceOfCustomComparator.get() instanceof CustomComparator);
    }

    @Test
    public void identifiesMultipleThenComparingMethodReferenceWithMethodReference() {
        CustomComparator<String> comparator = new CustomComparator<>();
        Comparator<String> methodReference = comparator::compare;
        Comparator<String> multipleThenComparing = methodReference.thenComparing(methodReference)::compare;
        Optional<Comparator<String>> instanceOfCustomComparator = instanceOfCustomComparator(
                multipleThenComparing.thenComparing(multipleThenComparing)::compare);
        Assertions.assertTrue(instanceOfCustomComparator.isPresent());
        Assertions.assertTrue(instanceOfCustomComparator.get() instanceof CustomComparator);
    }

    @Test
    public void identifiesMultipleThenComparingAndReversedMethodReferenceWithMethodReference() {
        CustomComparator<String> comparator = new CustomComparator<>();
        Comparator<String> methodReference = comparator::compare;
        Comparator<String> multipleThenComparing = methodReference
                .thenComparing(methodReference.reversed()::compare)::compare;
        Optional<Comparator<String>> instanceOfCustomComparator = instanceOfCustomComparator(
                multipleThenComparing.thenComparing(multipleThenComparing.reversed()::compare).reversed()::compare);
        Assertions.assertTrue(instanceOfCustomComparator.isPresent());
        Assertions.assertTrue(instanceOfCustomComparator.get() instanceof CustomComparator);
    }

}