/*
 * Copyright © 2017 AT&T, Inc. and others.  All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 */

package org.opendaylight.transportpce.common.NetworkTransaction;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
import org.opendaylight.transportpce.common.network.RequestProcessor;
import org.opendaylight.transportpce.test.AbstractTest;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.Network;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NetworkBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NetworkId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NetworkKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class NetworkTransactionServiceTest extends AbstractTest {

    private NetworkTransactionService networkTransactionService;
    private LogicalDatastoreType defaultDatastore = LogicalDatastoreType.CONFIGURATION;
    private NetworkBuilder nwBuilder = new NetworkBuilder();
    private NetworkId nwId = new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID);
    private Network defaultData;
    ExecutorService executor;


    private static final Logger LOG = LoggerFactory
            .getLogger(NetworkTransactionServiceTest.class);

    InstanceIdentifier<Network> nwInstanceIdentifier = InstanceIdentifier
            .builder(Network.class,
                    new NetworkKey(
                            new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
            .build();


    @Before
    public void instantiate() {

        networkTransactionService = new NetworkTransactionImpl(new RequestProcessor(getDataBroker()));
        nwBuilder.setNetworkId(nwId);
        nwBuilder.setKey(nwBuilder.getKey());
        defaultData = nwBuilder.build();
        executor = Executors.newFixedThreadPool(3);

    }

    @Test
    public void WhenOneThreadIsWritingOtherThreadsAreWaiting() {

        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        Thread t3 = new Thread(runnable);

        t1.start();
        t2.start();
        t3.start();

        //Check thread 2 is waiting to acquire lock when thread 1 is executing
        Assert.assertTrue(t2.getState().equals(Thread.State.WAITING));

        LOG.info(t3.getState().toString());
        //Check thread 3 is waiting to acquire lock when thread 1 is executing
        Assert.assertTrue(t3.getState().equals(Thread.State.WAITING));

        try {
            t1.join();
            //Check thread 3 is waiting to acquire lock when thread 1 is finished and thread is still in executing
            Assert.assertTrue(t3.getState().equals(Thread.State.WAITING));
            t2.join();
            t3.join();
        } catch (InterruptedException e) {
          LOG.error(e.getMessage());
        }
    }

    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            networkTransactionService.merge(defaultDatastore, nwInstanceIdentifier, defaultData);
            try {

                //Add delay to mock thread execution delay
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                LOG.error(e.getMessage());
            }
            networkTransactionService.submit();

        }
    };
}