package com.qnfhq.common.entity;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import jakarta.validation.constraints.Max;
import jakarta.validation.constraints.Min;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;

import java.lang.reflect.Field;
import java.time.LocalDateTime;
import java.util.Arrays;

@Data
public class BaseQueryDTO {

    @Min(value = 1, message = "页码不能小于1")
    private Integer pageNum = 1;

    @Min(value = 1, message = "每页条数不能小于1")
    @Max(value = 100, message = "每页条数不能大于100")
    private Integer pageSize = 10;

    private String orderField;
    private String order = "desc";

    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime createTimeStart;

    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime createTimeEnd;

    /**
     * 获取MyBatis Plus的Page对象
     */
    public <T> Page<T> getPage() {
        int size = Math.min(pageSize != null ? pageSize : 10, 100);
        int num = pageNum != null ? pageNum : 1;

        Page<T> page = new Page<>(num, size);

        if (StrUtil.isNotBlank(orderField)) {
            if ("asc".equalsIgnoreCase(order)) {
                page.addOrder(OrderItem.asc(orderField));
            } else {
                page.addOrder(OrderItem.desc(orderField));
            }
        } else {
            page.addOrder(OrderItem.desc("id"));
        }

        return page;
    }

    /**
     * 自动添加所有非空字段的等值查询条件
     */
    public <T> QueryWrapper<T> timeQuery() {
        QueryWrapper<T> wrapper = new QueryWrapper<>();

        // 处理时间范围
        if (createTimeStart != null) {
            wrapper.ge("create_time", createTimeStart);
        }
        if (createTimeEnd != null) {
            wrapper.le("create_time", createTimeEnd);
        }

        // 自动添加所有非空字段
        addEq(wrapper);

        return wrapper;
    }

    /**
     * 自动添加所有非空字段的查询条件
     * 字段名会自动转换为下划线格式
     */
    private <T> void addEq(QueryWrapper<T> wrapper) {
        Field[] fields = this.getClass().getDeclaredFields();

        for (Field field : fields) {
            // 跳过BaseQueryDTO中的基础字段
            if (isBaseField(field.getName())) {
                continue;
            }

            try {
                field.setAccessible(true);
                Object value = field.get(this);

                if (isValidValue(value)) {
                    // 驼峰转下划线作为数据库列名
                    String columnName = StrUtil.toUnderlineCase(field.getName());
                    wrapper.eq(columnName, value);
                }
            } catch (IllegalAccessException e) {
                // 忽略无法访问的字段
            }
        }
    }

    /**
     * 判断是否为BaseQueryDTO的基础字段
     */
    private boolean isBaseField(String fieldName) {
        return Arrays.asList("pageNum", "pageSize", "orderField", "order",
                "createTimeStart", "createTimeEnd","serialVersionUID").contains(fieldName);
    }

    /**
     * 判断字段值是否有效（非空且不等于-1）
     */
    private boolean isValidValue(Object value) {
        if (value == null) {
            return false;
        }

        if (value instanceof String) {
            return StrUtil.isNotBlank((String) value) && !"-1".equals(value);
        }

        if (value instanceof Number) {
            // 对于数字，-1通常表示"全部"，不添加条件
            return !value.equals(-1);
        }

        return true;
    }
}