/**
 * 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.ambari.server.view;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.apache.ambari.server.controller.internal.AbstractResourceProvider;
import org.apache.ambari.server.controller.internal.ResourceImpl;
import org.apache.ambari.server.controller.spi.NoSuchParentResourceException;
import org.apache.ambari.server.controller.spi.NoSuchResourceException;
import org.apache.ambari.server.controller.spi.Predicate;
import org.apache.ambari.server.controller.spi.Request;
import org.apache.ambari.server.controller.spi.RequestStatus;
import org.apache.ambari.server.controller.spi.Resource;
import org.apache.ambari.server.controller.spi.ResourceAlreadyExistsException;
import org.apache.ambari.server.controller.spi.SystemException;
import org.apache.ambari.server.controller.spi.UnsupportedPropertyException;
import org.apache.ambari.server.orm.entities.ViewEntity;
import org.apache.ambari.server.orm.entities.ViewInstanceEntity;

/**
 * External view sub-resource provider.
 */
public class ViewExternalSubResourceProvider extends AbstractResourceProvider {

  /**
   * View external sub resource property id constants.
   */
  private static final String VIEW_NAME_PROPERTY_ID     = "view_name";
  private static final String VIEW_VERSION_PROPERTY_ID  = "version";
  private static final String INSTANCE_NAME_PROPERTY_ID = "instance_name";
  private static final String RESOURCE_NAME_PROPERTY_ID = "name";

  /**
   * The resource type.
   */
  private final Resource.Type type;

  /**
   * The names of the external resources for the view.
   */
  private final Set<String> resourceNames = new HashSet<>();

  /**
   * The set of key property ids.
   */
  private final Set<String> pkPropertyIds;

  /**
   * The associated view definition.
   */
  private final ViewEntity viewDefinition;


  // ----- Constructors ------------------------------------------------------

  /**
   * Construct a view sub-resource provider.
   *
   * @param type            the resource type
   * @param viewDefinition  the associated view definition
   */
  public ViewExternalSubResourceProvider(Resource.Type type, ViewEntity viewDefinition) {
    super(_getPropertyIds(), _getKeyPropertyIds(type));

    this.type           = type;
    this.pkPropertyIds  = new HashSet<>(getKeyPropertyIds().values());
    this.viewDefinition = viewDefinition;
  }

  @Override
  public RequestStatus createResources(Request request)
      throws SystemException, UnsupportedPropertyException,
      ResourceAlreadyExistsException, NoSuchParentResourceException {
    throw new UnsupportedOperationException("Not supported!");
  }

  @Override
  public Set<Resource> getResources(Request request, Predicate predicate)
      throws SystemException, UnsupportedPropertyException,
      NoSuchResourceException, NoSuchParentResourceException {

    Set<Resource> resourceSet = new HashSet<>();

    Set<ViewInstanceEntity> instanceDefinitions = new HashSet<>();

    Set<Map<String, Object>> propertyMaps = getPropertyMaps(predicate);
    int size = propertyMaps.size();

    Collection<ViewInstanceEntity> viewInstanceDefinitions = viewDefinition.getInstances();
    if (size == 0) {
      instanceDefinitions.addAll(viewInstanceDefinitions);
    } else {
      for (Map<String, Object> propertyMap : propertyMaps) {
        String instanceName = (String) propertyMap.get(INSTANCE_NAME_PROPERTY_ID);
        if (instanceName == null) {
          instanceDefinitions.addAll(viewInstanceDefinitions);
          break;
        } else {
          instanceDefinitions.add(viewDefinition.getInstanceDefinition(instanceName));
        }
      }
    }

    for (ViewInstanceEntity viewInstanceDefinition : instanceDefinitions) {
      for (String resourceName : resourceNames) {
        ResourceImpl resource = new ResourceImpl(type);
        resource.setProperty(VIEW_NAME_PROPERTY_ID, viewDefinition.getCommonName());
        resource.setProperty(VIEW_VERSION_PROPERTY_ID, viewDefinition.getVersion());
        resource.setProperty(INSTANCE_NAME_PROPERTY_ID, viewInstanceDefinition.getName());
        resource.setProperty("name", resourceName);
        resourceSet.add(resource);
      }
    }

    return resourceSet;
  }

  @Override
  public RequestStatus updateResources(Request request, Predicate predicate)
      throws SystemException, UnsupportedPropertyException,
      NoSuchResourceException, NoSuchParentResourceException {
    throw new UnsupportedOperationException("Not supported!");
  }

  @Override
  public RequestStatus deleteResources(Request request, Predicate predicate)
      throws SystemException, UnsupportedPropertyException,
      NoSuchResourceException, NoSuchParentResourceException {
    throw new UnsupportedOperationException("Not supported!");
  }

  @Override
  protected Set<String> getPKPropertyIds() {
    return pkPropertyIds;
  }

  @Override
  public Set<String> checkPropertyIds(Set<String> propertyIds) {
    return Collections.emptySet();
  }


  // ----- helper methods ----------------------------------------------------

  /**
   * Register an external sub-resource name.
   *
   * @param resourceName  the resource name
   */
  public void addResourceName(String resourceName) {
    resourceNames.add(resourceName);
  }

  // get the key property ids for the resource
  private static Map<Resource.Type, String> _getKeyPropertyIds(Resource.Type type) {

    Map<Resource.Type, String> keyPropertyIds = new HashMap<>();

    keyPropertyIds.put(Resource.Type.View, VIEW_NAME_PROPERTY_ID);
    keyPropertyIds.put(Resource.Type.ViewVersion, VIEW_VERSION_PROPERTY_ID);
    keyPropertyIds.put(Resource.Type.ViewInstance, INSTANCE_NAME_PROPERTY_ID);
    keyPropertyIds.put(type, RESOURCE_NAME_PROPERTY_ID);

    return keyPropertyIds;
  }

  // get the property ids for the resource
  private static Set<String> _getPropertyIds()  {
    Set<String> propertyIds = new HashSet<>();
    propertyIds.add(INSTANCE_NAME_PROPERTY_ID);
    propertyIds.add(VIEW_NAME_PROPERTY_ID);
    propertyIds.add(VIEW_VERSION_PROPERTY_ID);
    propertyIds.add(RESOURCE_NAME_PROPERTY_ID);

    return propertyIds;
  }
}