/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.fineract.cn.teller;

import org.apache.commons.lang3.RandomStringUtils;
import org.apache.fineract.cn.accounting.api.v1.domain.Account;
import org.apache.fineract.cn.teller.api.v1.EventConstants;
import org.apache.fineract.cn.teller.api.v1.client.TellerAlreadyExistsException;
import org.apache.fineract.cn.teller.api.v1.client.TellerNotFoundException;
import org.apache.fineract.cn.teller.api.v1.client.TellerValidationException;
import org.apache.fineract.cn.teller.api.v1.domain.Teller;
import org.apache.fineract.cn.teller.api.v1.domain.TellerBalanceSheet;
import org.apache.fineract.cn.teller.api.v1.domain.TellerManagementCommand;
import org.apache.fineract.cn.teller.util.TellerGenerator;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.mockito.Matchers;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.restdocs.JUnitRestDocumentation;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;

import static org.springframework.restdocs.mockmvc.MockMvcRestDocumentation.document;
import static org.springframework.restdocs.mockmvc.MockMvcRestDocumentation.documentationConfiguration;
import static org.springframework.restdocs.mockmvc.RestDocumentationRequestBuilders.delete;
import static org.springframework.restdocs.mockmvc.RestDocumentationRequestBuilders.get;
import static org.springframework.restdocs.mockmvc.RestDocumentationRequestBuilders.post;
import static org.springframework.restdocs.mockmvc.RestDocumentationRequestBuilders.put;
import static org.springframework.restdocs.operation.preprocess.Preprocessors.preprocessRequest;
import static org.springframework.restdocs.operation.preprocess.Preprocessors.preprocessResponse;
import static org.springframework.restdocs.operation.preprocess.Preprocessors.prettyPrint;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

public class TestTellerManagement extends AbstractTellerTest {

    @Rule
    public final JUnitRestDocumentation restDocumentation = new JUnitRestDocumentation("src/doc/generated-snippets/test-teller-management");

    @Autowired
    private WebApplicationContext context;

    private MockMvc mockMvc;

    final String path = "/teller/v1";

    @Before
    public void setUp(){

        this.mockMvc = MockMvcBuilders.webAppContextSetup(this.context)
                .apply(documentationConfiguration(this.restDocumentation))
                .alwaysDo(document("{method-name}", preprocessRequest(prettyPrint()), preprocessResponse(prettyPrint())))
                .build();
    }

    public TestTellerManagement() {
        super();
    }

    @Test
    public void shouldCreateTeller() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);

        Assert.assertTrue(super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode()));

        this.mockMvc.perform(post(path + "/offices/" + officeIdentifier + "/teller/")
                .contentType(MediaType.APPLICATION_JSON_VALUE)
                .content(teller.getCode()).accept(MediaType.APPLICATION_JSON_VALUE))
                .andExpect(status().isNotFound());
    }

    @Test(expected = TellerValidationException.class)
    public void shouldNotCreateTellerUnknownOffice() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();

        Mockito.doAnswer(invocation -> false)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        super.testSubject.create(officeIdentifier, teller);
    }

    @Test(expected = TellerValidationException.class)
    public void shouldNotCreateTellerUnknownTellerAccount() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();

        Mockito.doAnswer(invocation -> Optional.empty())
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));

        super.testSubject.create(officeIdentifier, teller);
    }

    @Test(expected = TellerValidationException.class)
    public void shouldNotCreateTellerUnknownVaultAccount() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();

        Mockito.doAnswer(invocation -> Optional.empty())
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));

        super.testSubject.create(officeIdentifier, teller);
    }


    @Test(expected = TellerAlreadyExistsException.class)
    public void shouldNotCreateTellerAlreadyExists() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);

        Assert.assertTrue(super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode()));

        super.testSubject.create(officeIdentifier, teller);
    }

    @Test
    public void shouldFindTeller() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);

        Assert.assertTrue(super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode()));

        final Teller foundTeller = super.testSubject.find(officeIdentifier, teller.getCode());
        Assert.assertNotNull(foundTeller);

        this.compareTeller(teller, foundTeller);

        try
        {
            this.mockMvc.perform(get(path + "/offices/" + officeIdentifier + "/teller/" + foundTeller.getCode())
                    .accept(MediaType.ALL_VALUE))
                    .andExpect(status().is4xxClientError());
        } catch (Exception exception){ exception.printStackTrace(); }
    }

    @Test(expected = TellerValidationException.class)
    public void shouldNotFindTellerUnknownOffice() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final String tellerCode = RandomStringUtils.randomAlphabetic(32);

        Mockito.doAnswer(invocation -> false)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        super.testSubject.find(officeIdentifier, tellerCode);
    }

    @Test(expected = TellerNotFoundException.class)
    public void shouldNotFindTellerUnknownTeller() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final String tellerCode = RandomStringUtils.randomAlphabetic(32);

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        super.testSubject.find(officeIdentifier, tellerCode);
    }

    @Test
    public void shouldFetchTeller() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final List<Teller> tellerToCreate = Arrays.asList(
                TellerGenerator.createRandomTeller(),
                TellerGenerator.createRandomTeller(),
                TellerGenerator.createRandomTeller(),
                TellerGenerator.createRandomTeller(),
                TellerGenerator.createRandomTeller()
        );

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        tellerToCreate.forEach(teller -> {
            Mockito.doAnswer(invocation -> Optional.of(new Account()))
                    .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
            Mockito.doAnswer(invocation -> Optional.of(new Account()))
                    .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
            Mockito.doAnswer(invocation -> Optional.of(new Account()))
                    .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
            Mockito.doAnswer(invocation -> Optional.of(new Account()))
                    .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));


            super.testSubject.create(officeIdentifier, teller);

            try {
                Assert.assertTrue(super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode()));
            } catch (final InterruptedException e) {
                throw new IllegalStateException(e);
            }
        });

        final List<Teller> fetchedTeller = super.testSubject.fetch(officeIdentifier);

        Assert.assertTrue(fetchedTeller.size() >= tellerToCreate.size());

        try
        {
            this.mockMvc.perform(get(path + "/offices/" + officeIdentifier + "/teller/")
                    .accept(MediaType.ALL_VALUE).contentType(MediaType.APPLICATION_JSON_VALUE))
                    .andExpect(status().is4xxClientError());
        } catch (Exception exception){ exception.printStackTrace(); }
    }

    @Test(expected = TellerValidationException.class)
    public void shouldNotFetchTellerUnknownOffice() {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);

        Mockito.doAnswer(invocation -> false)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        super.testSubject.fetch(officeIdentifier);
    }

    @Test
    public void shouldUpdateTeller() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);

        super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode());

        teller.setCashdrawLimit(BigDecimal.valueOf(15000.00D));

        super.testSubject.change(officeIdentifier, teller.getCode(), teller);

        Assert.assertTrue(super.eventRecorder.wait(EventConstants.PUT_TELLER, teller.getCode()));

        final Teller changedTeller = super.testSubject.find(officeIdentifier, teller.getCode());
        Assert.assertNotNull(changedTeller);

        this.compareTeller(teller, changedTeller);

        this.mockMvc.perform(put(path + "/offices/" + officeIdentifier + "/teller/" + teller.getCode())
                .accept(MediaType.APPLICATION_JSON_VALUE)
                .contentType(MediaType.APPLICATION_JSON)
                .content(teller.getCode()))
                .andExpect(status().is4xxClientError());
    }

    @Test(expected = TellerValidationException.class)
    public void shouldNotUpdateTellerUnknownOffice() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);

        super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode());

        Mockito.doAnswer(invocation -> false)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        super.testSubject.change(officeIdentifier, teller.getCode(), teller);
    }

    @Test(expected = TellerValidationException.class)
    public void shouldNotUpdateTellerUnknownTellerAccount() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);

        super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode());

        teller.setTellerAccountIdentifier(RandomStringUtils.randomAlphanumeric(32));

        Mockito.doAnswer(invocation -> Optional.empty())
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));

        super.testSubject.change(officeIdentifier, teller.getCode(), teller);
    }

    @Test(expected = TellerValidationException.class)
    public void shouldNotUpdateTellerUnknownVaultAccount() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);

        super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode());

        teller.setVaultAccountIdentifier(RandomStringUtils.randomAlphanumeric(32));

        Mockito.doAnswer(invocation -> Optional.empty())
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));

        super.testSubject.change(officeIdentifier, teller.getCode(), teller);
    }

    @Test(expected = TellerValidationException.class)
    public void shouldNotUpdateTellerMismatch() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final String tellerCode = RandomStringUtils.randomAlphanumeric(32);
        final Teller teller = TellerGenerator.createRandomTeller();
        teller.setCode(tellerCode);

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);

        super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode());

        teller.setCode(RandomStringUtils.randomAlphanumeric(32));

        super.testSubject.change(officeIdentifier, tellerCode, teller);
    }

    @Test(expected = TellerNotFoundException.class)
    public void shouldNotUpdateTellerUnknownTeller() {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();

        super.testSubject.change(officeIdentifier, teller.getCode(), teller);
    }

    @Test
    public void shouldOpenTeller() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);

        super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode());

        final TellerManagementCommand command = new TellerManagementCommand();
        command.setAction(TellerManagementCommand.Action.OPEN.name());
        command.setAdjustment(TellerManagementCommand.Adjustment.NONE.name());
        command.setAssignedEmployeeIdentifier(RandomStringUtils.randomAlphanumeric(32));

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).employeeExists(Matchers.eq(command.getAssignedEmployeeIdentifier()));

        super.testSubject.post(officeIdentifier, teller.getCode(), command);

        Assert.assertTrue(super.eventRecorder.wait(EventConstants.OPEN_TELLER, teller.getCode()));

        final Teller openedTeller = super.testSubject.find(officeIdentifier, teller.getCode());
        Assert.assertEquals(Teller.State.OPEN.name(), openedTeller.getState());
        Assert.assertEquals(command.getAssignedEmployeeIdentifier(), openedTeller.getAssignedEmployee());

        this.mockMvc.perform(post(path + "/offices/" + officeIdentifier + "/teller/" + teller.getCode() + "/commands/")
                .contentType(MediaType.APPLICATION_JSON_VALUE)
                .content(teller.getCode()).accept(MediaType.APPLICATION_JSON_VALUE))
                .andExpect(status().isNotFound());
    }

    @Test
    public void shouldCloseTeller() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);

        super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode());

        final TellerManagementCommand command = new TellerManagementCommand();
        command.setAction(TellerManagementCommand.Action.OPEN.name());
        command.setAdjustment(TellerManagementCommand.Adjustment.NONE.name());
        command.setAssignedEmployeeIdentifier(RandomStringUtils.randomAlphanumeric(32));

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).employeeExists(Matchers.eq(command.getAssignedEmployeeIdentifier()));

        super.testSubject.post(officeIdentifier, teller.getCode(), command);

        super.eventRecorder.wait(EventConstants.OPEN_TELLER, teller.getCode());

        command.setAction(TellerManagementCommand.Action.CLOSE.name());
        command.setAssignedEmployeeIdentifier(null);
        super.testSubject.post(officeIdentifier, teller.getCode(), command);

        Assert.assertTrue(super.eventRecorder.wait(EventConstants.CLOSE_TELLER, teller.getCode()));

        final Teller openedTeller = super.testSubject.find(officeIdentifier, teller.getCode());
        Assert.assertEquals(Teller.State.CLOSED.name(), openedTeller.getState());
        Assert.assertNull(openedTeller.getAssignedEmployee());

        this.mockMvc.perform(post(path + "/offices/" + officeIdentifier + "/teller/" + teller.getCode() + "/commands/")
                .contentType(MediaType.APPLICATION_JSON_VALUE)
                .content(teller.getCode()).accept(MediaType.APPLICATION_JSON_VALUE))
                .andExpect(status().isNotFound());
    }

    @Test(expected = TellerValidationException.class)
    public void shouldNotCloseTellerAlreadyClosed() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);

        super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode());

        final TellerManagementCommand command = new TellerManagementCommand();
        command.setAction(TellerManagementCommand.Action.CLOSE.name());
        command.setAdjustment(TellerManagementCommand.Adjustment.NONE.name());

        super.testSubject.post(officeIdentifier, teller.getCode(), command);
    }

    @Test(expected = TellerValidationException.class)
    public void shouldNotOpenTellerAlreadyOpen() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));
        super.testSubject.create(officeIdentifier, teller);

        super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode());

        final TellerManagementCommand command = new TellerManagementCommand();
        command.setAction(TellerManagementCommand.Action.OPEN.name());
        command.setAdjustment(TellerManagementCommand.Adjustment.NONE.name());
        command.setAssignedEmployeeIdentifier(RandomStringUtils.randomAlphanumeric(32));

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).employeeExists(Matchers.eq(command.getAssignedEmployeeIdentifier()));

        super.testSubject.post(officeIdentifier, teller.getCode(), command);

        super.eventRecorder.wait(EventConstants.OPEN_TELLER, teller.getCode());

        // and again ...
        super.testSubject.post(officeIdentifier, teller.getCode(), command);
    }

    @Test(expected = TellerValidationException.class)
    public void shouldNotCreateTellerMinimumCashWithdrawalLimitViolation() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();
        teller.setCashdrawLimit(BigDecimal.valueOf(0.00001D));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);
    }

    @Test(expected = TellerValidationException.class)
    public void shouldNotCreateTellerMaximumCashWithdrawalLimitViolation() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();
        teller.setCashdrawLimit(BigDecimal.valueOf(2000000000));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);
    }

    @Test
    public void shouldCloseTellerEvenCashDrawLimitExceeding() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();
        teller.setCashdrawLimit(BigDecimal.valueOf(1000.00D));

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);

        super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode());

        final TellerManagementCommand openCommand = new TellerManagementCommand();
        openCommand.setAction(TellerManagementCommand.Action.OPEN.name());
        openCommand.setAdjustment(TellerManagementCommand.Adjustment.DEBIT.name());
        openCommand.setAmount(BigDecimal.valueOf(1100.00D));
        openCommand.setAssignedEmployeeIdentifier(RandomStringUtils.randomAlphanumeric(32));

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).employeeExists(Matchers.eq(openCommand.getAssignedEmployeeIdentifier()));

        super.testSubject.post(officeIdentifier, teller.getCode(), openCommand);

        super.eventRecorder.wait(EventConstants.OPEN_TELLER, teller.getCode());

        final TellerManagementCommand closeCommand = new TellerManagementCommand();
        closeCommand.setAction(TellerManagementCommand.Action.CLOSE.name());
        closeCommand.setAdjustment(TellerManagementCommand.Adjustment.CREDIT.name());
        closeCommand.setAmount(BigDecimal.valueOf(1100.00D));

        super.testSubject.post(officeIdentifier, teller.getCode(), closeCommand);
        Assert.assertTrue(super.eventRecorder.wait(EventConstants.CLOSE_TELLER, teller.getCode()));
    }

    @Test
    public void shouldDeleteTeller() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();
        teller.setCashdrawLimit(BigDecimal.valueOf(10000.00D));

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);
        Assert.assertTrue(super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode()));

        final Teller fetchedTeller = this.testSubject.find(officeIdentifier, teller.getCode());
        Assert.assertTrue(fetchedTeller.getLastOpenedBy() == null);

        super.testSubject.deleteTeller(officeIdentifier, teller.getCode());
        Assert.assertTrue(super.eventRecorder.wait(EventConstants.DELETE_TELLER, teller.getCode()));

        try
        {
            this.mockMvc.perform(delete(path + "/offices/" + officeIdentifier + "/teller/" + fetchedTeller.getCode())
                    .accept(MediaType.ALL_VALUE)
                    .contentType(MediaType.APPLICATION_JSON_VALUE))
                    .andExpect(status().isNotFound());
        } catch (Exception exception){ exception.printStackTrace(); }
    }

    @Test(expected = TellerValidationException.class)
    public void shouldNotDeleteTeller() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();
        teller.setCashdrawLimit(BigDecimal.valueOf(10000.00D));

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);
        Assert.assertTrue(super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode()));

        final TellerManagementCommand openCommand = new TellerManagementCommand();
        openCommand.setAction(TellerManagementCommand.Action.OPEN.name());
        openCommand.setAdjustment(TellerManagementCommand.Adjustment.NONE.name());
        openCommand.setAssignedEmployeeIdentifier(RandomStringUtils.randomAlphanumeric(32));

        this.testSubject.post(officeIdentifier, teller.getCode(), openCommand);
        Assert.assertTrue(super.eventRecorder.wait(EventConstants.OPEN_TELLER, teller.getCode()));

        final Teller fetchedTeller = this.testSubject.find(officeIdentifier, teller.getCode());
        Assert.assertTrue(fetchedTeller.getLastOpenedBy() != null);

        super.testSubject.deleteTeller(officeIdentifier, teller.getCode());
        Assert.assertTrue(super.eventRecorder.wait(EventConstants.DELETE_TELLER, teller.getCode()));

    }

    @Test
    public void shouldReturnZeroBalanceTellerNeverOpened() throws Exception {
        final String officeIdentifier = RandomStringUtils.randomAlphabetic(32);
        final Teller teller = TellerGenerator.createRandomTeller();
        teller.setCashdrawLimit(BigDecimal.valueOf(10000.00D));

        Mockito.doAnswer(invocation -> true)
                .when(super.organizationServiceSpy).officeExists(Matchers.eq(officeIdentifier));

        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getTellerAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getVaultAccountIdentifier()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getChequesReceivableAccount()));
        Mockito.doAnswer(invocation -> Optional.of(new Account()))
                .when(super.accountingServiceSpy).findAccount(Matchers.eq(teller.getCashOverShortAccount()));

        super.testSubject.create(officeIdentifier, teller);
        Assert.assertTrue(super.eventRecorder.wait(EventConstants.POST_TELLER, teller.getCode()));

        final TellerBalanceSheet tellerBalanceSheet = super.testSubject.getBalance(officeIdentifier, teller.getCode());
        Assert.assertTrue(BigDecimal.ZERO.compareTo(tellerBalanceSheet.getCashOnHand()) == 0);
    }

    private void compareTeller(final Teller expected, final Teller actual) {
        Assert.assertEquals(expected.getCode(), actual.getCode());
        Assert.assertEquals(expected.getTellerAccountIdentifier(), actual.getTellerAccountIdentifier());
        Assert.assertEquals(expected.getVaultAccountIdentifier(), actual.getVaultAccountIdentifier());
        Assert.assertTrue(expected.getCashdrawLimit().compareTo(actual.getCashdrawLimit()) == 0);
    }
}