/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.xsd.ui.internal.adapters;


import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.Assert;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.NotificationImpl;
import org.eclipse.swt.graphics.Image;
import org.eclipse.wst.xsd.ui.internal.adt.actions.BaseSelectionAction;
import org.eclipse.wst.xsd.ui.internal.adt.actions.DeleteAction;
import org.eclipse.wst.xsd.ui.internal.adt.actions.SetInputToGraphView;
import org.eclipse.wst.xsd.ui.internal.adt.actions.ShowPropertiesViewAction;
import org.eclipse.wst.xsd.ui.internal.adt.facade.IADTObject;
import org.eclipse.wst.xsd.ui.internal.adt.outline.ITreeElement;
import org.eclipse.wst.xsd.ui.internal.editor.Messages;
import org.eclipse.wst.xsd.ui.internal.editor.XSDEditorPlugin;
import org.eclipse.xsd.XSDAttributeGroupDefinition;
import org.eclipse.xsd.XSDComplexTypeDefinition;
import org.eclipse.xsd.XSDModelGroupDefinition;
import org.eclipse.xsd.XSDPackage;
import org.eclipse.xsd.XSDRedefine;
import org.eclipse.xsd.XSDRedefineContent;
import org.eclipse.xsd.XSDSimpleTypeDefinition;


public class XSDRedefineAdapter extends XSDSchemaDirectiveAdapter
{

  public XSDRedefineAdapter()
  {
    super();
  }

  public ITreeElement[] getChildren()
  {
    XSDRedefine xsdRedefine = (XSDRedefine)getTarget();

    children = new ArrayList();

    if (attributesCategory != null)
    {
      List attributes = getCategoryChildren(CategoryAdapter.ATTRIBUTES);
      List groups = getCategoryChildren(CategoryAdapter.GROUPS);
      List types = getCategoryChildren(CategoryAdapter.TYPES);

      attributesCategory.setChildren(attributes);
      attributesCategory.setAllChildren(attributes);
      typesCategory.setChildren(types);
      typesCategory.setAllChildren(types);
      groupsCategory.setChildren(groups);
      groupsCategory.setAllChildren(groups);
    }
    else
    {
      createCategoryAdapters(xsdRedefine);
    }

    children.add(attributesCategory);
    children.add(typesCategory);
    children.add(groupsCategory);

    return (ITreeElement[])children.toArray(new ITreeElement [0]);
  }

  public IADTObject getTopContainer()
  {
    return this;
  }

  public boolean isFocusAllowed()
  {
    return true;
  }

  protected List types = null;

  protected List children, allChildren;

  protected CategoryAdapter attributesCategory;

  protected CategoryAdapter typesCategory;

  protected CategoryAdapter groupsCategory;

  /**
   * Create all the category adapters
   * 
   * @param xsdRedefine the parent redefine component
   */
  private void createCategoryAdapters(XSDRedefine xsdRedefine)
  {
    List attributes = getCategoryChildren(CategoryAdapter.ATTRIBUTES);
    List groups = getCategoryChildren(CategoryAdapter.GROUPS);
    List types = getCategoryChildren(CategoryAdapter.TYPES);

    XSDEditorPlugin xsdEditorPlugin = XSDEditorPlugin.getDefault();
    attributesCategory = new RedefineCategoryAdapter(
      Messages._UI_GRAPH_REDEFINE_ATTRIBUTE_GROUPS,
      xsdEditorPlugin.getIconImage("obj16/attributesheader"), attributes, xsdRedefine, this, CategoryAdapter.ATTRIBUTES); //$NON-NLS-1$
    attributesCategory.setAllChildren(attributes);
    registerListener(attributesCategory);

    typesCategory = new RedefineCategoryAdapter(
      Messages._UI_GRAPH_REDEFINE_TYPES,
      xsdEditorPlugin.getIconImage("obj16/typesheader"), types, xsdRedefine, this, CategoryAdapter.TYPES); //$NON-NLS-1$
    typesCategory.setAllChildren(types);
    registerListener(typesCategory);

    groupsCategory = new RedefineCategoryAdapter(
      Messages._UI_GRAPH_REDEFINE_GROUPS,
      xsdEditorPlugin.getIconImage("obj16/groupsheader"), groups, xsdRedefine, this, CategoryAdapter.GROUPS); //$NON-NLS-1$
    groupsCategory.setAllChildren(groups);
    registerListener(groupsCategory);
  }

  public void notifyChanged(final Notification msg)
  {
    class CategoryNotification extends NotificationImpl
    {
      protected Object category;

      public CategoryNotification(Object category)
      {
        super(msg.getEventType(), msg.getOldValue(), msg.getNewValue(), msg.getPosition());
        this.category = category;
      }

      public Object getNotifier()
      {
        return category;
      }

      public Object getFeature()
      {
        return msg.getFeature();
      }
    }

    if (children == null)
    {
      getChildren();
    }

    Object newValue = msg.getNewValue();
    Object oldValue = msg.getOldValue();

    if (XSDPackage.eINSTANCE.getXSDRedefine_Contents() == msg.getFeature())
    {
      if ((newValue instanceof XSDAttributeGroupDefinition) || oldValue instanceof XSDAttributeGroupDefinition)
      {
        CategoryAdapter adapter = getCategory(CategoryAdapter.ATTRIBUTES);
        Assert.isTrue(adapter != null);
        List list = getCategoryChildren(CategoryAdapter.ATTRIBUTES);
        adapter.setChildren(list);
        adapter.setAllChildren(list);
       
        if (adapter.getModel() instanceof XSDSchemaAdapter)
        {
        	XSDSchemaAdapter schemaAdapter = (XSDSchemaAdapter)adapter.getModel();
        	schemaAdapter.notifyChanged(msg);
        }
       
        notifyListeners(new CategoryNotification(adapter), adapter.getText());
        return;
      }
      else if ((newValue instanceof XSDComplexTypeDefinition || newValue instanceof XSDSimpleTypeDefinition) || (oldValue instanceof XSDComplexTypeDefinition || oldValue instanceof XSDSimpleTypeDefinition))
      {
        CategoryAdapter adapter = getCategory(CategoryAdapter.TYPES);
        Assert.isTrue(adapter != null);
        List types = getCategoryChildren(CategoryAdapter.TYPES);
        adapter.setChildren(types);
        adapter.setAllChildren(types);
        if (adapter.getModel() instanceof XSDSchemaAdapter)
        {
        	XSDSchemaAdapter schemaAdapter = (XSDSchemaAdapter)adapter.getModel();
        	schemaAdapter.notifyChanged(msg);
        }
        notifyListeners(new CategoryNotification(adapter), adapter.getText());
        return;
      }
      else if (newValue instanceof XSDModelGroupDefinition || oldValue instanceof XSDModelGroupDefinition)
      {
        CategoryAdapter adapter = getCategory(CategoryAdapter.GROUPS);
        Assert.isTrue(adapter != null);
        List list = getCategoryChildren(CategoryAdapter.GROUPS);
        adapter.setChildren(list);
        adapter.setAllChildren(list); 
        if (adapter.getModel() instanceof XSDSchemaAdapter)
        {
        	XSDSchemaAdapter schemaAdapter = (XSDSchemaAdapter)adapter.getModel();
        	schemaAdapter.notifyChanged(msg);
        }
        notifyListeners(new CategoryNotification(adapter), adapter.getText());       
        return;
      }
      else if (msg.getFeature() == XSDPackage.eINSTANCE.getXSDSchema_Annotations())
      {
        return;
      }
    }
    super.notifyChanged(msg);
  }

  private void updateCategories()
  {
    getChildren();
  }

  public CategoryAdapter getCategory(int category)
  {
    if (children == null)
    {
      updateCategories();
    }
    int length = children.size();
    CategoryAdapter adapter = null;
    for (int index = 0; index < length; index++)
    {
      adapter = (CategoryAdapter)children.get(index);
      if (adapter.getGroupType() == category)
      {
        break;
      }
    }
    return adapter;
  }

  public String[] getActions(Object object)
  {
    Collection actionIDs = new ArrayList();

    actionIDs.add(DeleteAction.ID);
    actionIDs.add(BaseSelectionAction.SEPARATOR_ID);
    actionIDs.add(SetInputToGraphView.ID);
    actionIDs.add(BaseSelectionAction.SEPARATOR_ID);
    actionIDs.add(ShowPropertiesViewAction.ID);

    return (String[])actionIDs.toArray(new String [0]);
  }

  public void propertyChanged(Object object, String property)
  {
    notifyListeners(object, property);
  }

  public Image getImage()
  {
    return XSDEditorPlugin.getXSDImage("icons/XSDRedefine.gif"); //$NON-NLS-1$
  }

  private List getCategoryChildren(int category)
  {
    List list = new ArrayList();
    XSDRedefine redefine = (XSDRedefine)target;
    Iterator iterator = redefine.getContents().iterator();
    while (iterator.hasNext())
    {
      XSDRedefineContent redefineContent = (XSDRedefineContent)iterator.next();

      if (redefineContent instanceof XSDAttributeGroupDefinition && category == CategoryAdapter.ATTRIBUTES)
      {
        list.add(redefineContent);
      }
      else if (redefineContent instanceof XSDModelGroupDefinition && category == CategoryAdapter.GROUPS)
      {
        list.add(redefineContent);
      }
      else if (redefineContent instanceof XSDComplexTypeDefinition && category == CategoryAdapter.TYPES)
      {
        list.add(redefineContent);
      }
      else if (redefineContent instanceof XSDSimpleTypeDefinition && category == CategoryAdapter.TYPES)
      {
        list.add(redefineContent);
      }
    }
    List adapterList = new ArrayList();
    populateAdapterList(list, adapterList);
    return adapterList;
  }
}