package com.sztzjy.linkCommerce.controller.stu;

import com.sztzjy.linkCommerce.entity.School;
import com.sztzjy.linkCommerce.entity.SchoolClass;
import com.sztzjy.linkCommerce.entity.SchoolClassExample;
import com.sztzjy.linkCommerce.entity.SchoolFaculty;
import com.sztzjy.linkCommerce.entity.SchoolMajor;
import com.sztzjy.linkCommerce.entity.TeachingClassStudent;
import com.sztzjy.linkCommerce.entity.Userinfo;
import com.sztzjy.linkCommerce.mapper.SchoolClassMapper;
import com.sztzjy.linkCommerce.mapper.SchoolFacultyMapper;
import com.sztzjy.linkCommerce.mapper.SchoolMapper;
import com.sztzjy.linkCommerce.mapper.SchoolMajorMapper;
import com.sztzjy.linkCommerce.mapper.TeachingClassStudentMapper;
import com.sztzjy.linkCommerce.mapper.UserinfoMapper;
import com.sztzjy.linkCommerce.service.UserInfoService;
import com.sztzjy.linkCommerce.entity.importDto.SchoolAdminStudentImportDTO;
import com.sztzjy.linkCommerce.entity.importDto.TeachingClassStudentImportDTO;
import com.sztzjy.linkCommerce.util.Pinyin4jUtil;
import com.sztzjy.linkCommerce.util.ResultEntity;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.http.HttpStatus;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

class UserControllerTeacherAdminTest {

    @Test
    void addTeacherAccountAlwaysCreatesOrdinaryTeacher() {
        UserController controller = controllerWithCommonMocks();
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-admin")).thenReturn(teacher("teacher-admin", true));
        when(controller.userInfoService.existsByUserName("t001")).thenReturn(false);
        when(controller.userinfoMapper.insert(any(Userinfo.class))).thenReturn(1);

        ResultEntity result = controller.addTeacherAccount("school-1", "school", "faculty-1", "major-1",
                "major", "张老师", "t001", null, null, "teacher-admin");

        ArgumentCaptor<Userinfo> captor = ArgumentCaptor.forClass(Userinfo.class);
        verify(controller.userinfoMapper).insert(captor.capture());
        assertEquals(HttpStatus.OK, result.getStatusCode());
        assertEquals(3, captor.getValue().getRole());
        assertFalse(captor.getValue().getTeacherAdmin());
    }

    @Test
    void ordinaryTeacherCannotAddFaculty() {
        UserController controller = controllerWithCommonMocks();
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1", false));

        ResultEntity result = controller.addSchoolFaculty("school-1", "faculty", null, null, null, "teacher-1");

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
        verify(controller.schoolFacultyMapper, never()).insert(any(SchoolFaculty.class));
    }

    @Test
    void teacherAdminCanAddFaculty() {
        UserController controller = controllerWithCommonMocks();
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-admin")).thenReturn(teacher("teacher-admin", true));
        when(controller.schoolFacultyMapper.selectByExample(any())).thenReturn(Collections.emptyList());
        when(controller.schoolFacultyMapper.insert(any(SchoolFaculty.class))).thenReturn(1);

        ResultEntity result = controller.addSchoolFaculty("school-1", "faculty", null, null, null, "teacher-admin");

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.schoolFacultyMapper).insert(any(SchoolFaculty.class));
    }

    @Test
    void ordinaryTeacherCannotAddMajor() {
        UserController controller = controllerWithCommonMocks();
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1", false));

        ResultEntity result = controller.addSchoolMajor("school-1", "faculty-1", "major", null, null, "teacher-1");

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
        verify(controller.schoolMajorMapper, never()).insert(any(SchoolMajor.class));
    }

    @Test
    void ordinaryTeacherCannotUpdateTeacherAccount() {
        UserController controller = controllerWithCommonMocks();
        Userinfo update = teacher("teacher-2", false);
        update.setName("updated");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1", false));

        ResultEntity result = controller.updateTeacher(update, "teacher-1");

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
        verify(controller.userinfoMapper, never()).updateByPrimaryKey(any(Userinfo.class));
    }

    @Test
    void addSchoolClassStoresCreatorTeacher() {
        UserController controller = controllerWithCommonMocks();
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
        when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
        when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
        when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");

        ResultEntity result = controller.addSchoolClass("school-1", "faculty-1", "major-1", "class-1",
                "teacher-1", null, null);

        ArgumentCaptor<SchoolClass> captor = ArgumentCaptor.forClass(SchoolClass.class);
        verify(controller.schoolClassMapper).insert(captor.capture());
        assertEquals(HttpStatus.OK, result.getStatusCode());
        assertEquals("teacher-1", captor.getValue().getCreatedBy());
        assertEquals("TEACHING", captor.getValue().getClassType());
        assertEquals("LOCAL", captor.getValue().getDataSource());
    }

    @Test
    void ordinaryTeacherCanAddAdminClassWithinOwnSchool() {
        UserController controller = controllerWithCommonMocks();
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1", false));
        when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
        when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
        when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");

        ResultEntity result = controller.addSchoolClass("school-1", "faculty-1", "major-1", "admin-class",
                "teacher-1", "ADMIN", null);

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.schoolClassMapper).insert(argThat(schoolClass -> "ADMIN".equals(schoolClass.getClassType())));
    }

    @Test
    void teacherAdminCanAddAdminClass() {
        UserController controller = controllerWithCommonMocks();
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-admin")).thenReturn(teacher("teacher-admin", true));
        when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
        when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
        when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");

        ResultEntity result = controller.addSchoolClass("school-1", "faculty-1", "major-1", "admin-class",
                "teacher-admin", "ADMIN", null);

        ArgumentCaptor<SchoolClass> captor = ArgumentCaptor.forClass(SchoolClass.class);
        verify(controller.schoolClassMapper).insert(captor.capture());
        assertEquals(HttpStatus.OK, result.getStatusCode());
        assertEquals("teacher-admin", captor.getValue().getCreatedBy());
        assertEquals("ADMIN", captor.getValue().getClassType());
    }

    @Test
    void addSchoolClassRejectsDuplicateNameInSameSchool() {
        UserController controller = controllerWithCommonMocks();
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
        when(controller.schoolClassMapper.selectByExample(argThat(example -> hasCondition(example, "school_id ="))))
                .thenReturn(Collections.singletonList(new SchoolClass()));

        ResultEntity result = controller.addSchoolClass("school-1", "faculty-1", "major-1", "class-1",
                "teacher-1", null, null);

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
        verify(controller.schoolClassMapper, never()).insert(any(SchoolClass.class));
    }

    @Test
    void addTeachingClassFromAdminClassesCreatesMembershipRows() {
        UserController controller = controllerWithCommonMocks();
        Userinfo studentOne = new Userinfo();
        studentOne.setUserId("student-1");
        studentOne.setRole(4);
        studentOne.setSchoolClassId("admin-1");
        Userinfo studentTwo = new Userinfo();
        studentTwo.setUserId("student-2");
        studentTwo.setRole(4);
        studentTwo.setSchoolClassId("admin-2");
        when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
        when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
        when(controller.userinfoMapper.selectByExample(any())).thenReturn(Arrays.asList(studentOne, studentTwo));
        when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);
        when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");

        ResultEntity result = controller.addSchoolClass("school-1", "faculty-1", "major-1", "teaching-class",
                "teacher-1", "TEACHING", "admin-1,admin-2");

        ArgumentCaptor<SchoolClass> classCaptor = ArgumentCaptor.forClass(SchoolClass.class);
        ArgumentCaptor<TeachingClassStudent> memberCaptor = ArgumentCaptor.forClass(TeachingClassStudent.class);
        verify(controller.schoolClassMapper).insert(classCaptor.capture());
        verify(controller.teachingClassStudentMapper, times(2)).insertSelective(memberCaptor.capture());
        List<TeachingClassStudent> members = memberCaptor.getAllValues();
        assertEquals(HttpStatus.OK, result.getStatusCode());
        assertEquals(classCaptor.getValue().getSchoolClassId(), members.get(0).getTeachingClassId());
        assertEquals("student-1", members.get(0).getStudentUserId());
        assertEquals("admin-1", members.get(0).getAdminClassId());
        assertEquals("IN_PROGRESS", members.get(0).getStatus());
        assertEquals("student-2", members.get(1).getStudentUserId());
        assertEquals("admin-2", members.get(1).getAdminClassId());
    }

    @Test
    void addTeachingClassFromAdminClassesRequiresConfirmationWhenStudentAlreadyInOtherTeachingClass() {
        UserController controller = controllerWithCommonMocks();
        Userinfo student = student("student-1", "student-a", "2024001", "admin-1");
        when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
        when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.singletonList(student));
        when(controller.teachingClassStudentMapper.countByStudentUserIdExcludingTeachingClass("student-1", ""))
                .thenReturn(1L);
        when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");

        ResultEntity result = controller.addSchoolClass("school-1", "faculty-1", "major-1", "teaching-class",
                "teacher-1", "TEACHING", "admin-1");

        assertEquals(HttpStatus.CONFLICT, result.getStatusCode());
        verify(controller.schoolClassMapper, never()).insert(any(SchoolClass.class));
        verify(controller.teachingClassStudentMapper, never()).insertSelective(any(TeachingClassStudent.class));
    }

    @Test
    void addTeachingClassFromAdminClassesCanContinueAfterMultiClassConfirmation() {
        UserController controller = controllerWithCommonMocks();
        Userinfo student = student("student-1", "student-a", "2024001", "admin-1");
        when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
        when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
        when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.singletonList(student));
        when(controller.teachingClassStudentMapper.countByStudentUserIdExcludingTeachingClass("student-1", ""))
                .thenReturn(1L);
        when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);
        when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");

        ResultEntity result = controller.addSchoolClass("school-1", "faculty-1", "major-1", "teaching-class",
                "teacher-1", "TEACHING", "admin-1", true);

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.schoolClassMapper).insert(any(SchoolClass.class));
        verify(controller.teachingClassStudentMapper).insertSelective(any(TeachingClassStudent.class));
    }

    @Test
    void deleteFacultyRejectsWhenMajorExists() {
        UserController controller = controllerWithCommonMocks();
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
        SchoolFaculty faculty = new SchoolFaculty();
        faculty.setSchoolFacultyId("faculty-1");
        faculty.setSchoolId("school-1");
        when(controller.schoolFacultyMapper.selectByPrimaryKey("faculty-1")).thenReturn(faculty);
        when(controller.schoolMajorMapper.selectByExample(any())).thenReturn(Collections.singletonList(new SchoolMajor()));

        ResultEntity result = controller.deleteSchoolFaculty("faculty-1", "teacher-1");

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
        verify(controller.schoolFacultyMapper, never()).deleteByPrimaryKey("faculty-1");
    }

    @Test
    void deleteMajorRejectsWhenClassExists() {
        UserController controller = controllerWithCommonMocks();
        when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.singletonList(new SchoolClass()));

        ResultEntity result = controller.deleteSchoolMajor("major-1", "teacher-1");

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
        verify(controller.schoolMajorMapper, never()).deleteByPrimaryKey("major-1");
    }

    @Test
    void deleteClassRejectsWhenStudentsExist() {
        UserController controller = controllerWithCommonMocks();
        SchoolClass adminClass = classCreatedBy("teacher-1");
        adminClass.setClassType("ADMIN");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(adminClass);
        when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.singletonList(new Userinfo()));

        ResultEntity result = controller.deleteSchoolClass("class-1", "teacher-1");

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
        verify(controller.schoolClassMapper, never()).deleteByPrimaryKey("class-1");
    }

    @Test
    void teacherCannotDeleteClassCreatedByAnotherTeacher() {
        UserController controller = controllerWithCommonMocks();
        Userinfo teacher = teacher("teacher-1");
        SchoolClass schoolClass = classCreatedBy("teacher-2");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher);
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(schoolClass);

        ResultEntity result = controller.deleteSchoolClass("class-1", "teacher-1");

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
        verify(controller.schoolClassMapper, never()).deleteByPrimaryKey("class-1");
    }

    @Test
    void teacherAdminCanDeleteOwnLocalAdminClass() {
        UserController controller = controllerWithCommonMocks();
        Userinfo teacherAdmin = teacher("teacher-1", true);
        SchoolClass existing = classCreatedBy("teacher-1");
        existing.setClassType("ADMIN");
        existing.setDataSource("LOCAL");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacherAdmin);
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);
        when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.emptyList());
        when(controller.schoolClassMapper.deleteByPrimaryKey("class-1")).thenReturn(1);

        ResultEntity result = controller.deleteSchoolClass("class-1", "teacher-1");

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.schoolClassMapper).deleteByPrimaryKey("class-1");
    }

    @Test
    void ordinaryTeacherCanDeleteOwnLocalAdminClass() {
        UserController controller = controllerWithCommonMocks();
        Userinfo teacher = teacher("teacher-1", false);
        SchoolClass existing = classCreatedBy("teacher-1");
        existing.setClassType("ADMIN");
        existing.setDataSource("LOCAL");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher);
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);
        when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.emptyList());
        when(controller.schoolClassMapper.deleteByPrimaryKey("class-1")).thenReturn(1);

        ResultEntity result = controller.deleteSchoolClass("class-1", "teacher-1");

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.schoolClassMapper).deleteByPrimaryKey("class-1");
    }

    @Test
    void teacherAdminCanDeleteLocalAdminClassWithoutOwnerInSameSchool() {
        UserController controller = controllerWithCommonMocks();
        Userinfo teacherAdmin = teacher("teacher-1", true);
        SchoolClass existing = classCreatedBy(null);
        existing.setClassType("ADMIN");
        existing.setDataSource("LOCAL");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacherAdmin);
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);
        when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.emptyList());
        when(controller.schoolClassMapper.deleteByPrimaryKey("class-1")).thenReturn(1);

        ResultEntity result = controller.deleteSchoolClass("class-1", "teacher-1");

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.schoolClassMapper).deleteByPrimaryKey("class-1");
    }

    @Test
    void teacherAdminCannotDeleteZhiyunAdminClass() {
        UserController controller = controllerWithCommonMocks();
        Userinfo teacherAdmin = teacher("teacher-1", true);
        SchoolClass existing = classCreatedBy(null);
        existing.setClassType("ADMIN");
        existing.setDataSource("ZHIYUN");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacherAdmin);
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);

        ResultEntity result = controller.deleteSchoolClass("class-1", "teacher-1");

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
        verify(controller.schoolClassMapper, never()).deleteByPrimaryKey("class-1");
    }

    @Test
    void teacherUpdatesOnlyOwnedClass() {
        UserController controller = controllerWithCommonMocks();
        Userinfo teacher = teacher("teacher-1");
        SchoolClass existing = classCreatedBy("teacher-1");
        SchoolClass update = new SchoolClass();
        update.setSchoolClassId("class-1");
        update.setClassName("new-class");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher);
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);
        when(controller.schoolClassMapper.updateByPrimaryKeySelective(any(SchoolClass.class))).thenReturn(1);

        ResultEntity result = controller.updateSchoolClass(update, "teacher-1");

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.schoolClassMapper).updateByPrimaryKeySelective(update);
        verify(controller.schoolClassMapper, never()).deleteByPrimaryKey("class-1");
    }

    @Test
    void teacherAdminCanUpdateOwnLocalAdminClass() {
        UserController controller = controllerWithCommonMocks();
        Userinfo teacherAdmin = teacher("teacher-1", true);
        SchoolClass existing = classCreatedBy("teacher-1");
        existing.setClassType("ADMIN");
        existing.setDataSource("LOCAL");
        SchoolClass update = new SchoolClass();
        update.setSchoolClassId("class-1");
        update.setClassName("new-admin-class");
        update.setCreatedBy("teacher-1");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacherAdmin);
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);
        when(controller.schoolClassMapper.updateByPrimaryKeySelective(any(SchoolClass.class))).thenReturn(1);

        ResultEntity result = controller.updateSchoolClass(update, "teacher-1");

        ArgumentCaptor<SchoolClass> captor = ArgumentCaptor.forClass(SchoolClass.class);
        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.schoolClassMapper).updateByPrimaryKeySelective(captor.capture());
        assertEquals("teacher-1", captor.getValue().getCreatedBy());
    }

    @Test
    void ordinaryTeacherCanUpdateOwnLocalAdminClass() {
        UserController controller = controllerWithCommonMocks();
        Userinfo teacher = teacher("teacher-1", false);
        SchoolClass existing = classCreatedBy("teacher-1");
        existing.setClassType("ADMIN");
        existing.setDataSource("LOCAL");
        SchoolClass update = new SchoolClass();
        update.setSchoolClassId("class-1");
        update.setClassName("new-admin-class");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher);
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);
        when(controller.schoolClassMapper.updateByPrimaryKeySelective(any(SchoolClass.class))).thenReturn(1);

        ResultEntity result = controller.updateSchoolClass(update, "teacher-1");

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.schoolClassMapper).updateByPrimaryKeySelective(update);
    }

    @Test
    void teacherAdminCanUpdateLocalAdminClassWithoutOwnerInSameSchool() {
        UserController controller = controllerWithCommonMocks();
        Userinfo teacherAdmin = teacher("teacher-1", true);
        SchoolClass existing = classCreatedBy(null);
        existing.setClassType("ADMIN");
        existing.setDataSource("LOCAL");
        SchoolClass update = new SchoolClass();
        update.setSchoolClassId("class-1");
        update.setClassName("new-admin-class");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacherAdmin);
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);
        when(controller.schoolClassMapper.updateByPrimaryKeySelective(any(SchoolClass.class))).thenReturn(1);

        ResultEntity result = controller.updateSchoolClass(update, "teacher-1");

        ArgumentCaptor<SchoolClass> captor = ArgumentCaptor.forClass(SchoolClass.class);
        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.schoolClassMapper).updateByPrimaryKeySelective(captor.capture());
        assertNull(captor.getValue().getCreatedBy());
    }

    @Test
    void teacherAdminCannotUpdateZhiyunAdminClass() {
        UserController controller = controllerWithCommonMocks();
        Userinfo teacherAdmin = teacher("teacher-1", true);
        SchoolClass existing = classCreatedBy(null);
        existing.setClassType("ADMIN");
        existing.setDataSource("ZHIYUN");
        SchoolClass update = new SchoolClass();
        update.setSchoolClassId("class-1");
        update.setClassName("new-admin-class");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacherAdmin);
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);

        ResultEntity result = controller.updateSchoolClass(update, "teacher-1");

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
        verify(controller.schoolClassMapper, never()).updateByPrimaryKeySelective(any(SchoolClass.class));
    }

    @Test
    void teacherCannotDeleteStudentFromClassCreatedByAnotherTeacher() {
        UserController controller = controllerWithCommonMocks();
        Userinfo teacher = teacher("teacher-1");
        Userinfo student = new Userinfo();
        student.setUserId("student-1");
        student.setRole(4);
        student.setSchoolClassId("class-1");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher);
        when(controller.userinfoMapper.selectByPrimaryKey("student-1")).thenReturn(student);
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(classCreatedBy("teacher-2"));

        ResultEntity result = controller.deleteStudent("student-1", "teacher-1", null);

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
        verify(controller.userinfoMapper, never()).deleteByPrimaryKey("student-1");
    }

    @Test
    void teacherCanDeleteStudentInOwnedTeachingClassEvenWhenAdminClassIsDifferent() {
        UserController controller = controllerWithCommonMocks();
        Userinfo student = new Userinfo();
        student.setUserId("student-1");
        student.setRole(4);
        student.setSchoolClassId("admin-1");
        SchoolClass teachingClass = classCreatedBy("teacher-1");
        teachingClass.setSchoolClassId("teaching-1");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
        when(controller.userinfoMapper.selectByPrimaryKey("student-1")).thenReturn(student);
        when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
        when(controller.teachingClassStudentMapper.countByStudentUserIdAndTeachingClassId("student-1", "teaching-1"))
                .thenReturn(1L);
        when(controller.teachingClassStudentMapper.deleteByStudentUserIdAndTeachingClassId("student-1", "teaching-1"))
                .thenReturn(1);

        ResultEntity result = controller.deleteStudent("student-1", "teacher-1", "teaching-1");

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.teachingClassStudentMapper).deleteByStudentUserIdAndTeachingClassId("student-1", "teaching-1");
        verify(controller.userinfoMapper, never()).deleteByPrimaryKey("student-1");
    }

    @Test
    void teacherCanInitializePasswordForStudentInOwnedTeachingClass() {
        UserController controller = controllerWithCommonMocks();
        Userinfo student = new Userinfo();
        student.setUserId("student-1");
        student.setRole(4);
        student.setSchoolClassId("admin-1");
        SchoolClass teachingClass = classCreatedBy("teacher-1");
        teachingClass.setSchoolClassId("teaching-1");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
        when(controller.userinfoMapper.selectByPrimaryKey("student-1")).thenReturn(student);
        when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
        when(controller.teachingClassStudentMapper.countByStudentUserIdAndTeachingClassId("student-1", "teaching-1"))
                .thenReturn(1L);
        when(controller.userinfoMapper.updateByPrimaryKey(student)).thenReturn(1);

        ResultEntity result = controller.updateStudentPassword("student-1", "teacher-1", "teaching-1");

        assertEquals(HttpStatus.OK, result.getStatusCode());
        assertEquals("123qwe", student.getPassword());
        verify(controller.userinfoMapper).updateByPrimaryKey(student);
    }

    @Test
    void teacherCanUpdateStudentInOwnedTeachingClassEvenWhenAdminClassIsDifferent() {
        UserController controller = controllerWithCommonMocks();
        Userinfo existingStudent = new Userinfo();
        existingStudent.setUserId("student-1");
        existingStudent.setRole(4);
        existingStudent.setSchoolClassId("admin-1");
        Userinfo update = new Userinfo();
        update.setUserId("student-1");
        update.setRole(4);
        update.setSchoolClassId("admin-1");
        update.setName("updated");
        SchoolClass teachingClass = classCreatedBy("teacher-1");
        teachingClass.setSchoolClassId("teaching-1");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
        when(controller.userinfoMapper.selectByPrimaryKey("student-1")).thenReturn(existingStudent);
        when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
        when(controller.teachingClassStudentMapper.countByStudentUserIdAndTeachingClassId("student-1", "teaching-1"))
                .thenReturn(1L);
        when(controller.userinfoMapper.updateByPrimaryKey(update)).thenReturn(1);

        ResultEntity result = controller.updateStudent(update, "teacher-1", "teaching-1");

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.userinfoMapper).updateByPrimaryKey(update);
    }

    @Test
    void teacherCanAddStudentOnlyToOwnedClass() {
        UserController controller = controllerWithCommonMocks();
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(classCreatedBy("teacher-1"));
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
        when(controller.userInfoService.existsByUserName("s001")).thenReturn(false);
        when(controller.userinfoMapper.insert(any(Userinfo.class))).thenReturn(1);

        ResultEntity result = controller.addStudentAccount("school-1", "school", "faculty-1", "major-1",
                "major", "class-1", "class-1", "学生", "s001", null, null, "teacher-1");

        assertEquals(HttpStatus.OK, result.getStatusCode());
    }

    @Test
    void addStudentToTeachingClassCreatesMembershipInsteadOfChangingAdminClass() {
        UserController controller = controllerWithCommonMocks();
        SchoolClass teachingClass = classCreatedBy("teacher-1");
        teachingClass.setSourceClassIds("admin-1");
        when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
        when(controller.userInfoService.existsByUserName("s001")).thenReturn(false);
        when(controller.userinfoMapper.insert(any(Userinfo.class))).thenReturn(1);
        when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);

        ResultEntity result = controller.addStudentAccount("school-1", "school", "faculty-1", "major-1",
                "major", "teaching", "teaching-1", "瀛︾敓", "s001", null, null, "teacher-1");

        ArgumentCaptor<Userinfo> userCaptor = ArgumentCaptor.forClass(Userinfo.class);
        ArgumentCaptor<TeachingClassStudent> memberCaptor = ArgumentCaptor.forClass(TeachingClassStudent.class);
        verify(controller.userinfoMapper).insert(userCaptor.capture());
        verify(controller.teachingClassStudentMapper).insertSelective(memberCaptor.capture());
        assertEquals(HttpStatus.OK, result.getStatusCode());
        assertEquals("admin-1", userCaptor.getValue().getSchoolClassId());
        assertEquals("teaching-1", memberCaptor.getValue().getTeachingClassId());
        assertEquals(userCaptor.getValue().getUserId(), memberCaptor.getValue().getStudentUserId());
    }

    @Test
    void teacherCannotInitializeTeachingClassCreatedByAnotherTeacher() {
        UserController controller = controllerWithCommonMocks();
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(classCreatedBy("teacher-2"));

        ResultEntity result = controller.initializeTeachingClassTrainingData("class-1", "teacher-1");

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
    }

    @Test
    void teacherCanInitializeOwnedTeachingClassResetsAllMembers() {
        UserController controller = controllerWithCommonMocks();
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(classCreatedBy("teacher-1"));
        TeachingClassStudent memberOne = new TeachingClassStudent();
        memberOne.setStudentUserId("student-1");
        TeachingClassStudent memberTwo = new TeachingClassStudent();
        memberTwo.setStudentUserId("student-2");
        when(controller.teachingClassStudentMapper.selectByTeachingClassId("class-1"))
                .thenReturn(Arrays.asList(memberOne, memberTwo));

        ResultEntity result = controller.initializeTeachingClassTrainingData("class-1", "teacher-1");

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.cptfController).restartByUserId("student-1");
        verify(controller.cptfController).restartByUserId("student-2");
    }

    @Test
    void teacherCanInitializeSingleStudentOnlyInOwnedTeachingClass() {
        UserController controller = controllerWithCommonMocks();
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(classCreatedBy("teacher-1"));
        when(controller.teachingClassStudentMapper.countByStudentUserIdAndTeachingClassId("student-1", "class-1"))
                .thenReturn(1L);

        ResultEntity result = controller.initializeTeachingClassStudentTrainingData("class-1", "student-1", "teacher-1");

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.cptfController).restartByUserId("student-1");
    }

    @Test
    void selectStudentByTeachingClassUsesMembershipRows() {
        UserController controller = controllerWithCommonMocks();
        SchoolClass teachingClass = classCreatedBy("teacher-1");
        when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
        TeachingClassStudent member = new TeachingClassStudent();
        member.setStudentUserId("student-1");
        when(controller.teachingClassStudentMapper.selectByTeachingClassId("teaching-1"))
                .thenReturn(Collections.singletonList(member));
        Userinfo student = new Userinfo();
        student.setUserId("student-1");
        student.setRole(4);
        student.setSchoolId("school-1");
        student.setSchoolClassId("admin-1");
        when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.singletonList(student));

        ResultEntity result = controller.selectStudent("school-1", "teaching-1", null, null, 1, 10);

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.teachingClassStudentMapper).selectByTeachingClassId("teaching-1");
    }

    @Test
    void importTeachingClassStudentRowsCreatesMembershipForMatchedAdminStudents() {
        UserController controller = controllerWithCommonMocks();
        SchoolClass teachingClass = classCreatedBy("teacher-1");
        teachingClass.setSchoolClassId("teaching-1");
        teachingClass.setSchoolId("school-1");
        teachingClass.setSourceClassIds("admin-1");
        Userinfo student = new Userinfo();
        student.setUserId("student-1");
        student.setRole(4);
        student.setName("student");
        student.setUsername("2024001");
        student.setSchoolId("school-1");
        student.setSchoolClassId("admin-1");
        TeachingClassStudentImportDTO row = teachingClassStudentRow("student", "2024001");
        when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
        when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.singletonList(student));
        when(controller.teachingClassStudentMapper.countByStudentUserIdAndTeachingClassId("student-1", "teaching-1"))
                .thenReturn(0L);
        when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);

        ResultEntity result = controller.importTeachingClassStudentRows(Collections.singletonList(row), "teaching-1", "teacher-1");

        ArgumentCaptor<TeachingClassStudent> captor = ArgumentCaptor.forClass(TeachingClassStudent.class);
        verify(controller.teachingClassStudentMapper).insertSelective(captor.capture());
        assertEquals(HttpStatus.OK, result.getStatusCode());
        assertEquals("teaching-1", captor.getValue().getTeachingClassId());
        assertEquals("student-1", captor.getValue().getStudentUserId());
        assertEquals("admin-1", captor.getValue().getAdminClassId());
        assertEquals("IN_PROGRESS", captor.getValue().getStatus());
    }

    @Test
    void importTeachingClassStudentRowsTransfersStudentFromOtherTeachingClass() {
        UserController controller = controllerWithCommonMocks();
        SchoolClass teachingClass = classCreatedBy("teacher-1");
        teachingClass.setSchoolClassId("teaching-1");
        teachingClass.setSchoolId("school-1");
        teachingClass.setSourceClassIds("admin-1");
        Userinfo student = student("student-1", "student", "2024001", "admin-1");
        TeachingClassStudentImportDTO row = teachingClassStudentRow("student", "2024001");
        when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
        when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.singletonList(student));
        when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);

        ResultEntity result = controller.importTeachingClassStudentRows(Collections.singletonList(row), "teaching-1", "teacher-1");

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.teachingClassStudentMapper).exitActiveByStudentUserIdExceptClass("student-1", "teaching-1");
        verify(controller.teachingClassStudentMapper).insertSelective(any(TeachingClassStudent.class));
    }

    @Test
    void importTeachingClassStudentRowsCanContinueAfterMultiClassConfirmation() {
        UserController controller = controllerWithCommonMocks();
        SchoolClass teachingClass = classCreatedBy("teacher-1");
        teachingClass.setSchoolClassId("teaching-1");
        teachingClass.setSchoolId("school-1");
        teachingClass.setSourceClassIds("admin-1");
        Userinfo student = student("student-1", "student", "2024001", "admin-1");
        TeachingClassStudentImportDTO row = teachingClassStudentRow("student", "2024001");
        when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
        when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.singletonList(student));
        when(controller.teachingClassStudentMapper.countByStudentUserIdExcludingTeachingClass("student-1", "teaching-1"))
                .thenReturn(1L);
        when(controller.teachingClassStudentMapper.countByStudentUserIdAndTeachingClassId("student-1", "teaching-1"))
                .thenReturn(0L);
        when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);

        ResultEntity result = controller.importTeachingClassStudentRows(Collections.singletonList(row), "teaching-1", "teacher-1", true);

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.teachingClassStudentMapper).insertSelective(any(TeachingClassStudent.class));
    }

    @Test
    void importTeachingClassStudentRowsRejectsWholeBatchWhenStudentDoesNotMatchAdminClass() {
        UserController controller = controllerWithCommonMocks();
        SchoolClass teachingClass = classCreatedBy("teacher-1");
        teachingClass.setSchoolClassId("teaching-1");
        teachingClass.setSchoolId("school-1");
        teachingClass.setSourceClassIds("admin-1");
        TeachingClassStudentImportDTO row = teachingClassStudentRow("missing", "2024999");
        when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
        when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.emptyList());

        ResultEntity result = controller.importTeachingClassStudentRows(Collections.singletonList(row), "teaching-1", "teacher-1");

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
        verify(controller.teachingClassStudentMapper, never()).insertSelective(any(TeachingClassStudent.class));
    }

    @Test
    void createTeachingClassByImportRowsCreatesClassAndOnlyImportedMembers() {
        UserController controller = controllerWithCommonMocks();
        Userinfo studentOne = student("student-1", "student-a", "2024001", "admin-1");
        Userinfo studentTwo = student("student-2", "student-b", "2024002", "admin-2");
        when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
        when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
        when(controller.userinfoMapper.selectByExample(any()))
                .thenReturn(Collections.singletonList(studentOne))
                .thenReturn(Collections.singletonList(studentTwo))
                .thenReturn(Collections.singletonList(studentOne))
                .thenReturn(Collections.singletonList(studentTwo));
        when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);
        when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");

        ResultEntity result = controller.createTeachingClassByImportRows(
                Arrays.asList(teachingClassStudentRow("student-a", "2024001"), teachingClassStudentRow("student-b", "2024002")),
                "school-1", "faculty-1", "major-1", "import-teaching-class", "teacher-1");

        ArgumentCaptor<SchoolClass> classCaptor = ArgumentCaptor.forClass(SchoolClass.class);
        ArgumentCaptor<TeachingClassStudent> memberCaptor = ArgumentCaptor.forClass(TeachingClassStudent.class);
        verify(controller.schoolClassMapper).insert(classCaptor.capture());
        verify(controller.teachingClassStudentMapper, times(2)).insertSelective(memberCaptor.capture());
        assertEquals(HttpStatus.OK, result.getStatusCode());
        assertEquals("TEACHING", classCaptor.getValue().getClassType());
        assertEquals("teacher-1", classCaptor.getValue().getCreatedBy());
        assertEquals("admin-1,admin-2", classCaptor.getValue().getSourceClassIds());
        assertEquals(classCaptor.getValue().getSchoolClassId(), memberCaptor.getAllValues().get(0).getTeachingClassId());
        assertEquals("student-1", memberCaptor.getAllValues().get(0).getStudentUserId());
        assertEquals("student-2", memberCaptor.getAllValues().get(1).getStudentUserId());
    }

    @Test
    void createTeachingClassByImportRowsTransfersStudentFromOtherTeachingClass() {
        UserController controller = controllerWithCommonMocks();
        Userinfo student = student("student-1", "student-a", "2024001", "admin-1");
        when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
        when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
        when(controller.userinfoMapper.selectByExample(any()))
                .thenReturn(Collections.singletonList(student))
                .thenReturn(Collections.singletonList(student));
        when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);
        when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");

        ResultEntity result = controller.createTeachingClassByImportRows(
                Collections.singletonList(teachingClassStudentRow("student-a", "2024001")),
                "school-1", "faculty-1", "major-1", "import-teaching-class", "teacher-1");

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.schoolClassMapper).insert(any(SchoolClass.class));
        verify(controller.teachingClassStudentMapper).exitActiveByStudentUserIdExceptClass(argThat(id -> "student-1".equals(id)), any());
        verify(controller.teachingClassStudentMapper).insertSelective(any(TeachingClassStudent.class));
    }

    @Test
    void createTeachingClassByImportRowsCanContinueAfterMultiClassConfirmation() {
        UserController controller = controllerWithCommonMocks();
        Userinfo student = student("student-1", "student-a", "2024001", "admin-1");
        when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
        when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
        when(controller.userinfoMapper.selectByExample(any()))
                .thenReturn(Collections.singletonList(student))
                .thenReturn(Collections.singletonList(student));
        when(controller.teachingClassStudentMapper.countByStudentUserIdExcludingTeachingClass("student-1", ""))
                .thenReturn(1L);
        when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);
        when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");

        ResultEntity result = controller.createTeachingClassByImportRows(
                Collections.singletonList(teachingClassStudentRow("student-a", "2024001")),
                "school-1", "faculty-1", "major-1", "import-teaching-class", "teacher-1", true);

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.schoolClassMapper).insert(any(SchoolClass.class));
        verify(controller.teachingClassStudentMapper).insertSelective(any(TeachingClassStudent.class));
    }

    @Test
    void createTeachingClassByImportRowsRejectsWholeBatchBeforeCreatingClassWhenAnyRowDoesNotMatch() {
        UserController controller = controllerWithCommonMocks();
        when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
        when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.emptyList());

        ResultEntity result = controller.createTeachingClassByImportRows(
                Collections.singletonList(teachingClassStudentRow("missing", "2024999")),
                "school-1", "faculty-1", "major-1", "import-teaching-class", "teacher-1");

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
        verify(controller.schoolClassMapper, never()).insert(any(SchoolClass.class));
        verify(controller.teachingClassStudentMapper, never()).insertSelective(any(TeachingClassStudent.class));
    }

    @Test
    void createTeachingClassByImportRowsUsesSelectedSourceAdminClasses() {
        UserController controller = controllerWithCommonMocks();
        Userinfo student = student("student-1", "student-a", "2024001", "admin-1");
        SchoolClass adminClass = new SchoolClass();
        adminClass.setSchoolClassId("admin-1");
        adminClass.setSchoolId("school-1");
        adminClass.setSchoolMajorId("major-1");
        adminClass.setClassType("ADMIN");
        when(controller.schoolClassMapper.selectByPrimaryKey("admin-1")).thenReturn(adminClass);
        when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
        when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
        when(controller.userinfoMapper.selectByExample(any()))
                .thenReturn(Collections.singletonList(student))
                .thenReturn(Collections.singletonList(student));
        when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);
        when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");

        ResultEntity result = controller.createTeachingClassByImportRows(
                Collections.singletonList(teachingClassStudentRow("student-a", "2024001")),
                "school-1", "faculty-1", "major-1", "import-teaching-class", "teacher-1", "admin-1", false);

        ArgumentCaptor<SchoolClass> classCaptor = ArgumentCaptor.forClass(SchoolClass.class);
        verify(controller.schoolClassMapper).insert(classCaptor.capture());
        assertEquals(HttpStatus.OK, result.getStatusCode());
        assertEquals("admin-1", classCaptor.getValue().getSourceClassIds());
    }

    @Test
    void importTeacherStudentRowsCreatesStudentsForOwnedAdminClass() {
        UserController controller = controllerWithCommonMocks();
        SchoolClass adminClass = new SchoolClass();
        adminClass.setSchoolClassId("admin-1");
        adminClass.setSchoolId("school-1");
        adminClass.setSchoolMajorId("major-1");
        adminClass.setClassName("行政一班");
        adminClass.setClassType("ADMIN");
        adminClass.setCreatedBy("teacher-1");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1", true));
        when(controller.schoolFacultyMapper.selectByExample(any())).thenReturn(Collections.singletonList(faculty("faculty-1", "院系")));
        when(controller.schoolMajorMapper.selectByExample(any())).thenReturn(Collections.singletonList(major("major-1", "faculty-1", "专业")));
        when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.singletonList(adminClass));
        when(controller.userInfoService.existsByUserName("20260001")).thenReturn(false);
        when(controller.userinfoMapper.insertSelective(any(Userinfo.class))).thenReturn(1);

        ResultEntity result = controller.importTeacherStudentRows(
                Collections.singletonList(studentAccountRow("张三", "20260001", "男", "院系", "专业", "行政一班")),
                "teacher-1");

        ArgumentCaptor<Userinfo> captor = ArgumentCaptor.forClass(Userinfo.class);
        verify(controller.userinfoMapper).insertSelective(captor.capture());
        assertEquals(HttpStatus.OK, result.getStatusCode());
        assertEquals("张三", captor.getValue().getName());
        assertEquals("20260001", captor.getValue().getUsername());
        assertEquals("admin-1", captor.getValue().getSchoolClassId());
        assertEquals(4, captor.getValue().getRole());
        assertEquals("Excel导入", captor.getValue().getCodeFrom());
    }

    @Test
    void importTeacherStudentRowsAllowsAdminClassFromSameSchool() {
        UserController controller = controllerWithCommonMocks();
        SchoolClass adminClass = new SchoolClass();
        adminClass.setSchoolClassId("admin-1");
        adminClass.setSchoolId("school-1");
        adminClass.setSchoolMajorId("major-1");
        adminClass.setClassName("行政一班");
        adminClass.setClassType("ADMIN");
        adminClass.setCreatedBy("teacher-2");
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1", true));
        when(controller.schoolFacultyMapper.selectByExample(any())).thenReturn(Collections.singletonList(faculty("faculty-1", "院系")));
        when(controller.schoolMajorMapper.selectByExample(any())).thenReturn(Collections.singletonList(major("major-1", "faculty-1", "专业")));
        when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.singletonList(adminClass));
        when(controller.userInfoService.existsByUserName("20260001")).thenReturn(false);
        when(controller.userinfoMapper.insertSelective(any(Userinfo.class))).thenReturn(1);

        ResultEntity result = controller.importTeacherStudentRows(
                Collections.singletonList(studentAccountRow("张三", "20260001", "男", "院系", "专业", "行政一班")),
                "teacher-1");

        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.userinfoMapper).insertSelective(argThat(student -> "admin-1".equals(student.getSchoolClassId())));
    }

    private UserController controllerWithCommonMocks() {
        UserController controller = new UserController();
        controller.schoolMapper = mock(SchoolMapper.class);
        controller.schoolFacultyMapper = mock(SchoolFacultyMapper.class);
        controller.schoolMajorMapper = mock(SchoolMajorMapper.class);
        controller.schoolClassMapper = mock(SchoolClassMapper.class);
        controller.teachingClassStudentMapper = mock(TeachingClassStudentMapper.class);
        controller.userinfoMapper = mock(UserinfoMapper.class);
        controller.userInfoService = mock(UserInfoService.class);
        controller.pinyin4jUtil = mock(Pinyin4jUtil.class);
        controller.cptfController = mock(CptfController.class);

        School school = new School();
        school.setSchoolId("school-1");
        school.setSchoolName("school");
        SchoolFaculty faculty = new SchoolFaculty();
        faculty.setSchoolFacultyId("faculty-1");
        faculty.setSchoolId("school-1");
        SchoolMajor major = new SchoolMajor();
        major.setSchoolMajorId("major-1");
        major.setSchoolFacultyId("faculty-1");

        when(controller.schoolMapper.selectByPrimaryKey("school-1")).thenReturn(school);
        when(controller.schoolFacultyMapper.selectByPrimaryKey("faculty-1")).thenReturn(faculty);
        when(controller.schoolMajorMapper.selectByPrimaryKey("major-1")).thenReturn(major);
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
        when(controller.userinfoMapper.selectByPrimaryKey("teacher-admin")).thenReturn(teacher("teacher-admin", true));
        return controller;
    }

    private Userinfo teacher(String userId) {
        return teacher(userId, false);
    }

    private Userinfo teacher(String userId, boolean teacherAdmin) {
        Userinfo teacher = new Userinfo();
        teacher.setUserId(userId);
        teacher.setRole(3);
        teacher.setSchoolId("school-1");
        teacher.setTeacherAdmin(teacherAdmin);
        return teacher;
    }

    private SchoolFaculty faculty(String facultyId, String facultyName) {
        SchoolFaculty faculty = new SchoolFaculty();
        faculty.setSchoolFacultyId(facultyId);
        faculty.setSchoolId("school-1");
        faculty.setSchoolFacultyName(facultyName);
        return faculty;
    }

    private SchoolMajor major(String majorId, String facultyId, String majorName) {
        SchoolMajor major = new SchoolMajor();
        major.setSchoolMajorId(majorId);
        major.setSchoolFacultyId(facultyId);
        major.setSchoolMajorName(majorName);
        return major;
    }

    private SchoolClass classCreatedBy(String teacherId) {
        SchoolClass schoolClass = new SchoolClass();
        schoolClass.setSchoolClassId("class-1");
        schoolClass.setSchoolId("school-1");
        schoolClass.setCreatedBy(teacherId);
        schoolClass.setClassType("TEACHING");
        return schoolClass;
    }

    private boolean hasCondition(SchoolClassExample example, String condition) {
        return example.getOredCriteria().stream()
                .flatMap(criteria -> criteria.getAllCriteria().stream())
                .anyMatch(criterion -> condition.equals(criterion.getCondition()));
    }

    private TeachingClassStudentImportDTO teachingClassStudentRow(String studentName, String userName) {
        TeachingClassStudentImportDTO row = new TeachingClassStudentImportDTO();
        row.setStudentName(studentName);
        row.setUserName(userName);
        return row;
    }

    private Userinfo student(String userId, String name, String userName, String adminClassId) {
        Userinfo student = new Userinfo();
        student.setUserId(userId);
        student.setRole(4);
        student.setName(name);
        student.setUsername(userName);
        student.setSchoolId("school-1");
        student.setSchoolFacultyId("faculty-1");
        student.setSchoolMajorId("major-1");
        student.setSchoolClassId(adminClassId);
        return student;
    }

    private SchoolAdminStudentImportDTO studentAccountRow(String name,
                                                          String username,
                                                          String sex,
                                                          String facultyName,
                                                          String majorName,
                                                          String className) {
        SchoolAdminStudentImportDTO row = new SchoolAdminStudentImportDTO();
        row.setName(name);
        row.setUsername(username);
        row.setSex(sex);
        row.setSchoolFacultyName(facultyName);
        row.setSchoolMajorName(majorName);
        row.setSchoolClassName(className);
        row.setPhone("13800000000");
        row.setEmail("student@example.com");
        return row;
    }
}