dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'com.querydsl:querydsl-jpa'
    annotationProcessor "com.querydsl:querydsl-apt:${dependencyManagement.importedProperties['querydsl.version']}:jpa"
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
}

@Getter(value = AccessLevel.PROTECTED)
public abstract class QueryDslSupport {

	private final Class<?> domainClass;

	private JPAQueryFactory queryFactory;
	private Querydsl querydsl;

	public QueryDslSupport(Class<?> domainClass) {
		notNull("domainClass", domainClass);
		this.domainClass = domainClass;
	}

	@Autowired
	public void setEntityManager(EntityManager entityManager) {
		val jpaEntityInformationSupport = JpaEntityInformationSupport.getEntityInformation(domainClass, entityManager);
		val resolver = SimpleEntityPathResolver.INSTANCE;
		val path = resolver.createPath(jpaEntityInformationSupport.getJavaType());

		querydsl = new Querydsl(entityManager, new PathBuilder<>(path.getType(), path.getMetadata()));
		queryFactory = new JPAQueryFactory(entityManager);
	}

	protected <T> JPAQuery<T> select(Expression<T> expr) {
		return getQueryFactory().select(expr);
	}

	protected <T> JPAQuery<T> selectFrom(EntityPath<T> from) {
		return getQueryFactory().selectFrom(from);
	}

	protected <T> JPADeleteClause delete(EntityPath<T> path) {
		return getQueryFactory().delete(path);
	}

	protected <T> JPAUpdateClause update(EntityPath<T> path) {
		return getQueryFactory().update(path);
	}

	protected <T> boolean exists(Function<JPAQuery<Integer>, JPAQuery<T>> query) {
		return query.apply(getQueryFactory().selectOne())
				.fetchFirst() != null;

	}

	protected <T> Page<T> applyPagination(
			Pageable pageable,
			Supplier<JPAQuery<T>> contentQuery,
			Supplier<JPAQuery<Long>> countQuery
	) {

		val content = getQuerydsl()
				.applyPagination(pageable, contentQuery.get())
				.fetch();

		return PageableExecutionUtils.getPage(content, pageable, countQuery.get()::fetchOne);
	}

	protected <T> Slice<T> applySlicing(Pageable pageable, Supplier<JPAQuery<T>> query) {
		val contents = querydsl
				.applySorting(
						pageable.getSort(),
						query.get()
								.offset(pageable.getOffset())
								.limit(pageable.getPageSize() + 1)
				)
				.fetch();

		var hasNext = false;
		if (contents.size() > pageable.getPageSize()) {
			hasNext = true;
			int lastIndex = contents.size() - 1;
			contents.remove(lastIndex);
		}
		return new SliceImpl<>(contents, pageable, hasNext);
	}

}