package id.co.sofcograha.gajiidapi.testutils;

import static org.hamcrest.Matchers.is;
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.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import java.util.Map;
import java.util.Properties;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.http.MediaType;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultActions;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;

import com.fasterxml.jackson.databind.ObjectMapper;

import id.co.sofcograha.gajiidapi.FunctionAccessListForTest;
import id.co.sofcograha.gajiidapi.GajiIdApiApplicationTests;
import id.co.sofcograha.gajiidapi.base.authentication.anonymous.AnonymousAuthentication;
import id.co.sofcograha.gajiidapi.base.constants.BaseConstants;
import id.co.sofcograha.gajiidapi.base.extendables.BaseEntity;
import id.co.sofcograha.gajiidapi.base.extendables.BaseRepository;
import id.co.sofcograha.gajiidapi.base.mst.company.entities.Company;
import id.co.sofcograha.gajiidapi.base.mst.company.repositories.CompanyRepository;
import id.co.sofcograha.gajiidapi.base.mst.companyfunctionaccess.entities.CompanyFunctionAccess;
import id.co.sofcograha.gajiidapi.base.mst.companyfunctionaccess.repositories.CompanyFunctionAccessRepository;
import id.co.sofcograha.gajiidapi.base.mst.customer.entities.Customer;
import id.co.sofcograha.gajiidapi.base.mst.customer.repositories.CustomerRepository;
import id.co.sofcograha.gajiidapi.base.mst.functionaccess.entities.FunctionAccess;
import id.co.sofcograha.gajiidapi.base.mst.functionaccess.repositories.FunctionAccessRepository;
import id.co.sofcograha.gajiidapi.base.mst.groupuser.entities.GroupUser;
import id.co.sofcograha.gajiidapi.base.mst.groupuser.repositories.GroupUserRepository;
import id.co.sofcograha.gajiidapi.base.mst.groupuserfunctionaccess.entities.GroupUserFunctionAccess;
import id.co.sofcograha.gajiidapi.base.mst.groupuserfunctionaccess.repositories.GroupUserFunctionAccessRepository;
import id.co.sofcograha.gajiidapi.base.mst.report.repositories.ReportRepository;
import id.co.sofcograha.gajiidapi.base.mst.reportlog.repositories.ReportLogRepository;
import id.co.sofcograha.gajiidapi.base.mst.systemconfig.repositories.SystemConfigRepository;
import id.co.sofcograha.gajiidapi.base.mst.user.entities.User;
import id.co.sofcograha.gajiidapi.base.mst.user.repositories.UserRepository;
import id.co.sofcograha.gajiidapi.base.mst.usercompany.entities.UserCompany;
import id.co.sofcograha.gajiidapi.base.mst.usercompany.repositories.UserCompanyRepository;
import id.co.sofcograha.gajiidapi.base.mst.userfunctionaccess.entities.UserFunctionAccess;
import id.co.sofcograha.gajiidapi.base.mst.userfunctionaccess.repositories.UserFunctionAccessRepository;
import id.co.sofcograha.gajiidapi.base.mst.usergroupuser.entities.UserGroupUser;
import id.co.sofcograha.gajiidapi.base.mst.usergroupuser.repositories.UserGroupUserRepository;
import id.co.sofcograha.gajiidapi.base.utils.PasswordUtil;
import id.co.sofcograha.gajiidapi.base.utils.TokenUtil;
import id.co.sofcograha.gajiidapi.testutils.testcases.BaseControllerTestCases;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = GajiIdApiApplicationTests.class, webEnvironment = WebEnvironment.RANDOM_PORT)
@AutoConfigureTestDatabase
@AutoConfigureMockMvc
@TestPropertySource(locations = "classpath:application-test.properties", inheritLocations = false)
public abstract class BaseControllerIntegrationTest<E extends BaseEntity, R extends BaseRepository<E>>
        implements BaseControllerTestCases {

    @Autowired
    protected MockMvc mockMvc;

    @Autowired
    private CustomerRepository customerRepo;

    @Autowired
    private UserRepository userRepo;

    @Autowired
    private CompanyRepository companyRepo;

    @Autowired
    private GroupUserRepository groupUserRepo;

    @Autowired
    private UserGroupUserRepository userGroupUserRepo;

    @Autowired
    private UserCompanyRepository userCompanyRepo;

    @Autowired
    private FunctionAccessRepository functionAccessRepo;

    @Autowired
    private CompanyFunctionAccessRepository companyFunctionAccessRepo;

    @Autowired
    private UserFunctionAccessRepository userFunctionAccessRepo;

    @Autowired
    private GroupUserFunctionAccessRepository groupUserFunctionAccessRepo;

    @Autowired
    private ReportLogRepository reportLogRepository;

    @Autowired
    private ReportRepository reportRepository;

    @Autowired
    private SystemConfigRepository systemConfigRepository;

    @Autowired
    protected R repo;

    @Autowired
    protected ObjectMapper objectMapper;

    private static String username = "tester";
    private static String companycode = "public";
    private static String groupUserCode = "group_tester";
    private static String token = TokenUtil.generateTokenFromUsernameAndCompanyCode(username, companycode);

    protected Company companyLogin;
    protected User userLogin;
    protected GroupUser groupUserLogin;

    @BeforeClass
    public static void setSystemPropertyBefore() {
        Properties properties = System.getProperties();
        properties.setProperty("spring.profiles.active", "test");
    }

    @AfterClass
    public static void setSystemPropertyAfter() {
        System.clearProperty("spring.profiles.active");
    }

    /**
     * Basic setup for controller integration tests. Override this method to add
     * additional setup code for tests. Don't forget to call super.before() when
     * overriding.
     */
    @Before
    public void before() {
        SecurityContextHolder.getContext().setAuthentication(new AnonymousAuthentication());
        companyLogin = addCompany(companycode);
        userLogin = addUser(username, companyLogin);
        groupUserLogin = addGroupUser(groupUserCode);
        GroupUser groupUser = addGroupUser("EtcTest");
        addUserGroupUser(userLogin, groupUserLogin);
        addUserCompany(userLogin, companyLogin);
        for (Object[] functionAccessObj : FunctionAccessListForTest.list) {
            FunctionAccess functionAccess = addFunctionAccess((String) functionAccessObj[0],
                    RandomDataGenerator.randomString(10));
            addCompanyFunctionAccess(companyLogin, functionAccess);
            addUserFunctionAccess(userLogin, functionAccess, (Boolean) functionAccessObj[1],
                    (Boolean) functionAccessObj[2], (Boolean) functionAccessObj[3], (Boolean) functionAccessObj[4],
                    (Boolean) functionAccessObj[5], (Boolean) functionAccessObj[6]);
            addGroupUserFunctionAccess(groupUserLogin, functionAccess, (Boolean) functionAccessObj[1],
                    (Boolean) functionAccessObj[2], (Boolean) functionAccessObj[3], (Boolean) functionAccessObj[4],
                    (Boolean) functionAccessObj[5], (Boolean) functionAccessObj[6]);
            addGroupUserFunctionAccess(groupUser, functionAccess, (Boolean) functionAccessObj[1],
                    (Boolean) functionAccessObj[2], (Boolean) functionAccessObj[3], (Boolean) functionAccessObj[4],
                    (Boolean) functionAccessObj[5], (Boolean) functionAccessObj[6]);
        }
    }

    /**
     * Basic cleanup for controller integration tests. Override this method to add
     * additional cleanup code for tests. Don't forget to call super.after() when
     * overriding.
     */
    @After
    public void after() {
        repo.deleteAll();
        cleanSystemTbl();
    }

    public void afterForSystemTbl() {
        cleanSystemTbl();
        repo.deleteAll();
    }

    private void cleanSystemTbl() {
        companyFunctionAccessRepo.deleteAll();
        groupUserFunctionAccessRepo.deleteAll();
        reportLogRepository.deleteAll();
        userCompanyRepo.deleteAll();
        userFunctionAccessRepo.deleteAll();
        userGroupUserRepo.deleteAll();
        reportRepository.deleteAll();
        systemConfigRepository.deleteAll();
        groupUserRepo.deleteAll();
        functionAccessRepo.deleteAll();
        userRepo.deleteAll();
        companyRepo.deleteAll();
        customerRepo.deleteAll();
    }

    /**
     * Create basic Request Builder for GET method with token.
     */
    protected MockHttpServletRequestBuilder createGetRequestBuilder(String uri) {
        return get(uri).header(BaseConstants.AUTHORIZATION_HEADER, token);
    }

    protected MockHttpServletRequestBuilder createGetHeaderRequestBuilder(String uri, Map<String, String> variables) {

        MockHttpServletRequestBuilder requestBuilder = get(uri).header(BaseConstants.AUTHORIZATION_HEADER, token);
        for (Map.Entry<String, String> entry : variables.entrySet()) {
            requestBuilder = requestBuilder.header(entry.getKey(), entry.getValue());
        }

        return requestBuilder;
    }

    /**
     * Create basic Request Builder for POST method with token.
     */
    protected MockHttpServletRequestBuilder createPostRequestBuilder(String uri) {
        return post(uri).header(BaseConstants.AUTHORIZATION_HEADER, token);
    }

    /**
     * Create basic Request Builder for PUT method with token.
     */
    protected MockHttpServletRequestBuilder createPutRequestBuilder(String uri) {
        return put(uri).header(BaseConstants.AUTHORIZATION_HEADER, token);
    }

    /**
     * Create basic Request Builder for DELETE method with token.
     */
    protected MockHttpServletRequestBuilder createDeleteRequestBuilder(String uri) {
        return delete(uri).header(BaseConstants.AUTHORIZATION_HEADER, token);
    }

    /**
     * Call MockMvc perform with basic content expectation.
     */
    protected ResultActions performRequest(MockHttpServletRequestBuilder requestBuilder) throws Exception {
        return mockMvc.perform(requestBuilder).andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8));
    }

    /**
     * Call MockMvc perform with basic content expectation and OK status.
     */
    protected ResultActions performRequestOK(MockHttpServletRequestBuilder requestBuilder) throws Exception {
        return performRequest(requestBuilder).andExpect(status().isOk())
                .andExpect(jsonPath("$.status", is(BaseConstants.STATUS_OK)));
    }

    /**
     * Call MockMvc perform with basic content expectation and ERROR status.
     */
    protected ResultActions performRequestError(MockHttpServletRequestBuilder requestBuilder) throws Exception {
        return performRequest(requestBuilder).andExpect(status().isBadRequest())
                .andExpect(jsonPath("$.status", is(BaseConstants.STATUS_ERROR))).andExpect(jsonPath("$.data").isEmpty())
                .andExpect(jsonPath("$.errors").isNotEmpty());
    }

    private User addUser(String username, Company company) {
        User user = new User();
        user.setUserName(username);
        user.setName(username);
        user.setPassword(PasswordUtil.hashPassword(username));
        user.setCompany(company);
        user.setLocked(false);
        user.setActive(true);

        return userRepo.saveAndFlush(user);
    }

    private Customer addCustomer(String name) {
        Customer customer = new Customer();
        customer.setName(name);
        customer.setActive(true);

        customer = customerRepo.saveAndFlush(customer);
        return customer;
    }

    private Company addCompany(String code) {
        Company company = new Company();
        company.setCode(code);
        company.setName(code);
        company.setCustomer(addCustomer(RandomDataGenerator.randomString(20)));
        company.setAddress(RandomDataGenerator.randomString(99));
        company.setCity(RandomDataGenerator.randomString(50));
        company.setPhoneNumber(RandomDataGenerator.randomString(20));
        company.setEmail(RandomDataGenerator.randomString(50));
        company.setPicName(RandomDataGenerator.randomString(50));
        company.setPicPosition(RandomDataGenerator.randomString(50));
        company.setPicEmail(RandomDataGenerator.randomString(50));
        company.setActiveStartMonth(RandomDataGenerator.randomDateBeforeToday());
        company.setActiveEndMonth(RandomDataGenerator.randomDateAfterToday());
        company.setActive(true);

        return companyRepo.saveAndFlush(company);
    }

    private GroupUser addGroupUser(String name) {
        GroupUser groupUser = new GroupUser();
        groupUser.setName(name);
        groupUser.setDescription(RandomDataGenerator.randomString(20));
        groupUser.setActive(true);

        groupUser = groupUserRepo.saveAndFlush(groupUser);
        return groupUser;
    }

    private UserGroupUser addUserGroupUser(User user, GroupUser groupUser) {
        UserGroupUser userGroupUser = new UserGroupUser();
        userGroupUser.setUser(user);
        userGroupUser.setGroupUser(groupUser);
        userGroupUser.setActive(true);

        userGroupUser = userGroupUserRepo.saveAndFlush(userGroupUser);
        return userGroupUser;
    }

    private void addUserCompany(User user, Company company) {
        UserCompany userCompany = new UserCompany();
        userCompany.setUser(user);
        userCompany.setCompany(company);
        userCompany.setStartDate(RandomDataGenerator.randomDateBeforeToday());
        userCompany.setEndDate(RandomDataGenerator.randomDateAfterToday());
        userCompany.setSuperUser(false);

        userCompanyRepo.saveAndFlush(userCompany);
    }

    private FunctionAccess addFunctionAccess(String code, String description) {
        FunctionAccess functionAccess = new FunctionAccess();
        functionAccess.setCode(code);
        functionAccess.setDescription(description);
        functionAccess.setActive(true);

        functionAccess = functionAccessRepo.saveAndFlush(functionAccess);
        return functionAccess;
    }

    private CompanyFunctionAccess addCompanyFunctionAccess(Company company, FunctionAccess functionAccess) {
        CompanyFunctionAccess companyFunctionAccess = new CompanyFunctionAccess();
        companyFunctionAccess.setCompany(company);
        companyFunctionAccess.setFunctionAccess(functionAccess);

        companyFunctionAccess = companyFunctionAccessRepo.saveAndFlush(companyFunctionAccess);
        return companyFunctionAccess;
    }

    private UserFunctionAccess addUserFunctionAccess(User user, FunctionAccess functionAccess, Boolean allowRead,
            Boolean allowAdd, Boolean allowEdit, Boolean allowDelete, Boolean allowConfirm,
            Boolean allowCancelConfirm) {
        UserFunctionAccess userFunctionAccess = new UserFunctionAccess();
        userFunctionAccess.setUser(user);
        userFunctionAccess.setFunctionAccess(functionAccess);
        userFunctionAccess.setAllowRead(allowRead);
        userFunctionAccess.setAllowAdd(allowAdd);
        userFunctionAccess.setAllowEdit(allowEdit);
        userFunctionAccess.setAllowDelete(allowDelete);
        userFunctionAccess.setAllowConfirm(allowConfirm);
        userFunctionAccess.setAllowCancelConfirm(allowCancelConfirm);
        userFunctionAccess.setActive(true);

        userFunctionAccess = userFunctionAccessRepo.saveAndFlush(userFunctionAccess);
        return userFunctionAccess;
    }

    private GroupUserFunctionAccess addGroupUserFunctionAccess(GroupUser groupUser, FunctionAccess functionAccess,
            Boolean allowRead, Boolean allowAdd, Boolean allowEdit, Boolean allowDelete, Boolean allowConfirm,
            Boolean allowCancelConfirm) {
        GroupUserFunctionAccess groupUserFunctionAccess = new GroupUserFunctionAccess();
        groupUserFunctionAccess.setGroupUser(groupUser);
        groupUserFunctionAccess.setFunctionAccess(functionAccess);
        groupUserFunctionAccess.setAllowRead(allowRead);
        groupUserFunctionAccess.setAllowAdd(allowAdd);
        groupUserFunctionAccess.setAllowEdit(allowEdit);
        groupUserFunctionAccess.setAllowDelete(allowDelete);
        groupUserFunctionAccess.setAllowConfirm(allowConfirm);
        groupUserFunctionAccess.setAllowCancelConfirm(allowCancelConfirm);
        groupUserFunctionAccess.setActive(true);

        groupUserFunctionAccess = groupUserFunctionAccessRepo.saveAndFlush(groupUserFunctionAccess);
        return groupUserFunctionAccess;
    }
}