/*
 * JBoss, Home of Professional Open Source
 * Copyright 2005, JBoss Inc., and individual contributors as indicated
 * by the @authors tag. See the copyright.txt in the distribution for a
 * full listing of individual contributors.
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */
package org.jbpm.pvm.internal.wire;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.jbpm.pvm.internal.env.UserProvidedEnvironmentObject;
import org.jbpm.pvm.internal.wire.descriptor.AbstractDescriptor;
import org.jbpm.pvm.internal.wire.descriptor.ProvidedObjectDescriptor;


/**
 * map of {@link Descriptor}s that serve as input for a {@link WireContext}.
 *
 * @author Tom Baeyens
 * @author Guillaume Porcher (documentation)
 */
public class WireDefinition implements Serializable {

  private static final long serialVersionUID = 1L;
  // static Log log = Log.getLog(WireDefinition.class.getName());

  /** maps object names to {@link Descriptor}s */
  Map<String, Descriptor> descriptors;
  Map<Class<?>, String> descriptorNames;
  boolean useTypes = true;

  /** references all objects that must eagerly initialized.
   * @see WireContext */
  List<String> eagerInitNames;
  

  public WireDefinition() {
  }

  public WireDefinition(WireDefinition other, List<UserProvidedEnvironmentObject> txWireObjects) {
    if (other.descriptors!=null) {
      this.descriptors = new HashMap<String, Descriptor>(other.descriptors);
    }
    if (other.descriptorNames!=null) {
      this.descriptorNames = new HashMap<Class<?>, String>(other.descriptorNames);
    }
    if (other.eagerInitNames!=null) {
      this.eagerInitNames = new ArrayList<String>(other.eagerInitNames);
    }
    this.useTypes = other.useTypes;
    
    for (UserProvidedEnvironmentObject userProvidedEnvironmentObject: txWireObjects) {
      ProvidedObjectDescriptor descriptor = new ProvidedObjectDescriptor(
        userProvidedEnvironmentObject.getObject(),
        userProvidedEnvironmentObject.isTypeExposed(),
        userProvidedEnvironmentObject.getName()
      );
      addDescriptor(descriptor);
    }
  }

  public void addDescriptor(Descriptor descriptor) {
    if (descriptor!=null) {

      String name = descriptor.getName();

      if (useTypes) {
        Class<?> type = descriptor.getType(this);

        if (type!=null) {
          if ( (name==null)
               && (descriptor instanceof AbstractDescriptor)
             ) {
            name = type.getName();
            ((AbstractDescriptor)descriptor).setName(type.getName());
          }
          
          if ( (name!=null)
               && ( (descriptors==null)
                    || (!descriptors.containsKey(name))
                  )
             ) {
            // add all superclasses and interfaces to map to this descriptor
            addDescriptorType(type, descriptor, name);
          }
        }
      }
      
      if ( (name!=null)
           && (! hasDescriptor(name))
         ) {
        putDescriptor(name, descriptor);

        if (descriptor.isEagerInit()) {
          addEagerInitObjectName(name);
        }
      }
      
    }
  }

  void putDescriptor(String name, Descriptor descriptor) {
    if (descriptors==null) {
      descriptors = new HashMap<String, Descriptor>();
    }
    descriptors.put(name, descriptor);
  }

  void addDescriptorType(Class<?> type, Descriptor descriptor, String descriptorName) {
    if (type!=null) {
      if (descriptorNames==null) {
        descriptorNames = new HashMap<Class<?>, String>();
      }
      if (!descriptorNames.containsKey(type)) {
        descriptorNames.put(type, descriptorName);
      }
      addDescriptorType(type.getSuperclass(), descriptor, descriptorName);
      Class<?>[] interfaceTypes = type.getInterfaces();
      if (interfaceTypes!=null) {
        for (Class<?> interfaceType: interfaceTypes) {
          addDescriptorType(interfaceType, descriptor, descriptorName);
        }
      }
    }
  }
  
  public String getDescriptorName(Class<?> type) {
    return (descriptorNames!=null ? descriptorNames.get(type) : null ); 
  }

  /** the descriptor with the given name from the WireDefinition or <code>null</code>
   * if the object doesn't have a descriptor.
   */
  public Descriptor getDescriptor(String objectName) {
    if (descriptors==null) {
      return null;
    }
    return descriptors.get(objectName);
  }

  /** @return previous Descriptor associated with the given name, or null if there was no Descriptor for this name. */
  public synchronized Descriptor addDescriptor(String objectName, Descriptor descriptor) {
    if (descriptors==null) {
      descriptors = new HashMap<String, Descriptor>();
    }
    return descriptors.put(objectName, descriptor);
  }

  /** @return previous Descriptor associated with the given name, or null if there was no Descriptor for this name. */
  public synchronized Descriptor removeDescriptor(String objectName) {
    if (descriptors!=null) {
      return descriptors.remove(objectName);
    }
    return null;
  }

  public boolean hasDescriptor(String objectName) {
    return (descriptors!=null)
           && (descriptors.containsKey(objectName));
  }

  public void addEagerInitObjectName(String eagerInitObjectName) {
    if (eagerInitObjectName!=null) {
      if (eagerInitNames==null) {
        eagerInitNames = new ArrayList<String>();
      }
      eagerInitNames.add(eagerInitObjectName);
    }
  }

  public void addWireDefinition(WireDefinition wireDefinition) {
    if ( (wireDefinition!=null)
         && (wireDefinition.getDescriptors()!=null)
       ) {
      for (Descriptor descriptor: wireDefinition.getDescriptors().values()) {
        addDescriptor(descriptor);
      }
    }
  }

  public Set<Class<?>> getDescriptorTypes() {
    return (descriptorNames!=null ? descriptorNames.keySet() : null);
  }
  public Map<String, Descriptor> getDescriptors() {
    return descriptors;
  }
  public List<String> getEagerInitNames() {
    return eagerInitNames;
  }
  public void setEagerInitNames(List<String> eagerInitNames) {
    this.eagerInitNames = eagerInitNames;
  }
  public void setDescriptors(Map<String, Descriptor> descriptors) {
    this.descriptors = descriptors;
  }
}