RaidBuilderAPI/src/main/java/com/mattrixwv/raidbuilder/controller/RaidGroupRequestController.java

package com.mattrixwv.raidbuilder.controller;


import java.util.List;
import java.util.UUID;

import org.springframework.security.core.Authentication;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.mattrixwv.raidbuilder.annotation.AccountAuthorization;
import com.mattrixwv.raidbuilder.annotation.RaidGroupAuthorization;
import com.mattrixwv.raidbuilder.entity.Account;
import com.mattrixwv.raidbuilder.entity.RaidGroupRequest;
import com.mattrixwv.raidbuilder.service.AccountService;
import com.mattrixwv.raidbuilder.service.RaidGroupRequestService;
import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.AccountPermissionType;
import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.RaidGroupPermissionType;
import com.mattrixwv.raidbuilder.util.validation.RaidGroupRequestValidationUtil;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import tools.jackson.databind.ObjectMapper;
import tools.jackson.databind.node.ArrayNode;
import tools.jackson.databind.node.ObjectNode;


@Slf4j
@RestController
@RequestMapping("/raidGroup/{raidGroupId}/raidGroupRequest")
@RequiredArgsConstructor
public class RaidGroupRequestController{
	private final ObjectMapper mapper;
	private final AccountService accountService;
	private final RaidGroupRequestService rgrService;
	//Utilities
	private final RaidGroupRequestValidationUtil rgrvUtil;


	@GetMapping
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
	@RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN})
	public List<RaidGroupRequest> getRaidGroupRequests(@PathVariable("raidGroupId") UUID raidGroupId, @RequestParam("page") int page, @RequestParam("pageSize") int pageSize, @RequestParam(name = "searchTerm", required = false) String searchTerm){
		log.info("Getting raid group requests for raid group id: {}", raidGroupId);


		List<RaidGroupRequest> raidGroupRequests = searchTerm == null ?
			rgrService.getByRaidGroupId(raidGroupId, page, pageSize) :
			rgrService.getByRaidGroupId(raidGroupId, page, pageSize, searchTerm);


		return raidGroupRequests;
	}

	@GetMapping("/count")
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
	public ObjectNode getRaidGroupRequestCount(@PathVariable("raidGroupId") UUID raidGroupId, @RequestParam(name = "searchTerm", required = false) String searchTerm){
		log.info("Getting Raid Group Request Count for Raid Group {} with search {}", raidGroupId, searchTerm);


		long count = searchTerm == null ?
			rgrService.getCountByRaidGroupId(raidGroupId) :
			rgrService.getCountByRaidGroupId(raidGroupId, searchTerm);

		ObjectNode returnNode = mapper.createObjectNode();
		returnNode.put("count", count);
		returnNode.put("status", "success");

		return returnNode;
	}

	@PutMapping("/{raidGroupRequestId}/resolve")
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
	@RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN})
	public ObjectNode resolveRaidGroupRequest(@PathVariable("raidGroupId") UUID raidGroupId, @PathVariable("raidGroupRequestId") UUID raidGroupRequestId, @RequestBody ObjectNode bodyNode){
		log.info("Resolving raid group request for raid group id: {}", raidGroupId);


		String resolution = bodyNode.get("resolution").asString();
		if(resolution.equals("denied")){
			rgrService.deleteRaidGroupRequest(raidGroupRequestId);
		}
		else{
			RaidGroupPermissionType permissionType = RaidGroupPermissionType.valueOf(resolution);
			rgrService.resolveRaidGroupRequest(raidGroupRequestId, permissionType);
		}

		ObjectNode returnNode = mapper.createObjectNode();
		returnNode.put("status", "success");


		return returnNode;
	}


	@PostMapping
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
	public ObjectNode createRaidGroupRequest(@PathVariable("raidGroupId") UUID raidGroupId, @RequestBody RaidGroupRequest raidGroupRequest, Authentication authentication){
		log.info("Creating raid group request for raid group id: {}", raidGroupId);


		Account account = accountService.getByUsername(authentication.getName());
		raidGroupRequest.setAccountId(account.getAccountId());
		raidGroupRequest.setRaidGroupId(raidGroupId);
		ObjectNode returnNode = mapper.createObjectNode();
		List<String> errors = rgrvUtil.validateNewRaidGroupRequest(raidGroupRequest);
		if(errors.isEmpty()){
			raidGroupRequest = rgrService.createRaidGroupRequest(raidGroupRequest);

			returnNode.put("status", "success");
			returnNode.put("raidGroupRequestId", raidGroupRequest.getRaidGroupRequestId().toString());

			log.info("Created raid group request for raid group id: {}", raidGroupId);
		}
		else{
			returnNode.put("status", "fail");
			returnNode.set("errors", mapper.valueToTree(errors));
		}


		return returnNode;
	}

	@PutMapping("/{raidGroupRequestId}")
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
	public ObjectNode updateRaidGroupRequest(@PathVariable("raidGroupId") UUID raidGroupId, @PathVariable("raidGroupRequestId") UUID raidGroupRequestId, @RequestBody RaidGroupRequest raidGroupRequest){
		log.info("Updating raid group request for raid group id: {}", raidGroupId);


		raidGroupRequest.setRaidGroupRequestId(raidGroupRequestId);
		raidGroupRequest.setRaidGroupId(raidGroupId);
		ObjectNode returnNode = mapper.createObjectNode();
		List<String> errors = rgrvUtil.validateExistingRaidGroupRequest(raidGroupRequest);
		if(errors.isEmpty()){
			raidGroupRequest = rgrService.updateRaidGroupRequest(raidGroupRequest);

			returnNode.put("status", "success");
			returnNode.put("raidGroupRequestId", raidGroupRequest.getRaidGroupRequestId().toString());
		}
		else{
			returnNode.put("status", "fail");
			returnNode.set("errors", mapper.valueToTree(errors));
		}


		return returnNode;
	}

	@DeleteMapping("/{raidGroupRequestId}")
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
	public ObjectNode deleteRaidGroupRequest(@PathVariable("raidGroupId") UUID raidGroupId, @PathVariable("raidGroupRequestId") UUID raidGroupRequestId){
		log.info("Deleting raid group request for raid group id: {}", raidGroupId);


		ObjectNode returnNode = mapper.createObjectNode();
		RaidGroupRequest existingRaidGroupRequest = rgrService.getById(raidGroupRequestId);
		if(existingRaidGroupRequest != null){
			rgrService.deleteRaidGroupRequest(raidGroupRequestId);

			returnNode.put("status", "success");
		}
		else{
			returnNode.put("status", "fail");
			ArrayNode errorsNode = mapper.createArrayNode();
			errorsNode.add("Raid Group Request does not exist");
			returnNode.set("errors", errorsNode);
		}


		return returnNode;
	}
}