package org.leumasjaffe.recipe.controller;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Optional;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.platform.runner.JUnitPlatform;
import org.junit.runner.RunWith;
import org.leumasjaffe.recipe.model.RecipeCard;
import org.mockito.ArgumentCaptor;
import org.mockito.InOrder;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
@RunWith(JUnitPlatform.class)
class FileControllerTest {	
	@Mock SaveLoadHandle handle;
	@Mock FileController.ViewModel viewmodel;
	@InjectMocks FileController controller;
	
	@Test
	void testCanCreateNewModel() {
		controller.create();
		verify(viewmodel).setModel(any(RecipeCard.class));
	}

	@Test
	void testRepeatedCreatesProvideNewObjects() {
		InOrder inOrder = inOrder(viewmodel);
		final ArgumentCaptor<RecipeCard> first = ArgumentCaptor.forClass(RecipeCard.class);
		final ArgumentCaptor<RecipeCard> second = ArgumentCaptor.forClass(RecipeCard.class);

		controller.create();
		inOrder.verify(viewmodel).setModel(first.capture());

		controller.create();
		inOrder.verify(viewmodel).setModel(second.capture());
		
		assertNotSame(first.getValue(), second.getValue());
	}

	@Test
	void testOpensContentIntoRecipe() {
		final String data = "{ \"title\": \"Example\" }";
		doReturn(Optional.of(new StringReader(data))).when(handle).reader();

		controller.open();
		
		verify(viewmodel).setModel(argThat(r -> r.getTitle().equals("Example")));
	}

	@Test
	void testEmitsErrorWithMalformedData() {
		final String data = "{ \"name\": \"Example\" }";
		doReturn(Optional.of(new StringReader(data))).when(handle).reader();
		doNothing().when(handle).error(any());

		controller.open();
		
		verify(handle).error(any());
	}
	
	@Test
	void testCanWriteRecipeToStream() {
		StringWriter writer = new StringWriter();
		doReturn(Optional.of(writer)).when(handle).writer();
		
		controller.create();
		controller.save();
		assertNotEquals("", writer.toString());
	}
	
	@Test
	void testCreateClearsHandle() {
		controller.create();
		verify(handle, times(1)).clear();
	}
	
	@Test
	void testSaveAsClearsHandle() {
		StringWriter writer = new StringWriter();
		doReturn(Optional.of(writer)).when(handle).writer();
		
		controller.create();
		controller.saveAs();
		verify(handle, times(2)).clear();
		assertNotEquals("", writer.toString());
	}
	
	@Test
	void testWriteErrorCallsHandle() {
		Writer writer = mock(Writer.class, inv -> { throw new IOException(); });
		
		doReturn(Optional.of(writer)).when(handle).writer();
		doNothing().when(handle).error(any());
		
		controller.create();
		controller.save();
		verify(handle).error(any());
	}
	
	@Test
	void testDoesNothingIfHandleReturnsMissingReader() {
		doReturn(Optional.empty()).when(handle).reader();
		
		controller.open();
		verify(viewmodel, never()).setModel(any());
		verify(handle, never()).error(any());
	}
	
	@Test
	void testDoesNothingIfHandleReturnsMissingWriter() {
		doReturn(Optional.empty()).when(handle).writer();
		
		controller.create();
		controller.save();
		verify(handle, never()).error(any());
	}

}