package com.example.mpstudy.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.experimental.Accessors;

import java.time.LocalDateTime;

@Data
@Accessors(chain = true) // 支持链式调用
// `@TableName("tb_user")`: Mybatis-Plus 注解
// 用于将 `UserDO` 类与数据库中的 `tb_user` 表进行显式绑定。
@TableName("tb_user")
public class UserDO {
    // 注意：我们在这里提前设置ID，因为数据库表中的id字段是主键，MP会使用默认的雪花算法生成一个全局唯一的ID，不方便我们的测试
    @TableId(type = IdType.AUTO)
    private Long id;

    /**
     * 姓名
     */
    private String name;

    /**
     * 年龄
     */
    private Integer age;

    /**
     * 邮箱
     */
    private String email;

    /**
     * 乐观锁版本号
     */
    private Integer version;

    /**
     * 逻辑删除标志(0-未删除;1-已删除)
     */
    private Integer isDeleted;

    /**
     * 创建时间
     */
    private LocalDateTime gmtCreate;

    /**
     * 修改时间
     */
    private LocalDateTime gmtModified;
}

package com.example.mpstudy.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.mpstudy.domain.UserDO;
// `extends BaseMapper<UserDO>`: 这是 Mybatis-Plus 的强大所在
// 通过继承 `BaseMapper` 并指定泛型为 `UserDO`，我们的 `UserMapper` 接口瞬间拥有了一整套强大且经过性能优化的 CRUD 方法
public interface UserMapper extends BaseMapper<UserDO> {
    // 目前无需编写任何方法
}

package com.example.mpstudy;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.example.mpstudy.mapper") // <-- 添加此行注解
public class MpStudyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MpStudyApplication.class, args);
    }

}

package com.example.mpstudy.mapper;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

// @SpringBootTest: 标记这是一个Spring Boot的测试类，会加载整个Spring应用上下文
@SpringBootTest
class UserMapperTest {

    // @Autowired: 从Spring容器中自动注入UserMapper的实例
    @Autowired
    private UserMapper userMapper;

    // 后续的所有测试方法都将写在这个类中
}

// UserMapperTest.java

@Test
void testInsert() {
    System.out.println("----- 开始执行 insert 测试 -----");
    UserDO user = new UserDO();
    user.setName("Prorise");
    user.setAge(30);
    user.setEmail("prorise@example.com");

    int result = userMapper.insert(user);
    System.out.println("受影响的行数: " + result);
    System.out.println("插入后的用户ID: " + user.getId());
    System.out.println("----- insert 测试执行完毕 -----");
}

@Test
   void testDelete() {
       System.out.println("----- 开始执行 delete 测试 -----");
       int resultById = userMapper.deleteById(1L);
       System.out.println("deleteById 受影响行数: " + resultById);

       // 2. 根据多个ID批量删除
       List<Long> idsToDelete = Arrays.asList(4L, 5L);
       int resultBatch = userMapper.deleteBatchIds(idsToDelete);
       System.out.println("deleteBatchIds 受影响行数: " + resultBatch);


       // 3. 根据Map中的条件删除 (多个条件之间是 AND 关系)
       // 删除 name = 'Tom' AND age = 28 的记录
       HashMap<String, Object> columnMap = new HashMap<>();
       columnMap.put("name", "Tom"); // key是数据库中的列名，不是Java属性名
       columnMap.put("age", 28);
       int resultMap = userMapper.deleteByMap(columnMap);
       System.out.println("deleteByMap 受影响行数: " + resultMap);

   }

// UserMapperTest.java

@Test
void testUpdate() {
    // 确保ID为 4 的用户存在
    UserDO user = new UserDO();
    user.setId(4L); // 指定要更新的记录ID
    user.setAge(22); // 只设置age，其他字段为null

    // 执行更新
    int result = userMapper.updateById(user);
    System.out.println("updateById 受影响行数: " + result);
}

// UserMapperTest.java

@Test
void testSelect() {
    // 1. 根据主键ID查询
    UserDO user = userMapper.selectById(5L);
    System.out.println("selectById 查询结果: " + user);

    // 2. 查询所有记录
    // selectList(null) 传入null作为查询条件，代表无条件查询
    List<UserDO> userList = userMapper.selectList(null);
    System.out.println("selectList 查询到的总数: " + userList.size());
    userList.forEach(System.out::println);

    // 3. 根据多个ID批量查询
    List<Long> idsToSelect = Arrays.asList(4L, 5L);
    List<UserDO> usersByIds = userMapper.selectBatchIds(idsToSelect);
    System.out.println("selectBatchIds 查询到的结果:");
    usersByIds.forEach(System.out::println);

    // 4. 根据Map中的条件查询
    // 查询 name = 'Sandy' 的记录
    Map<String, Object> columnMap = new HashMap<>();
    columnMap.put("name", "Sandy"); // key是数据库中的列名
    List<UserDO> usersByMap = userMapper.selectByMap(columnMap);
    System.out.println("selectByMap 查询到的结果:");
    usersByMap.forEach(System.out::println);
}

package com.example.mpstudy.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.example.mpstudy.domain.UserDO;

public interface UserService extends IService<UserDO> {
    // IService<UserDO> 泛型接口，提供了大量便捷的业务层方法，如 save, list, page 等。
    // 通过继承它，UserService 立刻就拥有了这些通用的业务方法。
    
    // 后续我们可以在这里定义 User 相关的、IService 中没有的特定业务方法。
    // 例如：void lockUser(Long userId);
}

package com.example.mpstudy.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.mpstudy.domain.UserDO;
import com.example.mpstudy.mapper.UserMapper;
import com.example.mpstudy.service.UserService;
import org.springframework.stereotype.Service;

// @Service: 将该类标记为Spring的Service组件，交由IoC容器管理。
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, UserDO> implements UserService {
    // ServiceImpl 是 IService 的官方实现类，封装了对BaseMapper的调用。
    // 继承 ServiceImpl<M, T> 需要提供两个泛型：
    // 1. M: 当前Service对应的Mapper接口类型，这里是 UserMapper。
    // 2. T: 当前Service对应的实体类型，这里是 UserDO。
    
    // 继承之后，所有IService中定义的方法都已自动实现，无需我们手动编写。
    // 我们只需要在这里实现 UserService 中自定义的业务方法即可。
}

package com.example.mpstudy.service;

import com.example.mpstudy.domain.UserDO;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    void testGetAndList() {
        // 1. 根据ID查询 (等同于 userMapper.selectById)
        UserDO user = userService.getById(5L);
        System.out.println("getById 查询结果: " + user);

        // 2. 查询所有 (等同于 userMapper.selectList(null))
        List<UserDO> list = userService.list();
        System.out.println("list 查询到的总数: " + list.size());
    }
}

@Test
void testBatchOperations() {
    // 1. 批量新增
    List<UserDO> userList = List.of(
            new UserDO().setName("BatchUser1").setAge(25).setEmail("b1@example.com"),
            new UserDO().setName("BatchUser2").setAge(26).setEmail("b2@example.com")
    );
    boolean saveResult = userService.saveBatch(userList);
    System.out.println("批量新增是否成功: " + saveResult);
}

// UserServiceTest.java

@Test
void testSaveOrUpdate() {
    // 1. ID为null，执行插入操作
    UserDO newUser = new UserDO().setName("NewOrUpdateUser").setAge(40).setEmail("nou@example.com");
    boolean insertSuccess = userService.saveOrUpdate(newUser);
    System.out.println("插入操作是否成功: " + insertSuccess + ", 用户ID: " + newUser.getId());
    
    // 2. ID不为null，执行更新操作
    // 使用上一步插入的ID
    UserDO existingUser = new UserDO().setId(newUser.getId()).setAge(41);
    boolean updateSuccess = userService.saveOrUpdate(existingUser);
    System.out.println("更新操作是否成功: " + updateSuccess);
}

package com.example.mpstudy.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.mpstudy.domain.UserDO;
import org.apache.ibatis.annotations.Param; // 引入MyBatis的Param注解

public interface UserMapper extends BaseMapper<UserDO> {
    // 继承了 BaseMapper 的同时，我们可以在这里定义任何自定义的方法。
    
    /**
     * 根据姓名查询用户信息
     * @param name 姓名
     * @return 用户信息
     */
    UserDO selectByName(@Param("name") String name);
}

// UserMapperTest.java (添加新的测试方法)

@Test
void testCustomMethod() {
    System.out.println("----- 开始执行自定义方法测试 -----");
    UserDO user = userMapper.selectByName("Tom");
    System.out.println("查询到的 Tom 的信息: " + user);
    System.out.println("----- 自定义方法测试执行完毕 -----");
}

package com.example.mpstudy.domain;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.experimental.Accessors;

@Data
@Accessors(chain = true)
// 使用 @TableName("tb_user") 明确告诉MP，此类对应数据库中的 "tb_user" 表。
// 这是最常见也是最重要的映射注解之一。
@TableName("tb_user")
public class UserDO {
    // ... 属性 ...
}

// UserDO.java
import com.baomidou.mybatisplus.annotation.TableField;

// ...

/**
 * 邮箱
 */
// @TableField 的 value 属性用于指定数据库中对应的列名
@TableField("user_email")
private String email;

// UserDO.java
import com.baomidou.mybatisplus.annotation.TableField;

// ...

/**
 * 用户的角色描述，这个字段在 tb_user 表中不存在。
 */
// @TableField(exist = false) 告诉MP，在执行任何数据库操作时（如INSERT, UPDATE, SELECT），
// 都要完全忽略这个 'userRole' 属性，它只是一个普通的Java类成员。
@TableField(exist = false)
private String userRole;

// UserDO.java
import com.baomidou.mybatisplus.annotation.TableField;

// ...

/**
 * 假设我们有一个密码字段
 */
// @TableField(select = false) 表示此字段在数据库中存在，
// 但在使用 MP 内置的查询方法（如 selectList）时，不会被包含在 SELECT 的字段列表中。
// 注意：INSERT 和 UPDATE 操作仍然会包含此字段。
@TableField(select = false)
private String password;

// UserDO.java
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;

// ...

// @TableId 用于标识主键字段
// type = IdType.AUTO: 指定主键生成策略为数据库自增。
// 当我们执行 insert 操作时, MP不会为ID赋值，而是依赖数据库生成，并在插入后将生成的值回填到实体对象中。
@TableId(type = IdType.AUTO)
private Long id;

// 示例：将所有用户的年龄增加1岁
LambdaUpdateWrapper<UserDO> wrapper = new LambdaUpdateWrapper<>();
wrapper.setSql("age = age + 1");
userMapper.update(null, wrapper);

package com.example.mpstudy;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.example.mpstudy.domain.UserDO;
import com.example.mpstudy.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class WrapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    void testBasicQueries() {
        // 1. 查询年龄大于20岁，并且ID小于等于4的用户
        LambdaQueryWrapper<UserDO> wrapper = new LambdaQueryWrapper<>();
        wrapper.gt(UserDO::getAge, 20)      // gt: greater than, 大于
               .le(UserDO::getId, 4L);     // le: less than or equal, 小于等于

        System.out.println("--- 年龄大于20且ID小于等于4的用户 ---");
        List<UserDO> users1 = userMapper.selectList(wrapper);
        users1.forEach(System.out::println);


        // 2. 查询姓名为 "Tom" 的用户
        // new 一个新的Wrapper, 或者调用 clear() 清空上一个Wrapper的条件
        wrapper.clear(); 
        wrapper.eq(UserDO::getName, "Tom"); // eq: equal, 等于
        
        System.out.println("\n--- 姓名为Tom的用户 ---");
        UserDO tom = userMapper.selectOne(wrapper); // selectOne: 查询单个结果，如果结果超过1个会报错
        System.out.println(tom);


        // 3. 查询年龄在20到30岁之间的用户
        wrapper.clear();
        wrapper.between(UserDO::getAge, 20, 30); // between(字段, 起始值, 结束值)
        
        System.out.println("\n--- 年龄在20-30岁之间的用户 ---");
        List<UserDO> users3 = userMapper.selectList(wrapper);
        users3.forEach(System.out::println);
    }
}

@Test
void testLikeAndNullQueries() {
    // 1. 模糊查询: 查询姓名中包含 "m" 的用户
    LambdaQueryWrapper<UserDO> wrapperLike = new LambdaQueryWrapper<>();
    // like(字段, 值): 对应SQL --> LIKE '%m%'
    wrapperLike.like(UserDO::getName,"m");
    // likeLeft(字段, 值): 对应SQL --> LIKE '%e' (以e结尾)
    // likeRight(字段, 值): 对应SQL --> LIKE 'T%' (以T开头)
    System.out.println("--- 姓名中包含 'm' 的用户 ---");
    List<UserDO> users1 = userMapper.selectList(wrapperLike);
    users1.forEach(System.out::println);


    // 2. 判空查询: 查询邮箱地址未设置的用户
    LambdaQueryWrapper<UserDO> wrapperNull = new LambdaQueryWrapper<>();
    // isNull(字段): 对应SQL --> IS NULL
    wrapperNull.isNull(UserDO::getEmail);

    System.out.println("\n--- 邮箱地址为空的用户 ---");
    List<UserDO> users2 = userMapper.selectList(wrapperNull);
    users2.forEach(System.out::println);

    System.out.println("\n--- 查询所有名字不为空的用户 --- ");
    LambdaQueryWrapper<UserDO> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    lambdaQueryWrapper.isNotNull(UserDO::getName);
    List<UserDO> users = userMapper.selectList(lambdaQueryWrapper);
    System.out.println(users);
}

@Test
void testInAndExistsQueries() {
    // 1. IN 查询: 查询ID为 1, 3, 5 的用户
    LambdaQueryWrapper<UserDO> wrapperIn = new LambdaQueryWrapper<>();
    // in(字段, 集合或数组): 对应SQL --> IN (?, ?, ?)
    wrapperIn.in(UserDO::getId, List.of(1L, 3L, 5L));
    // 如果想要取反，则使用下面的方法
    // wrapperIn.notIn(UserDO::getId, List.of(1L, 3L, 5L));

    System.out.println("--- ID为 1, 3, 5 的用户 ---");
    List<UserDO> users1 = userMapper.selectList(wrapperIn);
    users1.forEach(System.out::println);

}

// WrapperTest.java

@Test
void testOrderingAndGrouping() {
    // 1. 排序: 按年龄降序排序，如果年龄相同，则按ID升序排序
    LambdaQueryWrapper<UserDO> orderWrapper = new LambdaQueryWrapper<>();
    // orderByDesc/orderByAsc 可以接收多个字段，并按顺序应用排序规则
    orderWrapper.orderByDesc(UserDO::getAge)
                .orderByAsc(UserDO::getId);
    
    System.out.println("--- 按年龄降序、ID升序排序 ---");
    List<UserDO> users1 = userMapper.selectList(orderWrapper);
    users1.forEach(System.out::println);

    // 2. 分组查询: 按年龄分组，统计每个年龄段的用户数
    // 注意：分组查询通常伴随着聚合函数(COUNT, SUM, AVG等)，
    // 返回的结果集结构已不再是 UserDO，因此不能用 LambdaQueryWrapper 的 select 方法。
    // 我们需要使用 QueryWrapper 并用字符串指定查询字段，同时使用 selectMaps 返回 List<Map>。
    QueryWrapper<UserDO> groupWrapper = new QueryWrapper<>();
    groupWrapper.select("age, COUNT(*) as count") // 查询 age 字段和统计数(别名为count)
                .groupBy("age") // 按 age 字段分组
                .having("count > 1"); // having 用于对分组后的结果进行过滤

    System.out.println("\n--- 按年龄分组，统计人数大于1的年龄段 ---");
    List<Map<String, Object>> maps = userMapper.selectMaps(groupWrapper);
    maps.forEach(System.out::println);
}

// WrapperTest.java

@Test
void testLogicalAndNested() {
    // 1. OR 连接: 查询姓名以 'J' 开头 或 年龄大于 25 的用户
    LambdaQueryWrapper<UserDO> orWrapper = new LambdaQueryWrapper<>();
    orWrapper.likeRight(UserDO::getName, "J") // likeRight: LIKE 'J%'
             .or() // 使用 or() 方法连接下一个条件
             .gt(UserDO::getAge, 25);
    
    System.out.println("--- 姓名以 'J' 开头 或 年龄大于 25 的用户 ---");
    List<UserDO> users1 = userMapper.selectList(orWrapper);
    users1.forEach(System.out::println);

    // 2. 嵌套查询: 查询 (年龄 < 25 AND 邮箱包含 "test") OR (姓名 = 'Tom')
    LambdaQueryWrapper<UserDO> nestedWrapper = new LambdaQueryWrapper<>();
    // nested() 方法接收一个Lambda表达式，用于构建一个带括号的条件块
    nestedWrapper.nested(w -> w.lt(UserDO::getAge, 25).like(UserDO::getEmail, "test"))
                 .or()
                 .eq(UserDO::getName, "Tom");

    System.out.println("\n--- (年龄<25且邮箱含test) 或 (姓名为Tom) 的用户 ---");
    List<UserDO> users2 = userMapper.selectList(nestedWrapper);
    users2.forEach(System.out::println);
}

// WrapperTest.java

@Test
void testSelectColumns() {
    // 场景：在用户列表页，我们只需要展示用户的 ID, 姓名, 邮箱
    LambdaQueryWrapper<UserDO> wrapper = new LambdaQueryWrapper<>();
    // select 方法可以接收多个方法引用，指定要查询的列
    wrapper.select(UserDO::getId, UserDO::getName, UserDO::getEmail);
    
    System.out.println("--- 只查询 ID, 姓名, 邮箱 ---");
    List<UserDO> users = userMapper.selectList(wrapper);
    users.forEach(System.out::println);
}

package com.example.mpstudy.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.experimental.Accessors;

@Data
@Accessors(chain = true)
@TableName("tb_department")
public class DepartmentDO {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
}

package com.example.mpstudy.domain.vo;

import com.example.mpstudy.domain.DepartmentDO;
import com.example.mpstudy.domain.UserDO;
import lombok.Data;
import lombok.EqualsAndHashCode;

@Data
@EqualsAndHashCode(callSuper = true)
public class UserVO extends UserDO {
    // 额外定义的属性，用于封装一对一关系中的“一”方
    private DepartmentDO department;
}

package com.example.mpstudy.domain.vo;

import com.example.mpstudy.domain.DepartmentDO;
import com.example.mpstudy.domain.UserDO;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.List;

@Data
@EqualsAndHashCode(callSuper = true)
public class DepartmentVO extends DepartmentDO {
    // 额外定义的属性，用于封装一对多关系中的“多”方
    private List<UserDO> users;
}

package com.example.mpstudy.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.mpstudy.domain.UserDO;
import com.example.mpstudy.domain.vo.UserVO;
import org.apache.ibatis.annotations.Param;

public interface UserMapper extends BaseMapper<UserDO> {
    
    UserDO selectByName(@Param("name") String name);

    /**
     * 根据用户ID查询用户及其所属部门信息
     * @param id 用户ID
     * @return 包含部门信息的用户视图对象
     */
    UserVO findUserWithDept(@Param("id") Long id);
}

// UserMapperTest.java
@Test
void testFindUserWithDept() {
    UserVO userWithDept = userMapper.findUserWithDept(1L);
    System.out.println("查询到的用户信息: " + userWithDept.getName());
    System.out.println("该用户所属的部门: " + userWithDept.getDepartment());
}

package com.example.mpstudy.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.mpstudy.domain.DepartmentDO;
import com.example.mpstudy.domain.vo.DepartmentVO;
import org.apache.ibatis.annotations.Param;

public interface DepartmentMapper extends BaseMapper<DepartmentDO> {
    
    DepartmentVO findDeptWithUsers(@Param("id") Long id);
}