package it.inaf.ia2.gms.controller;

import com.fasterxml.jackson.databind.ObjectMapper;
import it.inaf.ia2.gms.GmsTestUtils;
import static it.inaf.ia2.gms.controller.ControllersMockData.*;
import it.inaf.ia2.gms.manager.GroupsManager;
import it.inaf.ia2.gms.manager.PermissionsManager;
import it.inaf.ia2.gms.model.GroupNode;
import it.inaf.ia2.gms.model.Permission;
import it.inaf.ia2.gms.model.request.AddGroupRequest;
import it.inaf.ia2.gms.model.response.GroupsTabResponse;
import it.inaf.ia2.gms.model.response.PaginatedData;
import it.inaf.ia2.gms.persistence.GroupsDAO;
import it.inaf.ia2.gms.persistence.LoggingDAO;
import it.inaf.ia2.gms.persistence.model.GroupEntity;
import it.inaf.ia2.gms.service.GroupNameService;
import it.inaf.ia2.gms.service.GroupsService;
import it.inaf.ia2.gms.service.GroupsTreeBuilder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import javax.servlet.http.HttpServletRequest;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.junit.Assert.assertEquals;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.eq;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;

@RunWith(MockitoJUnitRunner.class)
public class GroupsControllerTest {

    @Mock
    private GroupsTabResponseBuilder groupsTabResponseBuilder;

    @Mock
    private GroupsManager groupsManager;

    @Mock
    private GroupsService groupsService;

    @Mock
    private HttpServletRequest servletRequest;

    @Mock
    private PermissionsManager permissionsManager;

    @Mock
    private GroupsTreeBuilder groupsTreeBuilder;

    @Mock
    private GroupsDAO groupsDAO;

    @Mock
    private LoggingDAO loggingDAO;

    @InjectMocks
    private GroupsController controller;

    private final ObjectMapper mapper = new ObjectMapper();

    private MockMvc mockMvc;

    @Before
    public void init() {
        mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
        controller.groupNameService = new GroupNameService(groupsDAO);
        GmsTestUtils.mockPrincipal(servletRequest);
    }

    @Test
    public void testGetGroupsPaginated() throws Exception {

        GroupsTabResponse response = new GroupsTabResponse();
        response.setBreadcrumbs(new ArrayList<>());
        response.setGroupsPanel(new PaginatedData<>(new ArrayList<>(), 1, 10));
        response.setPermission(Permission.ADMIN);

        when(groupsTabResponseBuilder.getGroupsTab(any())).thenReturn(response);

        mockMvc.perform(get("/ui/groups?groupId=ROOT&paginatorPageSize=20&paginatorPage=1"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.breadcrumbs", notNullValue()))
                .andExpect(jsonPath("$.groupsPanel", notNullValue()))
                .andExpect(jsonPath("$.permission", is("ADMIN")));
    }

    @Test
    public void testAddGroupPaginated() throws Exception {

        AddGroupRequest request = new AddGroupRequest();
        request.setNewGroupName("New Group");
        request.setParentGroupId("abcd");
        request.setLeaf(true);
        request.setPaginatorPage(1);
        request.setPaginatorPageSize(10);

        List<GroupNode> nodes = new ArrayList<>();
        PaginatedData<GroupNode> paginatedData = new PaginatedData<>(nodes, 1, 10);
        when(groupsTreeBuilder.listSubGroups(any(), any(), any())).thenReturn(paginatedData);

        mockMvc.perform(post("/ui/group")
                .content(mapper.writeValueAsString(request))
                .accept(MediaType.APPLICATION_JSON)
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isCreated());
    }

    @Test
    public void testDeleteGroupPaginated() throws Exception {

        mockMvc.perform(delete("/ui/group/id?paginatorPageSize=20&paginatorPage=1&searchFilter="))
                .andDo(print())
                .andExpect(status().isOk());

        verify(groupsManager, times(1)).deleteGroup(eq("id"));
    }

    @Test
    public void testAddGroup() throws Exception {

        GroupEntity peopleGroup = getPeopleGroup();

        when(groupsManager.getRoot()).thenReturn(getRoot());
        when(groupsManager.createGroup(any(GroupEntity.class), eq("people"), eq(false))).thenReturn(peopleGroup);
        when(groupsManager.createGroup(any(GroupEntity.class), eq("name.surname"), eq(true))).thenReturn(getNameSurnameGroup());

        mockMvc.perform(post("/group")
                .param("name", "people.name\\.surname")
                .param("leaf", "true")
                .accept(MediaType.TEXT_PLAIN)
                .contentType(MediaType.APPLICATION_FORM_URLENCODED))
                .andExpect(status().isCreated());

        verify(groupsService, times(2)).findGroupByParentAndName(any(GroupEntity.class), any());
        verify(groupsManager, times(1)).createGroup(argGroupIdEq(GroupsService.ROOT), eq("people"), eq(false));
        verify(groupsManager, times(1)).createGroup(argGroupIdEq("people_id"), eq("name.surname"), eq(true));
    }

    @Test
    public void testDeleteGroup() throws Exception {

        GroupEntity inafGroup = getInafGroup();

        when(groupsDAO.findGroupByParentAndName("", "LBT")).thenReturn(Optional.of(getLbtGroup()));
        when(groupsDAO.findGroupByParentAndName("lbt_id", "INAF")).thenReturn(Optional.of(inafGroup));

        mockMvc.perform(delete("/group?name=LBT.INAF"))
                .andExpect(status().isNoContent());

        verify(groupsManager, times(1)).deleteGroup(eq(inafGroup.getId()));
    }

    @Test
    public void testListChildGroups() throws Exception {

        GroupEntity lbtGroup = getLbtGroup();
        GroupEntity inafGroup = getInafGroup();
        GroupEntity inafProgramGroup = getInafProgramGroup();

        when(groupsDAO.findGroupByParentAndName("", "LBT")).thenReturn(Optional.of(lbtGroup));
        when(groupsDAO.findGroupByParentAndName(lbtGroup.getPath(), "INAF")).thenReturn(Optional.of(inafGroup));

        Map<String, String> namesMap = Map.of(inafProgramGroup.getId(), "LBT.INAF.P1");
        when(groupsDAO.getGroupCompleteNamesFromId(Set.of(inafProgramGroup.getId()))).thenReturn(namesMap);

        when(groupsManager.getChildGroups(eq(inafGroup), anyBoolean())).thenReturn(Arrays.asList(inafProgramGroup));

        String response = mockMvc.perform(get("/groups?parent=LBT.INAF&recursive=false")
                .accept(MediaType.TEXT_PLAIN))
                .andExpect(status().isOk())
                .andReturn().getResponse().getContentAsString();

        assertEquals("P1\n", response);
    }

    private GroupEntity argGroupIdEq(String groupId) {
        return argThat(g -> g.getId().equals(groupId));
    }
}