package com.mattrixwv.cipherstream.controller.monosubstitution;


import static org.mockito.Mockito.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

import com.fasterxml.jackson.databind.node.ObjectNode;
import com.mattrixwv.cipherstream.aspect.CipherStreamLoggingAspect;
import com.mattrixwv.cipherstream.controller.CipherStreamControllerIntegrationTestBase;
import com.mattrixwv.cipherstream.utils.CipherInfoUtil;
import com.mattrixwv.cipherstream.utils.CipherParameterUtil;


@Tag("integration-test")
@WebMvcTest(controllers = BaseXCipherController.class)
public class BaseXCipherControllerIntegrationTest extends CipherStreamControllerIntegrationTestBase{
	@Autowired
	private MockMvc mockMvc;
	//Loggers
	@Mock(name = "com.mattrixwv.cipherstream.controller.monosubstitution.BaseXCipherController")
	protected Logger baseXLogger;
	//Fields
	private String url = "/basex";
	private String decodedString = "A+B@C d\te\nf";
	private String encodedString = "1000001 101011 1000010 1000000 1000011 100000 1100100 1001 1100101 1010 1100110";
	private int base = 2;
	private static final ObjectNode blankNode = mapper.createObjectNode();


	@BeforeEach
	public void setup(){
		decodedNode = mapper.createObjectNode();
		decodedNode.put(CipherParameterUtil.PRESERVE_CAPITALS, true);
		decodedNode.put(CipherParameterUtil.PRESERVE_WHITESPACE, true);
		decodedNode.put(CipherParameterUtil.PRESERVE_SYMBOLS, true);
		decodedNode.put(CipherParameterUtil.BASE_X_BASE, base);
		decodedNode.put(CipherParameterUtil.INPUT_STRING, decodedString);
		decodedNode.put(CipherParameterUtil.OUTPUT_STRING, encodedString);

		encodedNode = mapper.createObjectNode();
		encodedNode.put(CipherParameterUtil.PRESERVE_CAPITALS, true);
		encodedNode.put(CipherParameterUtil.PRESERVE_WHITESPACE, true);
		encodedNode.put(CipherParameterUtil.PRESERVE_SYMBOLS, true);
		encodedNode.put(CipherParameterUtil.BASE_X_BASE, base);
		encodedNode.put(CipherParameterUtil.INPUT_STRING, encodedString);
		encodedNode.put(CipherParameterUtil.OUTPUT_STRING, decodedString);
	}


	@Test
	public void testGetCipherInfo() throws Exception{
		ObjectNode infoNode = CipherInfoUtil.buildInfoNode(CipherInfoUtil.BASE_X_CIPHER_NAME, CipherInfoUtil.BASE_X_CIPHER_DESCRIPTION);

		mockMvc.perform(get(url)
				.header("X-Request-Id", requestId)
				.header("X-Forwarded-For", ipAddress))
			.andExpect(status().isOk())
			.andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
			.andExpect(jsonPath(CipherInfoUtil.CIPHER_DESCRIPTION).value(CipherInfoUtil.BASE_X_CIPHER_DESCRIPTION))
			.andExpect(jsonPath(CipherInfoUtil.CIPHER_NAME).value(CipherInfoUtil.BASE_X_CIPHER_NAME));

		//Filter
		super.verifyFilter(url);
		//Controller
		verify(baseXLogger, times(1)).info("Getting info for {}", CipherInfoUtil.BASE_X_CIPHER_NAME);
		verify(mdc, times(1)).put(CipherStreamLoggingAspect.CIPHER_NAME_LOGGING, CipherInfoUtil.BASE_X_CIPHER_NAME);
		//Cipher Aspect
		verify(aspectLogger, times(1)).info("CipherStream log {}", infoNode);
	}

	@Test
	public void testEncodeBaseXEncode() throws Exception{
		mockMvc.perform(post(url + "/encode")
				.header("X-Request-Id", requestId)
				.header("X-Forwarded-For", ipAddress)
				.contentType(MediaType.APPLICATION_JSON)
				.content(decodedNode.toString()))
			.andExpect(status().isOk())
			.andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
			.andExpect(jsonPath(CipherParameterUtil.OUTPUT_STRING).value(encodedString));

		//Filter
		super.verifyFilter(url + "/encode");
		//Controller
		verify(baseXLogger, times(1)).info("Encoding {}", CipherInfoUtil.BASE_X_CIPHER_NAME);
		verify(mdc, times(1)).put(CipherStreamLoggingAspect.CIPHER_NAME_LOGGING, CipherInfoUtil.BASE_X_CIPHER_NAME);
		//Cipher Aspect
		verify(aspectLogger, times(1)).info("CipherStream log {}", decodedNode);
	}

	@Test
	public void testEncodeBaseX_error() throws Exception{
		mockMvc.perform(post(url + "/encode")
				.header("X-Request-Id", requestId)
				.header("X-Forwarded-For", ipAddress)
				.contentType(MediaType.APPLICATION_JSON)
				.content(blankNode.toString()))
			.andExpect(status().isBadRequest())
			.andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
			.andExpect(jsonPath("message").value(CipherParameterUtil.INPUT_STRING + CipherParameterUtil.PRESENT_MESSAGE));

		//Filter
		super.verifyFilter(url + "/encode");
		//Controller
		verify(baseXLogger, times(1)).info("Encoding {}", CipherInfoUtil.BASE_X_CIPHER_NAME);
		verify(mdc, times(1)).put(CipherStreamLoggingAspect.CIPHER_NAME_LOGGING, CipherInfoUtil.BASE_X_CIPHER_NAME);
		//Cipher Aspect
		verifyNoInteractions(aspectLogger);
	}

	@Test
	public void testDecodeBaseXDecode() throws Exception{
		mockMvc.perform(post(url + "/decode")
				.header("X-Request-Id", requestId)
				.header("X-Forwarded-For", ipAddress)
				.contentType(MediaType.APPLICATION_JSON)
				.content(encodedNode.toString()))
			.andExpect(status().isOk())
			.andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
			.andExpect(jsonPath(CipherParameterUtil.OUTPUT_STRING).value(decodedString));

		//Filter
		super.verifyFilter(url + "/decode");
		//Controller
		verify(baseXLogger, times(1)).info("Decoding {}", CipherInfoUtil.BASE_X_CIPHER_NAME);
		verify(mdc, times(1)).put(CipherStreamLoggingAspect.CIPHER_NAME_LOGGING, CipherInfoUtil.BASE_X_CIPHER_NAME);
		//Cipher Aspect
		verify(aspectLogger, times(1)).info("CipherStream log {}", encodedNode);
	}

	@Test
	public void testDecodeBaseX_error() throws Exception{
		mockMvc.perform(post(url + "/decode")
				.header("X-Request-Id", requestId)
				.header("X-Forwarded-For", ipAddress)
				.contentType(MediaType.APPLICATION_JSON)
				.content(blankNode.toString()))
			.andExpect(status().isBadRequest())
			.andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
			.andExpect(jsonPath("message").value(CipherParameterUtil.INPUT_STRING + CipherParameterUtil.PRESENT_MESSAGE));

		//Filter
		super.verifyFilter(url + "/decode");
		//Controller
		verify(baseXLogger, times(1)).info("Decoding {}", CipherInfoUtil.BASE_X_CIPHER_NAME);
		verify(mdc, times(1)).put(CipherStreamLoggingAspect.CIPHER_NAME_LOGGING, CipherInfoUtil.BASE_X_CIPHER_NAME);
		//Cipher Aspect
		verifyNoInteractions(aspectLogger);
	}
}