package com.sztzjy.linkCommerce.controller.stu;

import com.sztzjy.linkCommerce.entity.SchoolClass;
import com.sztzjy.linkCommerce.entity.TaskAllocation;
import com.sztzjy.linkCommerce.mapper.SchoolClassMapper;
import com.sztzjy.linkCommerce.mapper.TaskAllocationMapper;
import com.sztzjy.linkCommerce.service.SchoolDefaultTaskService;
import com.sztzjy.linkCommerce.util.ResultEntity;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.http.HttpStatus;
import org.springframework.test.util.ReflectionTestUtils;

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

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

class TaskAllocationControllerTest {

    @Test
    void teacherCannotUpdateTaskAllocationForClassCreatedByAnotherTeacher() {
        TaskAllocationController controller = new TaskAllocationController();
        controller.taskAllocationMapper = mock(TaskAllocationMapper.class);
        controller.schoolClassMapper = mock(SchoolClassMapper.class);
        SchoolClass schoolClass = new SchoolClass();
        schoolClass.setSchoolClassId("class-1");
        schoolClass.setCreatedBy("teacher-2");
        when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(schoolClass);

        ResultEntity result = controller.updateTaskAllocationByClassId(Collections.emptyList(), "class-1", "school-1", "teacher-1");

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
        verify(controller.taskAllocationMapper, never()).deleteByExample(org.mockito.ArgumentMatchers.any());
    }

    @Test
    void teacherCannotUpdateTaskAllocationForAdminClassEvenWhenCreatedBySelf() {
        TaskAllocationController controller = controllerWithMocks();
        SchoolClass schoolClass = new SchoolClass();
        schoolClass.setSchoolClassId("admin-1");
        schoolClass.setCreatedBy("teacher-1");
        schoolClass.setClassType("ADMIN");
        when(controller.schoolClassMapper.selectByPrimaryKey("admin-1")).thenReturn(schoolClass);

        ResultEntity result = controller.updateTaskAllocationByClassId(Collections.emptyList(), "admin-1", "school-1", "teacher-1");

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
        verify(controller.taskAllocationMapper, never()).deleteByExample(any());
    }

    @Test
    void teacherCanUpdateTaskAllocationForOwnedTeachingClass() {
        TaskAllocationController controller = controllerWithMocks();
        SchoolClass schoolClass = new SchoolClass();
        schoolClass.setSchoolClassId("teaching-1");
        schoolClass.setSchoolId("school-1");
        schoolClass.setCreatedBy("teacher-1");
        schoolClass.setClassType("TEACHING");
        when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(schoolClass);
        TaskAllocation allocation = new TaskAllocation();
        allocation.setModule("comprehensive-case-training");
        allocation.setSort(1);

        ResultEntity result = controller.updateTaskAllocationByClassId(Collections.singletonList(allocation), "teaching-1", "school-1", "teacher-1");

        ArgumentCaptor<TaskAllocation> captor = ArgumentCaptor.forClass(TaskAllocation.class);
        assertEquals(HttpStatus.OK, result.getStatusCode());
        verify(controller.taskAllocationMapper).deleteByExample(any());
        verify(controller.taskAllocationMapper, org.mockito.Mockito.times(2)).insert(captor.capture());
        List<TaskAllocation> inserted = captor.getAllValues();
        assertNotNull(inserted.get(0).getId());
        assertEquals(TaskAllocation.PUBLICATION_MARKER, inserted.get(0).getModule());
        assertEquals((byte) 1, inserted.get(0).getDisabledStatus());
        assertEquals("comprehensive-case-training", inserted.get(1).getModule());
        assertEquals((byte) 0, inserted.get(1).getDisabledStatus());
        assertEquals("teaching-1", inserted.get(1).getClassId());
        assertEquals("school-1", inserted.get(1).getSchoolId());
    }

    @Test
    void taskLookupUsesSchoolDefaultResolverForTeachingClass() {
        TaskAllocationController controller = controllerWithMocks();
        SchoolDefaultTaskService defaultTaskService = mock(SchoolDefaultTaskService.class);
        ReflectionTestUtils.setField(controller, "schoolDefaultTaskService", defaultTaskService);
        TaskAllocation allocation = new TaskAllocation();
        allocation.setModule("学校默认任务");
        when(defaultTaskService.resolveForTeachingClass("teaching-1")).thenReturn(List.of(allocation));

        ResultEntity<List<TaskAllocation>> result = controller.selectTaskAllocationByClassId("teaching-1");

        assertEquals(List.of(allocation), result.getBody().getData());
    }

    private TaskAllocationController controllerWithMocks() {
        TaskAllocationController controller = new TaskAllocationController();
        controller.taskAllocationMapper = mock(TaskAllocationMapper.class);
        controller.schoolClassMapper = mock(SchoolClassMapper.class);
        return controller;
    }
}