/*******************************************************************************
 * Copyright (c) 2001, 2004 IBM Corporation 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
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.xsd.ui.internal.provider;

import java.util.ArrayList;
import java.util.Collection;

import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.edit.provider.ChangeNotifier;
import org.eclipse.emf.edit.provider.Disposable;
import org.eclipse.emf.edit.provider.IChangeNotifier;
import org.eclipse.emf.edit.provider.IDisposable;
import org.eclipse.emf.edit.provider.INotifyChangedListener;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.swt.widgets.Display;
import org.eclipse.xsd.XSDAnnotation;
import org.eclipse.xsd.XSDAttributeDeclaration;
import org.eclipse.xsd.XSDAttributeGroupDefinition;
import org.eclipse.xsd.XSDAttributeUse;
import org.eclipse.xsd.XSDComplexTypeDefinition;
import org.eclipse.xsd.XSDElementDeclaration;
import org.eclipse.xsd.XSDImport;
import org.eclipse.xsd.XSDInclude;
import org.eclipse.xsd.XSDModelGroup;
import org.eclipse.xsd.XSDModelGroupDefinition;
import org.eclipse.xsd.XSDNotationDeclaration;
import org.eclipse.xsd.XSDParticle;
import org.eclipse.xsd.XSDRedefine;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.XSDSimpleTypeDefinition;
import org.eclipse.xsd.XSDWildcard;
import org.eclipse.xsd.util.XSDAdapterFactory;
import org.eclipse.xsd.util.XSDSwitch;

public class XSDModelAdapterFactoryImpl extends XSDAdapterFactory
  implements IChangeNotifier, IDisposable
{
  static XSDModelAdapterFactoryImpl instance;
  
  public static XSDModelAdapterFactoryImpl getInstance()
  {
    if (instance == null)
    {
      instance = new XSDModelAdapterFactoryImpl();
    }                                         
    return instance;
  }
  
  protected IChangeNotifier changeNotifier = new ChangeNotifier();
  
  protected Disposable disposable = new Disposable();
  
  protected Collection supportedTypes = new ArrayList();
  
  protected boolean showReferences = false;
  protected boolean showInherited = false;
  
  /**
   * 
   */
  public XSDModelAdapterFactoryImpl()
  {
    super();
    supportedTypes.add(ILabelProvider.class);
  }

  public void setShowReferences(boolean b)
  {
    showReferences = b;
  }
  
  public boolean getShowReferences()
  {
    return showReferences;
  }
  
  public void setShowInherited(boolean b)
  {
    showInherited= b;
  }
  
  public boolean getShowInherited()
  {
    return showInherited;
  }
  
  protected XSDSwitch modelSwitch = new XSDSwitch()
  {
      public Object caseXSDAnnotation(XSDAnnotation object)
      {
        return createXSDAnnotationAdapter();
      }
      public Object caseXSDAttributeDeclaration(XSDAttributeDeclaration object)
      {
        return createXSDAttributeDeclarationAdapter();
      }
      public Object caseXSDAttributeGroupDefinition(XSDAttributeGroupDefinition object)
      {
        return createXSDAttributeGroupDefinitionAdapter();
      }
      public Object caseXSDAttributeUse(XSDAttributeUse object)
      {
        return createXSDAttributeUseAdapter();
      }
      public Object caseXSDComplexTypeDefinition(XSDComplexTypeDefinition object)
      {
        return createXSDComplexTypeDefinitionAdapter();
      }
      public Object caseXSDElementDeclaration(XSDElementDeclaration object)
      {
        return createXSDElementDeclarationAdapter();
      }
      public Object caseXSDModelGroup(XSDModelGroup object)
      {
        return createXSDModelGroupAdapter();
      }
      public Object caseXSDModelGroupDefinition(XSDModelGroupDefinition object)
      {
        return createXSDModelGroupDefinitionAdapter();
      }
      public Object caseXSDNotationDeclaration(XSDNotationDeclaration object)
      {
        return createXSDNotationDeclarationAdapter();
      }
      public Object caseXSDParticle(XSDParticle object)
      {
        return createXSDParticleAdapter();
      }
//      public Object caseXSDParticleContent(XSDParticleContent object)
//      {
//        return createXSDParticleContentAdapter();
//      }
      public Object caseXSDSchema(XSDSchema object)
      {
        return createXSDSchemaAdapter();
      }
      public Object caseXSDImport(XSDImport object)
      {
        // return createXSDImportAdapter();
        return createXSDSchemaDirectiveAdapter();
      }
      public Object caseXSDInclude(XSDInclude object)
      {
        // return createXSDIncludeAdapter();
        return createXSDSchemaDirectiveAdapter();
      }
      public Object caseXSDRedefine(XSDRedefine object)
      {
        // return createXSDRedefineAdapter();
        return createXSDSchemaDirectiveAdapter();
      }
      public Object caseXSDSimpleTypeDefinition(XSDSimpleTypeDefinition object)
      {
        return createXSDSimpleTypeDefinitionAdapter();
      
      }
      public Object caseXSDWildcard(XSDWildcard object)
      {
        return createXSDWildcardAdapter();
      }
      public Object defaultCase(EObject object)
      {
        return createEObjectAdapter();
      }
  };

  public Adapter createAdapter(Notifier target)
  {
    Adapter adapter = null;
    if (target instanceof EObject)
    {
      adapter = (Adapter)modelSwitch.doSwitch((EObject)target);
    }
    return adapter;
  }

  /* create adapters */
  
  public Adapter createXSDAnnotationAdapter()
  {
    return new XSDAnnotationAdapter(this);
  }

  public Adapter createXSDAttributeDeclarationAdapter()
  {
    return new XSDAttributeDeclarationAdapter(this);
  }

  public Adapter createXSDAttributeGroupDefinitionAdapter()
  {
    return new XSDAttributeGroupDefinitionAdapter(this);
  }

  public Adapter createXSDAttributeUseAdapter()
  {
    return new XSDAttributeUseAdapter(this);
  }

  public Adapter createXSDComplexTypeDefinitionAdapter()
  {
	return new XSDComplexTypeDefinitionAdapter(this); 
  }

  public Adapter createXSDElementDeclarationAdapter()
  {
    return new XSDElementDeclarationAdapter(this);
  }

  public Adapter createXSDModelGroupAdapter()
  {
    return new XSDModelGroupAdapter(this);
  }


  public Adapter createXSDModelGroupDefinitionAdapter()
  {
    return new XSDModelGroupDefinitionAdapter(this);
  }

  public Adapter createXSDNotationDeclarationAdapter()
  {
    return new XSDNotationDeclarationAdapter(this);
  }

  public Adapter createXSDWildcardAdapter()
  {
    return new XSDWildcardAdapter(this);
  }
  
  public Adapter createXSDParticleAdapter()
  {
    return new XSDParticleAdapter(this);
  }
//
//  protected XSDParticleContentAdapter xsdParticleContentAdapter;
//  public Adapter createXSDParticleContentAdapter()
//  {
//    if (xsdParticleContentAdapter == null)
//    {
//      xsdParticleContentAdapter = new XSDParticleContentAdapter(this);
//    }
//    return xsdParticleContentAdapter;
//  }

  public Adapter createXSDSchemaAdapter()
  {
    return new XSDSchemaAdapter(this);
  }
  
  public Adapter createXSDSchemaDirectiveAdapter()
  {
    return new XSDSchemaDirectiveAdapter(this);
  }

  public Adapter createXSDSimpleTypeDefinitionAdapter()
  {
    return new XSDSimpleTypeDefinitionAdapter(this);
  }

  public Adapter createEObjectAdapter()
  {
    return null;
  }

  public boolean isFactoryForType(Object type)
  {
    return super.isFactoryForType(type) || supportedTypes.contains(type);
  }

  /**
   * This implementation substitutes the factory itself as the key for the adapter.
   */
  public Adapter adapt(Notifier notifier, Object type)
  {
    return super.adapt(notifier, this);
  }

  public Object adapt(Object object, Object type)
  {
    // This is a kludge to deal with enumerators, which crash the doSwitch.
    //
    if (object instanceof EObject && ((EObject)object).eClass() == null)
    {
      return null;
    }

    if (isFactoryForType(type))
    {
      Object adapter = super.adapt(object, type);
      if (!(type instanceof Class) || (((Class)type).isInstance(adapter)))
      {
        return adapter;
      }
    }

    return null;
  }

  public Adapter adaptNew(Notifier object, Object type)
  {
    Adapter result = super.adaptNew(object, type);
    disposable.add(result);
    return result;
  }

  /**
   * This adds a listener.
   */
  public void addListener(INotifyChangedListener notifyChangedListener)
  {
    changeNotifier.addListener(notifyChangedListener);
  }

  /**
   * This removes a listener.
   */
  public void removeListener(INotifyChangedListener notifyChangedListener)
  {
    changeNotifier.removeListener(notifyChangedListener);
  }

  /**
   * This delegates to {@link #changeNotifier} and to {@link #parentAdapterFactory}.
   */
  public void fireNotifyChanged(Notification notification)
  {
    Display display = Display.getDefault();
    if (display != null)
    {
      if (display.getThread() == Thread.currentThread ())
      {
        changeNotifier.fireNotifyChanged(notification);
      }
    }

//    if (parentAdapterFactory != null)
//    {
//      parentAdapterFactory.fireNotifyChanged(notification);
//    }
  }

  public void dispose()
  {
    instance = null;
    disposable.dispose();
  }

}