/*
 * Copyright (c) 2016 Cisco and/or its affiliates.
 *
 * Licensed 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 io.fd.honeycomb.v3po.data.impl;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyMap;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;

import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
import io.fd.honeycomb.v3po.data.DataModification;
import io.fd.honeycomb.v3po.translate.TranslationException;
import io.fd.honeycomb.v3po.translate.write.WriteContext;
import io.fd.honeycomb.v3po.translate.write.WriterRegistry;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.interfaces._interface.Ethernet;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;

public class ModifiableDataTreeDelegatorTest {

    @Mock
    private WriterRegistry writer;
    @Mock
    private BindingNormalizedNodeSerializer serializer;
    @Mock
    private DataTree dataTree;
    @Mock
    private org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification modification;
    @Mock
    private DataBroker contextBroker;

    private ModifiableDataTreeManager configDataTree;

    @Before
    public void setUp() {
        initMocks(this);
        configDataTree = new ModifiableDataTreeDelegator(serializer, dataTree, writer, contextBroker);
    }

    @Test
    public void testRead() throws Exception {
        final org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot
                snapshot = mock(org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot.class);
        when(dataTree.takeSnapshot()).thenReturn(snapshot);
        when(snapshot.newModification()).thenReturn(modification);

        final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class);
        final Optional node = mock(Optional.class);
        doReturn(node).when(modification).readNode(path);

        final DataModification dataTreeSnapshot = configDataTree.newModification();
        final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> future =
                dataTreeSnapshot.read(path);

        verify(dataTree, times(2)).takeSnapshot();
        verify(modification).readNode(path);

        assertTrue(future.isDone());
        assertEquals(node, future.get());
    }

    @Test
    public void testNewModification() throws Exception {
        final org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot
                snapshot = mock(org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot.class);
        when(dataTree.takeSnapshot()).thenReturn(snapshot);
        when(snapshot.newModification()).thenReturn(modification);

        configDataTree.newModification();
        // Snapshot captured twice, so that original data could be provided to translation layer without any possible
        // modification
        verify(dataTree, times(2)).takeSnapshot();
        verify(snapshot, times(2)).newModification();
    }

    @Test
    public void testCommitSuccessful() throws Exception {
        final org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot
            snapshot = mock(org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot.class);
        when(dataTree.takeSnapshot()).thenReturn(snapshot);
        when(snapshot.newModification()).thenReturn(modification);
        final DataTreeCandidate prepare = mock(DataTreeCandidate.class);
        doReturn(prepare).when(dataTree).prepare(modification);

        final org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction ctxTransaction = mock(
            org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction.class);
        doReturn(ctxTransaction).when(contextBroker).newReadWriteTransaction();
        doReturn(Futures.immediateCheckedFuture(null)).when(ctxTransaction).submit();

        final DataObject dataBefore = mockDataObject("before", Ethernet.class);
        final DataObject dataAfter = mockDataObject("after", Ethernet.class);

        // Prepare modification:
        final DataTreeCandidateNode rootNode = mockRootNode();
        doReturn(ModificationType.SUBTREE_MODIFIED).when(rootNode).getModificationType();
        doReturn(mock(YangInstanceIdentifier.PathArgument.class)).when(rootNode).getIdentifier();
        final DataTreeCandidateNode childNode = mock(DataTreeCandidateNode.class);
        doReturn(mock(YangInstanceIdentifier.PathArgument.class)).when(childNode).getIdentifier();
        doReturn(Collections.singleton(childNode)).when(rootNode).getChildNodes();
        doReturn(ModificationType.WRITE).when(childNode).getModificationType();

        // data before:
        final ContainerNode nodeBefore = mockContainerNode(dataBefore);
        when(childNode.getDataBefore()).thenReturn(Optional.fromNullable(nodeBefore));
        // data after:
        final ContainerNode nodeAfter = mockContainerNode(dataAfter);
        when(childNode.getDataAfter()).thenReturn(Optional.fromNullable(nodeAfter));

        // Run the test
        doReturn(rootNode).when(prepare).getRootNode();
        final DataModification dataModification = configDataTree.newModification();
        dataModification.commit();

        // Verify all changes were processed:
        verify(writer).update(
                mapOf(dataBefore, Ethernet.class),
                mapOf(dataAfter, Ethernet.class),
                any(WriteContext.class));

        // Verify modification was validated
        verify(dataTree).validate(modification);
        // Verify context transaction was finished
        verify(ctxTransaction).submit();
    }

    private Map<InstanceIdentifier<?>, DataObject> mapOf(final DataObject dataBefore, final Class<Ethernet> type) {
        return eq(Collections.singletonMap(InstanceIdentifier.create(type),dataBefore));
    }

    private DataObject mockDataObject(final String name, final Class<? extends DataObject> classToMock) {
        final DataObject dataBefore = mock(classToMock, name);
        doReturn(classToMock).when(dataBefore).getImplementedInterface();
        return dataBefore;
    }

    @Test
    public void testCommitUndoSuccessful() throws Exception {
        final org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot
            snapshot = mock(org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot.class);
        when(dataTree.takeSnapshot()).thenReturn(snapshot);
        when(snapshot.newModification()).thenReturn(modification);
        final DataTreeCandidate prepare = mock(DataTreeCandidate.class);
        doReturn(prepare).when(dataTree).prepare(modification);

        // Prepare data changes:
        final DataObject dataBefore = mockDataObject("before", Ethernet.class);
        final DataObject dataAfter = mockDataObject("after", Ethernet.class);

        final io.fd.honeycomb.v3po.translate.write.WriterRegistry.Reverter reverter = mock(
            io.fd.honeycomb.v3po.translate.write.WriterRegistry.Reverter.class);

        // Fail on update:
        final TranslationException failedOnUpdateException = new TranslationException("update failed");
        doThrow(new io.fd.honeycomb.v3po.translate.write.WriterRegistry.BulkUpdateException(InstanceIdentifier.create(Ethernet.class), reverter,
                failedOnUpdateException)).when(writer).update(anyMap(), anyMap(), any(WriteContext.class));

        // Prepare modification:
        final DataTreeCandidateNode rootNode = mockRootNode();
        doReturn(ModificationType.SUBTREE_MODIFIED).when(rootNode).getModificationType();
        doReturn(mock(YangInstanceIdentifier.PathArgument.class)).when(rootNode).getIdentifier();
        final DataTreeCandidateNode childNode = mock(DataTreeCandidateNode.class);
        doReturn(mock(YangInstanceIdentifier.PathArgument.class)).when(childNode).getIdentifier();
        doReturn(Collections.singleton(childNode)).when(rootNode).getChildNodes();
        doReturn(ModificationType.WRITE).when(childNode).getModificationType();

        // data before:
        final ContainerNode nodeBefore = mockContainerNode(dataBefore);
        when(childNode.getDataBefore()).thenReturn(Optional.fromNullable(nodeBefore));
        // data after:
        final ContainerNode nodeAfter = mockContainerNode(dataAfter);
        when(childNode.getDataAfter()).thenReturn(Optional.fromNullable(nodeAfter));

        // Run the test
        try {
            doReturn(rootNode).when(prepare).getRootNode();
            final DataModification dataModification = configDataTree.newModification();
            dataModification.commit();
        } catch (io.fd.honeycomb.v3po.translate.write.WriterRegistry.BulkUpdateException e) {
            verify(writer).update(anyMap(), anyMap(), any(WriteContext.class));
            verify(reverter).revert();
            assertEquals(failedOnUpdateException, e.getCause());
            return;
        }

        fail("WriterRegistry.BulkUpdateException was expected");
    }

    @Test
    public void testCommitUndoFailed() throws Exception {
        final org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot
            snapshot = mock(org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot.class);
        when(dataTree.takeSnapshot()).thenReturn(snapshot);
        when(snapshot.newModification()).thenReturn(modification);
        final DataTreeCandidate prepare = mock(DataTreeCandidate.class);
        doReturn(prepare).when(dataTree).prepare(modification);

        // Prepare data changes:
        final DataObject dataBefore = mockDataObject("before", Ethernet.class);
        final DataObject dataAfter = mockDataObject("after", Ethernet.class);

        final io.fd.honeycomb.v3po.translate.write.WriterRegistry.Reverter reverter = mock(
            io.fd.honeycomb.v3po.translate.write.WriterRegistry.Reverter.class);

        // Fail on update:
        doThrow(new io.fd.honeycomb.v3po.translate.write.WriterRegistry.BulkUpdateException(InstanceIdentifier.create(Ethernet.class), reverter,
                new TranslationException("update failed"))).when(writer).update(anyMap(), anyMap(), any(WriteContext.class));

        // Fail on revert:
        final TranslationException failedOnRevertException = new TranslationException("update failed");
        final io.fd.honeycomb.v3po.translate.write.WriterRegistry.Reverter.RevertFailedException revertFailedException =
                new io.fd.honeycomb.v3po.translate.write.WriterRegistry.Reverter.RevertFailedException(Collections.<InstanceIdentifier<?>>emptyList(),
                        failedOnRevertException);
        doThrow(revertFailedException).when(reverter).revert();

        // Prepare modification:
        final DataTreeCandidateNode rootNode = mockRootNode();
        doReturn(ModificationType.SUBTREE_MODIFIED).when(rootNode).getModificationType();
        doReturn(mock(YangInstanceIdentifier.PathArgument.class)).when(rootNode).getIdentifier();
        final DataTreeCandidateNode childNode = mock(DataTreeCandidateNode.class);
        doReturn(mock(YangInstanceIdentifier.PathArgument.class)).when(childNode).getIdentifier();
        doReturn(Collections.singleton(childNode)).when(rootNode).getChildNodes();
        doReturn(ModificationType.WRITE).when(childNode).getModificationType();

        // data before:
        final ContainerNode nodeBefore = mockContainerNode(dataBefore);
        when(childNode.getDataBefore()).thenReturn(Optional.fromNullable(nodeBefore));
        // data after:
        final ContainerNode nodeAfter = mockContainerNode(dataAfter);
        when(childNode.getDataAfter()).thenReturn(Optional.fromNullable(nodeAfter));

        // Run the test
        try {
            doReturn(rootNode).when(prepare).getRootNode();
            final DataModification dataModification = configDataTree.newModification();
            dataModification.commit();
        } catch (io.fd.honeycomb.v3po.translate.write.WriterRegistry.Reverter.RevertFailedException e) {
            verify(writer).update(anyMap(), anyMap(), any(WriteContext.class));
            verify(reverter).revert();
            assertEquals(failedOnRevertException, e.getCause());
            return;
        }

        fail("RevertFailedException was expected");
    }

    @Test
    public void testChildrenFromNormalized() throws Exception {
        final BindingNormalizedNodeSerializer serializer = mock(BindingNormalizedNodeSerializer.class);

        final Map<YangInstanceIdentifier, NormalizedNode<?, ?>> map = new HashMap<>();

        // init child1 (will not be serialized)
        final DataContainerChild child1 = mock(DataContainerChild.class);
        when(child1.getIdentifier()).thenReturn(mock(YangInstanceIdentifier.PathArgument.class));
        when(serializer.fromNormalizedNode(any(YangInstanceIdentifier.class), eq(child1))).thenReturn(null);
        map.put(mock(YangInstanceIdentifier.class), child1);

        // init child 2 (will be serialized)
        final DataContainerChild child2 = mock(DataContainerChild.class);
        when(child2.getIdentifier()).thenReturn(mock(YangInstanceIdentifier.PathArgument.class));

        final Map.Entry entry = mock(Map.Entry.class);
        final InstanceIdentifier<?> id = mock(InstanceIdentifier.class);
        doReturn(id).when(entry).getKey();
        final DataObject data = mock(DataObject.class);
        doReturn(data).when(entry).getValue();
        when(serializer.fromNormalizedNode(any(YangInstanceIdentifier.class), eq(child2))).thenReturn(entry);
        map.put(mock(YangInstanceIdentifier.class), child2);

        // run tested method
        final Map<InstanceIdentifier<?>, DataObject> baMap =
                ModifiableDataTreeDelegator.toBindingAware(map, serializer);
        assertEquals(1, baMap.size());
        assertEquals(data, baMap.get(id));
    }

    private DataTreeCandidateNode mockRootNode() {
        final DataTreeCandidate candidate = mock(DataTreeCandidate.class);
        when(dataTree.prepare(modification)).thenReturn(candidate);

        final DataTreeCandidateNode rootNode = mock(DataTreeCandidateNode.class);
        when(candidate.getRootNode()).thenReturn(rootNode);

        return rootNode;
    }

    private ContainerNode mockContainerNode(DataObject modification) {
        final YangInstanceIdentifier.NodeIdentifier identifier =
                YangInstanceIdentifier.NodeIdentifier.create(QName.create("/"));

        final ContainerNode node = mock(ContainerNode.class);
        when(node.getIdentifier()).thenReturn(identifier);

        final Map.Entry entry = mock(Map.Entry.class);
        final Class<? extends DataObject> implementedInterface =
                (Class<? extends DataObject>) modification.getImplementedInterface();
        final InstanceIdentifier<?> id = InstanceIdentifier.create(implementedInterface);

        doReturn(id).when(entry).getKey();
        doReturn(modification).when(entry).getValue();
        doReturn(entry).when(serializer).fromNormalizedNode(any(YangInstanceIdentifier.class), eq(node));

        return node;
    }
}