// 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 com.cloud.hypervisor.vmware;

import static org.mockito.Mockito.when;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import javax.inject.Inject;
import javax.naming.ConfigurationException;

import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;

import org.apache.cloudstack.api.command.admin.zone.AddVmwareDcCmd;
import org.apache.cloudstack.api.command.admin.zone.RemoveVmwareDcCmd;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreManager;
import org.apache.cloudstack.framework.config.dao.ConfigurationDao;
import org.apache.cloudstack.test.utils.SpringUtils;

import com.cloud.agent.AgentManager;
import com.cloud.cluster.ClusterManager;
import com.cloud.cluster.dao.ManagementServerHostPeerDao;
import com.cloud.dc.ClusterDetailsDao;
import com.cloud.dc.ClusterDetailsVO;
import com.cloud.dc.ClusterVO;
import com.cloud.dc.DataCenter.NetworkType;
import com.cloud.dc.DataCenterVO;
import com.cloud.dc.HostPodVO;
import com.cloud.dc.dao.ClusterDao;
import com.cloud.dc.dao.ClusterVSMMapDao;
import com.cloud.dc.dao.DataCenterDao;
import com.cloud.dc.dao.HostPodDao;
import com.cloud.event.dao.EventDao;
import com.cloud.exception.DiscoveryException;
import com.cloud.exception.InvalidParameterValueException;
import com.cloud.exception.ResourceInUseException;
import com.cloud.host.dao.HostDao;
import com.cloud.hypervisor.Hypervisor.HypervisorType;
import com.cloud.hypervisor.dao.HypervisorCapabilitiesDao;
import com.cloud.hypervisor.vmware.dao.LegacyZoneDao;
import com.cloud.hypervisor.vmware.dao.VmwareDatacenterDao;
import com.cloud.hypervisor.vmware.dao.VmwareDatacenterZoneMapDao;
import com.cloud.hypervisor.vmware.manager.VmwareManagerImpl;
import com.cloud.network.NetworkModel;
import com.cloud.network.dao.CiscoNexusVSMDeviceDao;
import com.cloud.org.Cluster.ClusterType;
import com.cloud.org.Managed.ManagedState;
import com.cloud.secstorage.CommandExecLogDao;
import com.cloud.server.ConfigurationServer;
import com.cloud.storage.secondary.SecondaryStorageVmManager;
import com.cloud.user.Account;
import com.cloud.user.AccountManager;
import com.cloud.user.AccountService;
import com.cloud.user.AccountVO;
import com.cloud.user.UserVO;
import com.cloud.user.dao.AccountDao;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.vm.dao.UserVmDao;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(loader = AnnotationConfigContextLoader.class)
public class VmwareDatacenterApiUnitTest {

    @Inject
    VmwareDatacenterService _vmwareDatacenterService;

    @Inject
    DataCenterDao _dcDao;

    @Inject
    HostPodDao _podDao;

    @Inject
    VmwareDatacenterDao _vmwareDcDao;

    @Inject
    VmwareDatacenterZoneMapDao _vmwareDcZoneMapDao;

    @Inject
    ClusterDao _clusterDao;

    @Inject
    ClusterDetailsDao _clusterDetailsDao;

    @Inject
    ConfigurationDao _configDao;

    @Inject
    AccountDao _accountDao;

    @Inject
    AccountManager _acctMgr;

    long zoneId;
    long podId;
    long clusterId;
    long vmwareDcId;
    private static long domainId = 5L;
    private static String vmwareDcName = "dc";
    private static String clusterName = "cluster";
    private static String vCenterHost = "10.1.1.100";
    private static String url = "http://" + vCenterHost + "/" + vmwareDcName + "/" + clusterName;
    private static String user = "administrator";
    private static String password = "password";
    private static String guid = vmwareDcName + "@" + vCenterHost;

    private static VmwareDatacenterVO dc;
    private static List<VmwareDatacenterVO> vmwareDcs;
    private static ClusterVO cluster;
    private static VmwareDatacenterZoneMapVO dcZoneMap;
    private static List<ClusterVO> clusterList;
    private static ClusterDetailsVO clusterDetails;

    @Mock
    private static AddVmwareDcCmd addCmd;
    @Mock
    private static RemoveVmwareDcCmd removeCmd;

    @BeforeClass
    public static void setUp() throws ConfigurationException {
    }

    @Before
    public void testSetUp() {
        Mockito.when(_configDao.isPremium()).thenReturn(true);
        ComponentContext.initComponentsLifeCycle();
        MockitoAnnotations.initMocks(this);

        DataCenterVO zone =
            new DataCenterVO(UUID.randomUUID().toString(), "test", "8.8.8.8", null, "10.0.0.1", null, "10.0.0.1/24", null, null, NetworkType.Basic, null, null, true,
                true, null, null);
        zoneId = 1L;

        HostPodVO pod = new HostPodVO(UUID.randomUUID().toString(), zoneId, "192.168.56.1", "192.168.56.0/24", 8, "test");
        podId = 1L;

        AccountVO acct = new AccountVO(200L);
        acct.setType(Account.ACCOUNT_TYPE_ADMIN);
        acct.setAccountName("admin");
        acct.setDomainId(domainId);

        UserVO user1 = new UserVO(1, "testuser", "password", "firstname", "lastName", "email", "timezone", UUID.randomUUID().toString());

        CallContext.register(user1, acct);

        when(_accountDao.findByIdIncludingRemoved(0L)).thenReturn(acct);

        dc = new VmwareDatacenterVO(guid, vmwareDcName, vCenterHost, user, password);
        vmwareDcs = new ArrayList<VmwareDatacenterVO>();
        vmwareDcs.add(dc);
        vmwareDcId = dc.getId();

        cluster = new ClusterVO(zone.getId(), pod.getId(), "vmwarecluster");
        cluster.setHypervisorType(HypervisorType.VMware.toString());
        cluster.setClusterType(ClusterType.ExternalManaged);
        cluster.setManagedState(ManagedState.Managed);
        clusterId = 1L;
        clusterList = new ArrayList<ClusterVO>();
        clusterList.add(cluster);

        clusterDetails = new ClusterDetailsVO(clusterId, "url", url);

        dcZoneMap = new VmwareDatacenterZoneMapVO(zoneId, vmwareDcId);

        Mockito.when(_dcDao.persist(Matchers.any(DataCenterVO.class))).thenReturn(zone);
        Mockito.when(_dcDao.findById(1L)).thenReturn(zone);
        Mockito.when(_podDao.persist(Matchers.any(HostPodVO.class))).thenReturn(pod);
        Mockito.when(_podDao.findById(1L)).thenReturn(pod);
        Mockito.when(_clusterDao.persist(Matchers.any(ClusterVO.class))).thenReturn(cluster);
        Mockito.when(_clusterDao.findById(1L)).thenReturn(cluster);
        Mockito.when(_clusterDao.listByZoneId(1L)).thenReturn(null);
        Mockito.when(_clusterDao.expunge(1L)).thenReturn(true);
        Mockito.when(_clusterDetailsDao.persist(Matchers.any(ClusterDetailsVO.class))).thenReturn(clusterDetails);
        Mockito.when(_clusterDetailsDao.expunge(1L)).thenReturn(true);
        Mockito.when(_vmwareDcDao.persist(Matchers.any(VmwareDatacenterVO.class))).thenReturn(dc);
        Mockito.when(_vmwareDcDao.findById(1L)).thenReturn(null);
        Mockito.when(_vmwareDcDao.expunge(1L)).thenReturn(true);
        Mockito.when(_vmwareDcDao.getVmwareDatacenterByNameAndVcenter(vmwareDcName, vCenterHost)).thenReturn(null);
        Mockito.when(_vmwareDcZoneMapDao.persist(Matchers.any(VmwareDatacenterZoneMapVO.class))).thenReturn(dcZoneMap);
        Mockito.when(_vmwareDcZoneMapDao.findByZoneId(1L)).thenReturn(null);
        Mockito.when(_vmwareDcZoneMapDao.expunge(1L)).thenReturn(true);
        Mockito.when(addCmd.getZoneId()).thenReturn(1L);
        Mockito.when(addCmd.getVcenter()).thenReturn(vCenterHost);
        Mockito.when(addCmd.getUsername()).thenReturn(user);
        Mockito.when(addCmd.getPassword()).thenReturn(password);
        Mockito.when(addCmd.getName()).thenReturn(vmwareDcName);
        Mockito.when(removeCmd.getZoneId()).thenReturn(1L);
    }

    @After
    public void tearDown() {
        CallContext.unregister();
    }

    //@Test(expected = InvalidParameterValueException.class)
    public void testAddVmwareDcToInvalidZone() throws ResourceInUseException, IllegalArgumentException, DiscoveryException, Exception {
        Mockito.when(addCmd.getZoneId()).thenReturn(2L);
        _vmwareDatacenterService.addVmwareDatacenter(addCmd);
    }

    //@Test(expected = ResourceInUseException.class)
    public void testAddVmwareDcToZoneWithClusters() throws ResourceInUseException, IllegalArgumentException, DiscoveryException, Exception {
        Mockito.when(_clusterDao.listByZoneId(1L)).thenReturn(clusterList);
        _vmwareDatacenterService.addVmwareDatacenter(addCmd);
    }

    @Test(expected = InvalidParameterValueException.class)
    public void testRemoveVmwareDcToInvalidZone() throws ResourceInUseException, IllegalArgumentException, DiscoveryException, Exception {
        Mockito.when(removeCmd.getZoneId()).thenReturn(2L);
        _vmwareDatacenterService.removeVmwareDatacenter(removeCmd);
    }

    @Test(expected = ResourceInUseException.class)
    public void testRemoveVmwareDcToZoneWithClusters() throws ResourceInUseException, IllegalArgumentException, DiscoveryException, Exception {
        Mockito.when(_clusterDao.listByZoneId(1L)).thenReturn(clusterList);
        _vmwareDatacenterService.removeVmwareDatacenter(removeCmd);
    }

    //@Test(expected = ResourceInUseException.class)
    public void testAddVmwareDcToZoneWithVmwareDc() throws ResourceInUseException, IllegalArgumentException, DiscoveryException, Exception {
        Mockito.when(_vmwareDcDao.getVmwareDatacenterByNameAndVcenter(vmwareDcName, vCenterHost)).thenReturn(vmwareDcs);
        _vmwareDatacenterService.addVmwareDatacenter(addCmd);
    }

    //@Test(expected = InvalidParameterValueException.class)
    public void testAddVmwareDcWithNullUser() throws ResourceInUseException, IllegalArgumentException, DiscoveryException, Exception {
        Mockito.when(addCmd.getUsername()).thenReturn(null);
        _vmwareDatacenterService.addVmwareDatacenter(addCmd);
    }

    //@Test(expected = InvalidParameterValueException.class)
    public void testAddVmwareDcWithNullPassword() throws ResourceInUseException, IllegalArgumentException, DiscoveryException, Exception {
        Mockito.when(addCmd.getPassword()).thenReturn(null);
        _vmwareDatacenterService.addVmwareDatacenter(addCmd);
    }

    //@Test(expected = InvalidParameterValueException.class)
    public void testAddVmwareDcWithNullUrl() throws ResourceInUseException, IllegalArgumentException, DiscoveryException, Exception {
        Mockito.when(addCmd.getVcenter()).thenReturn(null);
        _vmwareDatacenterService.addVmwareDatacenter(addCmd);
    }

    //@Test(expected = InvalidParameterValueException.class)
    public void testAddVmwareDcWithNullDcName() throws ResourceInUseException, IllegalArgumentException, DiscoveryException, Exception {
        Mockito.when(addCmd.getName()).thenReturn(null);
        _vmwareDatacenterService.addVmwareDatacenter(addCmd);
    }

    //@Test(expected = CloudRuntimeException.class)
    public void testReAddVmwareDc() throws ResourceInUseException, IllegalArgumentException, DiscoveryException, Exception {
        Mockito.when(_vmwareDcZoneMapDao.findByZoneId(1L)).thenReturn(dcZoneMap);
        _vmwareDatacenterService.addVmwareDatacenter(addCmd);
    }

    @Test(expected = CloudRuntimeException.class)
    public void testRemoveNonexistingVmwareDc() throws ResourceInUseException, IllegalArgumentException, DiscoveryException, Exception {
        Mockito.when(_vmwareDcZoneMapDao.findByZoneId(1L)).thenReturn(null);
        _vmwareDatacenterService.removeVmwareDatacenter(removeCmd);
    }

    @Configuration
    @ComponentScan(basePackageClasses = {VmwareManagerImpl.class},
                   includeFilters = {@Filter(value = TestConfiguration.Library.class, type = FilterType.CUSTOM)},
                   useDefaultFilters = false)
    public static class TestConfiguration extends SpringUtils.CloudStackTestConfiguration {

        @Bean
        public AccountDao accountDao() {
            return Mockito.mock(AccountDao.class);
        }

        @Bean
        public AccountService accountService() {
            return Mockito.mock(AccountService.class);
        }

        @Bean
        public DataCenterDao dataCenterDao() {
            return Mockito.mock(DataCenterDao.class);
        }

        @Bean
        public HostPodDao hostPodDao() {
            return Mockito.mock(HostPodDao.class);
        }

        @Bean
        public ClusterDao clusterDao() {
            return Mockito.mock(ClusterDao.class);
        }

        @Bean
        public ClusterDetailsDao clusterDetailsDao() {
            return Mockito.mock(ClusterDetailsDao.class);
        }

        @Bean
        public VmwareDatacenterDao vmwareDatacenterDao() {
            return Mockito.mock(VmwareDatacenterDao.class);
        }

        @Bean
        public VmwareDatacenterZoneMapDao vmwareDatacenterZoneMapDao() {
            return Mockito.mock(VmwareDatacenterZoneMapDao.class);
        }

        @Bean
        public AgentManager agentManager() {
            return Mockito.mock(AgentManager.class);
        }

        @Bean
        public HostDao hostDao() {
            return Mockito.mock(HostDao.class);
        }

        @Bean
        public NetworkModel networkModel() {
            return Mockito.mock(NetworkModel.class);
        }

        @Bean
        public ClusterManager clusterManager() {
            return Mockito.mock(ClusterManager.class);
        }

        @Bean
        public SecondaryStorageVmManager secondaryStorageVmManager() {
            return Mockito.mock(SecondaryStorageVmManager.class);
        }

        @Bean
        public CommandExecLogDao commandExecLogDao() {
            return Mockito.mock(CommandExecLogDao.class);
        }

        @Bean
        public CiscoNexusVSMDeviceDao ciscoNexusVSMDeviceDao() {
            return Mockito.mock(CiscoNexusVSMDeviceDao.class);
        }

        @Bean
        public ClusterVSMMapDao clusterVSMMapDao() {
            return Mockito.mock(ClusterVSMMapDao.class);
        }

        @Bean
        public LegacyZoneDao legacyZoneDao() {
            return Mockito.mock(LegacyZoneDao.class);
        }

        @Bean
        public ManagementServerHostPeerDao managementServerHostPeerDao() {
            return Mockito.mock(ManagementServerHostPeerDao.class);
        }

        @Bean
        public ConfigurationDao configurationDao() {
            return Mockito.mock(ConfigurationDao.class);
        }

        @Bean
        public ConfigurationServer configurationServer() {
            return Mockito.mock(ConfigurationServer.class);
        }

        @Bean
        public HypervisorCapabilitiesDao hypervisorCapabilitiesDao() {
            return Mockito.mock(HypervisorCapabilitiesDao.class);
        }

        @Bean
        public AccountManager accountManager() {
            return Mockito.mock(AccountManager.class);
        }

        @Bean
        public EventDao eventDao() {
            return Mockito.mock(EventDao.class);
        }

        @Bean
        public UserVmDao userVMDao() {
            return Mockito.mock(UserVmDao.class);
        }

        public AddVmwareDcCmd addVmwareDatacenterCmd() {
            return Mockito.mock(AddVmwareDcCmd.class);
        }

        public RemoveVmwareDcCmd removeVmwareDcCmd() {
            return Mockito.mock(RemoveVmwareDcCmd.class);
        }

        @Bean
        public DataStoreManager dataStoreManager() {
            return Mockito.mock(DataStoreManager.class);
        }

        public static class Library implements TypeFilter {

            @Override
            public boolean match(MetadataReader mdr, MetadataReaderFactory arg1) throws IOException {
                ComponentScan cs = TestConfiguration.class.getAnnotation(ComponentScan.class);
                return SpringUtils.includedInBasePackageClasses(mdr.getClassMetadata().getClassName(), cs);
            }
        }
    }
}
