/*
 * Copyright 2017-present Open Networking Laboratory
 *
 * 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 org.onosproject.provider.lisp.device.impl;

import com.google.common.collect.Sets;
import org.junit.Before;
import org.junit.Test;
import org.onosproject.core.ApplicationId;
import org.onosproject.core.CoreService;
import org.onosproject.core.DefaultApplicationId;
import org.onosproject.lisp.ctl.LispController;
import org.onosproject.lisp.ctl.LispControllerAdapter;
import org.onosproject.lisp.ctl.LispRouter;
import org.onosproject.lisp.ctl.LispRouterListener;
import org.onosproject.net.device.DeviceListener;
import org.onosproject.net.device.DeviceProvider;
import org.onosproject.net.device.DeviceProviderRegistry;
import org.onosproject.net.device.DeviceProviderRegistryAdapter;
import org.onosproject.net.device.DeviceProviderService;
import org.onosproject.net.device.DeviceProviderServiceAdapter;
import org.onosproject.net.device.DeviceService;
import org.onosproject.net.device.DeviceServiceAdapter;
import org.onosproject.net.provider.ProviderId;

import java.util.Set;

import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

/**
 * LISP device provider unit test.
 */
public class LispDeviceProviderTest {

    private static final String APP_NAME = "org.onosproject.lisp";

    private final LispDeviceProvider provider = new LispDeviceProvider();
    private final LispController controller = new MockLispController();

    // provider mocks
    private final DeviceProviderRegistry providerRegistry = new MockDeviceProviderRegistry();
    private final DeviceProviderService providerService = new MockDeviceProviderService();
    private final DeviceService deviceService = new MockDeviceService();

    private final Set<LispRouterListener> routerListeners = Sets.newCopyOnWriteArraySet();

    private CoreService coreService;
    private ApplicationId appId = new DefaultApplicationId(200, APP_NAME);
    private Set<DeviceListener> deviceListeners = Sets.newHashSet();

    @Before
    public void setUp() {
        coreService = createMock(CoreService.class);
        expect(coreService.registerApplication(APP_NAME))
                .andReturn(appId).anyTimes();
        replay(coreService);
        provider.coreService = coreService;
        provider.providerRegistry = providerRegistry;
        provider.deviceService = deviceService;
        provider.controller = controller;
        provider.activate();
    }

    @Test
    public void activate() throws Exception {

        assertEquals("Provider should be registered", 1,
                            providerRegistry.getProviders().size());
        assertTrue("LISP device provider should be registered",
                            providerRegistry.getProviders().contains(provider.id()));
        assertEquals("Incorrect provider service",
                            providerService, provider.providerService);
        assertEquals("LISP router listener should be registered", 1,
                            routerListeners.size());
    }

    @Test
    public void deactivate() throws Exception {
        provider.deactivate();

        assertFalse("Provider should not be registered",
                            providerRegistry.getProviders().contains(provider));
        assertNull("Provider service should be null",
                            provider.providerService);
        assertEquals("Controller listener should be removed", 0,
                            routerListeners.size());
    }

    /**
     * Mock class for LispController.
     */
    private class MockLispController extends LispControllerAdapter {

        Iterable<LispRouter> routers = Sets.newHashSet();

        @Override
        public Iterable<LispRouter> getRouters() {
            return routers;
        }

        @Override
        public void addRouterListener(LispRouterListener listener) {
            if (!routerListeners.contains(listener)) {
                routerListeners.add(listener);
            }
        }

        @Override
        public void removeRouterListener(LispRouterListener listener) {
            routerListeners.remove(listener);
        }
    }

    /**
     * Mock class for DeviceProviderRegistry.
     */
    private class MockDeviceProviderRegistry extends DeviceProviderRegistryAdapter {
        Set<ProviderId> providers = Sets.newHashSet();

        @Override
        public DeviceProviderService register(DeviceProvider provider) {
            providers.add(provider.id());
            return providerService;
        }

        @Override
        public void unregister(DeviceProvider provider) {
            providers.remove(provider.id());
        }

        @Override
        public Set<ProviderId> getProviders() {
            return providers;
        }
    }

    /**
     * Mock class for DeviceService.
     */
    private class MockDeviceService extends DeviceServiceAdapter {
        @Override
        public void addListener(DeviceListener listener) {
            deviceListeners.add(listener);
        }

        @Override
        public void removeListener(DeviceListener listener) {
            deviceListeners.remove(listener);
        }
    }

    /**
     * Mock class for DeviceProviderService.
     */
    private class MockDeviceProviderService extends DeviceProviderServiceAdapter {

    }
}