package com.izouma.dingdong.web;

import com.izouma.dingdong.annotations.Searchable;
import com.izouma.dingdong.dto.PageQuery;
import com.izouma.dingdong.utils.DateTimeUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;

import javax.persistence.criteria.Predicate;
import java.lang.reflect.Field;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.regex.Pattern;

public class BaseController {
    public static PageRequest toPageRequest(PageQuery pageQuery) {
        PageRequest pageRequest;
        if (StringUtils.isNotEmpty(pageQuery.getSort())) {
            List<Sort.Order> orders = new ArrayList<>();
            for (String sortStr : pageQuery.getSort().split(";")) {
                String direction = "asc";
                String prop = sortStr;
                if (sortStr.contains(",asc") || sortStr.contains(",desc")) {
                    prop = sortStr.split(",")[0];
                    direction = sortStr.split(",")[1];
                }
                orders.add("asc".equals(direction) ? Sort.Order.asc(prop) : Sort.Order.desc(prop));
            }
            pageRequest = PageRequest.of(pageQuery.getPage(), pageQuery.getSize(), Sort.by(orders));
        } else {
            pageRequest = PageRequest.of(pageQuery.getPage(), pageQuery.getSize());
        }
        return pageRequest;
    }

    public static <T> Specification<T> toSpecification(PageQuery pageQuery, Class queryClass) {
        return (Specification<T>) (root, criteriaQuery, criteriaBuilder) -> {
            List<Predicate> and = new ArrayList<>();
            pageQuery.getQuery().forEach((property, value) -> {
                if (value == null) {
                    return;
                }
                if (String.class.equals(value.getClass())) {
                    if (StringUtils.isEmpty((String) value)) {
                        return;
                    }
                    if ("true".equals(value) || "false".equals(value)) {
                        and.add(criteriaBuilder
                                .and(criteriaBuilder.equal(root.get(property), Boolean.valueOf((String) value))));
                        return;
                    }
                }
                if (property.equals("createdAt") && !StringUtils.isEmpty(value.toString())) {
                    DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
                    and.add(criteriaBuilder.between(root.get(property), LocalDateTime
                            .parse(value.toString().split(",")[0], df), LocalDateTime
                            .parse(value.toString().split(",")[1], df)));
                } else {
                    try {
                        Field field = queryClass.getDeclaredField(property);
                        Class fieldType = field.getType();
                        if (Enum.class.isAssignableFrom(fieldType)) {
                            if (value instanceof Collection) {
                                if (!((Collection) value).isEmpty()) {
                                    List list = new ArrayList();
                                    for (Object o : ((Collection) value)) {
                                        list.add(Enum.valueOf(fieldType, String.valueOf(o)));
                                    }
                                    and.add(root.get(property).in(list));
                                }
                            } else if (value instanceof String && StringUtils.isNotEmpty((String) value)) {
                                if (((String) value).contains(",")) {
                                    String[] arr = ((String) value).split(",");
                                    List list = new ArrayList();
                                    for (String s : arr) {
                                        list.add(Enum.valueOf(fieldType, s));
                                    }
                                    and.add(root.get(property).in(list));
                                } else {
                                    and.add(criteriaBuilder.and(criteriaBuilder
                                            .equal(root.get(property), Enum
                                                    .valueOf(fieldType, String.valueOf(value)))));
                                }
                            }
                        } else if (LocalDateTime.class == fieldType) {
                            if (value instanceof List) {
                                List list = (List) value;
                                if (list.size() == 1) {
                                    LocalDateTime start = DateTimeUtils
                                            .toLocalDateTime((String) list.get(0), "yyyy-MM-dd HH:mm:ss");
                                    and.add(criteriaBuilder.greaterThanOrEqualTo(root.get(property), start));
                                } else if (list.size() == 2) {
                                    LocalDateTime end = DateTimeUtils
                                            .toLocalDateTime((String) list.get(1), "yyyy-MM-dd HH:mm:ss");
                                    and.add(criteriaBuilder.lessThanOrEqualTo(root.get(property), end));
                                }
                            } else if (value instanceof String && Pattern
                                    .matches("^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2},\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}$", (String) value)) {
                                String[] arr = ((String) value).split(",");
                                LocalDateTime start = DateTimeUtils.toLocalDateTime(arr[0], "yyyy-MM-dd HH:mm:ss");
                                and.add(criteriaBuilder.greaterThanOrEqualTo(root.get(property), start));
                                LocalDateTime end = DateTimeUtils.toLocalDateTime(arr[1], "yyyy-MM-dd HH:mm:ss");
                                and.add(criteriaBuilder.lessThanOrEqualTo(root.get(property), end));
                            } else {
                                and.add(criteriaBuilder.and(criteriaBuilder.equal(root.get(property), DateTimeUtils
                                        .toLocalDateTime((String) value, "yyyy-MM-dd HH:mm:ss"))));
                            }
                        } else if (LocalDate.class == fieldType) {
                            if (value instanceof List) {
                                List list = (List) value;
                                if (list.size() == 1) {
                                    LocalDate start = DateTimeUtils
                                            .toLocalDate((String) list.get(0), "yyyy-MM-dd");
                                    and.add(criteriaBuilder.greaterThanOrEqualTo(root.get(property), start));
                                } else if (list.size() == 2) {
                                    LocalDate end = DateTimeUtils
                                            .toLocalDate((String) list.get(1), "yyyy-MM-dd");
                                    and.add(criteriaBuilder.lessThanOrEqualTo(root.get(property), end));
                                }
                            } else if (value instanceof String && Pattern
                                    .matches("^\\d{4}-\\d{2}-\\d{2},\\d{4}-\\d{2}-\\d{2}$", (String) value)) {
                                String[] arr = ((String) value).split(",");
                                LocalDate start = DateTimeUtils.toLocalDate(arr[0], "yyyy-MM-dd");
                                and.add(criteriaBuilder.greaterThanOrEqualTo(root.get(property), start));
                                LocalDate end = DateTimeUtils.toLocalDate(arr[1], "yyyy-MM-dd");
                                and.add(criteriaBuilder.lessThanOrEqualTo(root.get(property), end));
                            } else {
                                and.add(criteriaBuilder.and(criteriaBuilder.equal(root.get(property), DateTimeUtils
                                        .toLocalDateTime((String) value, "yyyy-MM-dd"))));
                            }
                        } else {
                            and.add(criteriaBuilder.and(criteriaBuilder.equal(root.get(property), value)));
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                }
            });
            if (StringUtils.isNotEmpty(pageQuery.getSearch())) {
                Field[] fields = queryClass.getDeclaredFields();
                List<Predicate> or = new ArrayList<>();
                try {
                    or.add(criteriaBuilder.equal(root.get("id"), pageQuery.getSearch()));
                } catch (Exception ignored) {
                }
                for (Field field : fields) {
                    Searchable annotation = field.getAnnotation(Searchable.class);
                    if (annotation == null) {
                        continue;
                    }
                    if (!annotation.value()) {
                        continue;
                    }

                    or.add(criteriaBuilder.like(root.get(field.getName()), "%" + pageQuery.getSearch() + "%"));
                }
                and.add(criteriaBuilder.or(or.toArray(new Predicate[0])));
            }
            return criteriaBuilder.and(and.toArray(new Predicate[0]));
        };
    }


      /*  return (Specification<T>) (root, criteriaQuery, criteriaBuilder) -> {
            List<Predicate> and = new ArrayList<>();
            pageQuery.getQuery().forEach((property, value) -> {
                if (value == null) {
                    return;
                }
                if (String.class.equals(value.getClass())) {
                    if (StringUtils.isEmpty((String) value)) {
                        return;
                    }
                }


                try {
                    Field field = queryClass.getDeclaredField(property);
                    Class fieldType = field.getType();
                    if (Enum.class.isAssignableFrom(fieldType)) {
                        if (value instanceof Collection) {
                            if (!((Collection) value).isEmpty()) {
                                List list = new ArrayList();
                                for (Object o : ((Collection) value)) {
                                    list.add(Enum.valueOf(fieldType, String.valueOf(o)));
                                }
                                and.add(root.get(property).in(list));
                            }
                        } else if (value instanceof String && StringUtils.isNotEmpty((String) value)) {
                            if (((String) value).contains(",")) {
                                String[] arr = ((String) value).split(",");
                                List list = new ArrayList();
                                for (String s : arr) {
                                    list.add(Enum.valueOf(fieldType, s));
                                }
                                and.add(root.get(property).in(list));
                            } else {
                                and.add(criteriaBuilder.and(criteriaBuilder
                                        .equal(root.get(property), Enum
                                                .valueOf(fieldType, String.valueOf(value)))));
                            }
                        }
                    }
                } catch (NoSuchFieldException e) {
                    e.printStackTrace();
                }

                and.add(criteriaBuilder.and(criteriaBuilder.equal(root.get(property), value)));
            });
            if (StringUtils.isNotEmpty(pageQuery.getSearch())) {
                Field[] fields = queryClass.getDeclaredFields();
                List<Predicate> or = new ArrayList<>();
                try {

                    or.add(criteriaBuilder.equal(root.get("id"), pageQuery.getSearch()));
                } catch (Exception e) {
                }
                for (Field field : fields) {
                    Searchable annotation = field.getAnnotation(Searchable.class);
                    if (annotation == null) {
                        continue;
                    }
                    if (!annotation.value()) {
                        continue;
                    }
                    or.add(criteriaBuilder.like(root.get(field.getName()), "%" + pageQuery.getSearch() + "%"));
                }
                and.add(criteriaBuilder.or(or.stream().toArray(Predicate[]::new)));
            }
            return criteriaBuilder.and(and.stream().toArray(Predicate[]::new));
        };*/

}
