package com.mattrixwv.raidbuilder.controller;


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

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.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.mattrixwv.raidbuilder.annotation.AccountAuthorization;
import com.mattrixwv.raidbuilder.annotation.RaidGroupAuthorization;
import com.mattrixwv.raidbuilder.entity.PersonCharacter;
import com.mattrixwv.raidbuilder.entity.RaidGroup;
import com.mattrixwv.raidbuilder.service.PersonCharacterService;
import com.mattrixwv.raidbuilder.service.RaidGroupService;
import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.AccountPermissionType;
import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.RaidGroupPermissionType;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;


@Slf4j
@RestController
@RequestMapping("/raidGroup")
@RequiredArgsConstructor
public class RaidGroupController{
	private final ObjectMapper mapper;
	private final RaidGroupService raidGroupService;
	private final PersonCharacterService personCharacterService;


	@GetMapping
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN})
	public List<RaidGroup> getRaidGroups(@RequestParam("page") int page, @RequestParam("pageSize") int pageSize, @RequestParam(value = "searchTerm", required = false) String searchTerm){
		log.info("Getting raid groups page {} of size {} with search term {}", page, pageSize, searchTerm);


		List<RaidGroup> raidGroups;
		if((searchTerm == null) || (searchTerm.isBlank())){
			raidGroups = raidGroupService.getRaidGroups(page, pageSize);
		}
		else{
			raidGroups = raidGroupService.getRaidGroups(page, pageSize, searchTerm);
		}


		return raidGroups;
	}

	@GetMapping("/count")
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN})
	public ObjectNode getRaidGroupsCount(@RequestParam(value = "searchTerm", required = false) String searchTerm){
		log.info("Getting raid groups count with search term {}", searchTerm);


		Long raidGroupsCount;
		if((searchTerm == null) || (searchTerm.isBlank())){
			raidGroupsCount = raidGroupService.getRaidGroupsCount();
		}
		else{
			raidGroupsCount = raidGroupService.getRaidGroupsCount(searchTerm);
		}

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


		return countNode;
	}


	@PostMapping
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
	public ObjectNode createRaidGroup(@RequestParam(value = "iconFile", required = false) MultipartFile file, @RequestParam("raidGroupName") String raidGroupName, @RequestParam("gameId") UUID gameId){
		log.info("Creating raid group {}", raidGroupName);


		//TODO: New raid group verification
		ObjectNode returnNode = mapper.createObjectNode();
		RaidGroup raidGroup = new RaidGroup();
		raidGroup.setGameId(gameId);
		raidGroup.setRaidGroupName(raidGroupName);
		raidGroupService.createRaidGroup(raidGroup, file);

		returnNode.put("raidGroupId", raidGroup.getRaidGroupId().toString());
		returnNode.put("status", "success");

		log.info("Successfully created raid group: {}", raidGroup.getRaidGroupId());

		return returnNode;
	}

	@GetMapping("/{raidGroupId}")
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
	@RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN, RaidGroupPermissionType.LEADER, RaidGroupPermissionType.RAIDER})
	public RaidGroup getRaidGroup(@PathVariable("raidGroupId") UUID raidGroupId){
		log.info("Getting raid group {}", raidGroupId);


		RaidGroup raidGroup = raidGroupService.getByRaidGroupId(raidGroupId);


		return raidGroup;
	
	}

	@PutMapping("/{raidGroupId}")
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
	@RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN})
	public ObjectNode updateRaidGroup(@RequestParam(value = "iconFile", required = false) MultipartFile file, @PathVariable("raidGroupId") UUID raidGroupId, @RequestParam("raidGroupName") String raidGroupName, @RequestParam("gameId") UUID gameId, @RequestParam(value = "raidGroupIcon", required = false) String raidGroupIcon){
		log.info("Updating raid group {}", raidGroupName);


		ObjectNode returnNode = mapper.createObjectNode();
		RaidGroup raidGroup = new RaidGroup();
		raidGroup.setRaidGroupId(raidGroupId);
		raidGroup.setGameId(gameId);
		raidGroup.setRaidGroupName(raidGroupName);
		raidGroup.setRaidGroupIcon(raidGroupIcon);
		raidGroupService.updateRaidGroup(raidGroup, file);

		returnNode.put("raidGroupId", raidGroup.getRaidGroupId().toString());
		returnNode.put("status", "success");

		log.info("Successfully updated raid group: {}", raidGroup.getRaidGroupId());

		return returnNode;
	}

	@DeleteMapping("/{raidGroupId}")
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
	@RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN})
	public ObjectNode deleteRaidGroup(@PathVariable("raidGroupId") UUID raidGroupId){
		log.info("Deleting raid group {}", raidGroupId);


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

		log.info("Successfully deleted raid group: {}", raidGroupId);

		return returnNode;
	}


	//!Game
	@GetMapping("/game/{gameId}")
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
	public List<RaidGroup> getRaidGroupsByGame(@PathVariable("gameId") UUID gameId, @RequestParam("page") int page, @RequestParam("pageSize") int pageSize, @RequestParam(value = "searchTerm", required = false) String searchTermString){
		log.info("Getting raid groups for game {} page {} of size {} with search term {}", gameId, page, pageSize, searchTermString);


		List<RaidGroup> raidGroups;
		if((searchTermString == null) || (searchTermString.isBlank())){
			raidGroups = raidGroupService.getRaidGroupsByGame(gameId, page, pageSize);
		}
		else{
			raidGroups = raidGroupService.getRaidGroupsByGame(gameId, page, pageSize, searchTermString);
		}


		return raidGroups;
	}

	@GetMapping("/game/{gameId}/count")
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
	public ObjectNode getRaidGroupsCountByGame(@PathVariable("gameId") UUID gameId, @RequestParam(value = "searchTerm", required = false) String searchTerm){
		log.info("Getting raid groups count for game {} with search term {}", gameId, searchTerm);


		Long raidGroupsCount;
		if((searchTerm == null) || (searchTerm.isBlank())){
			raidGroupsCount = raidGroupService.getRaidGroupsCountByGame(gameId);
		}
		else{
			raidGroupsCount = raidGroupService.getRaidGroupsCountByGame(gameId, searchTerm);
		}

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


		return countNode;
	}


	//!Account
	@GetMapping("/account/{accountId}")
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
	public List<RaidGroup> getRaidGroupsByAccount(@PathVariable("accountId") UUID accountId, @RequestParam("page") int page, @RequestParam("pageSize") int pageSize, @RequestParam(value = "searchTerm", required = false) String searchTermString){
		log.info("Getting raid groups for account {} page {} of size {} with search term {}", accountId, page, pageSize, searchTermString);


		List<RaidGroup> raidGroups;
		if((searchTermString == null) || (searchTermString.isBlank())){
			raidGroups = raidGroupService.getRaidGroupsByAccount(accountId, page, pageSize);
		}
		else{
			raidGroups = raidGroupService.getRaidGroupsByAccount(accountId, page, pageSize, searchTermString);
		}


		return raidGroups;
	}

	@GetMapping("/account/{accountId}/count")
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
	public ObjectNode getRaidGroupsCountByAccount(@PathVariable("accountId") UUID accountId, @RequestParam(value = "searchTerm", required = false) String searchTerm){
		log.info("Getting raid groups count for account {} with search term {}", accountId, searchTerm);


		Long raidGroupsCount;
		if((searchTerm == null) || (searchTerm.isBlank())){
			raidGroupsCount = raidGroupService.getRaidGroupsCountByAccount(accountId);
		}
		else{
			raidGroupsCount = raidGroupService.getRaidGroupsCountByAccount(accountId, searchTerm);
		}

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


		return countNode;
	}


	//!Person Character
	@GetMapping("/{raidGroupId}/person/character")
	@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
	@RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN, RaidGroupPermissionType.LEADER, RaidGroupPermissionType.RAIDER})
	public List<PersonCharacter> getPersonCharactersByRaidGroup(@PathVariable("raidGroupId") UUID raidGroupId){
		log.info("Getting person characters for raid group {}", raidGroupId);


		List<PersonCharacter> personCharacters = personCharacterService.getPersonCharactersByRaidGroupId(raidGroupId);


		return personCharacters;
	}
}