/*
 *  Copyright 2010, 2011 Christopher Pheby
 *
 *  Licensed 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.jadira.bindings.core.loader;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

import org.jadira.bindings.core.annotation.DefaultBinding;

/**
 * Represents a BindingConfigurationEntry - a specification of a particular
 * binding by configuration 
 * 
 * The configuration entry either consists of a) a
 * binding class implementing either {@link org.jadira.bindings.core.api.Binding}, 
 * {@link org.jadira.bindings.core.api.ToMarshaller},
 * {@link org.jadira.bindings.core.api.FromUnmarshaller}, 
 * or {@link org.jadira.bindings.core.api.Converter} together with an optional
 * qualifier, b) an arbitrary class to be inspected for annotations or other
 * configuration meaningful to a Provider, 
 * or c) an explicit definitionof a method for marshalling or unmarshalling 
 * and/or constructor (either from method or from constructor can be defined but 
 * not both).
 * 
 * @author Chris
 */
public class BindingConfigurationEntry {

	private final Class<?> bindingClass;
	private final Class<?> sourceClass;
	private final Class<?> targetClass;
	private final Class<? extends Annotation> qualifier;
	private final Method toMethod;
	private final Method fromMethod;
	private final Constructor<?> fromConstructor;

	/**
	 * Create a new entry for the given binding class
	 * @param bindingClass The binding class
	 */
	public BindingConfigurationEntry(Class<?> bindingClass) {
		this(bindingClass, null);
	}

	/**
	 * Create a new entry for the given binding class and qualifier
	 * @param bindingClass The binding class
	 * @param qualifier The qualifier
	 */
	public BindingConfigurationEntry(Class<?> bindingClass, Class<? extends Annotation> qualifier) {
		
		this.bindingClass = bindingClass;
		this.qualifier = qualifier == null ? DefaultBinding.class : qualifier;
		
		this.sourceClass = null;
		this.targetClass = null;
		this.toMethod = null;
		this.fromMethod = null;
		this.fromConstructor = null;
	}
	
	/**
	 * Create a new entry for the given options
	 * @param sourceClass The source class to be bound
	 * @param targetClass The foreign side of the relationship
	 * @param qualifier The qualifier
	 * @param toMethod The to method to be bound
	 * @param fromMethod The from method to be bound
	 */
	public BindingConfigurationEntry(Class<?> sourceClass, Class<?> targetClass,
			Class<? extends Annotation> qualifier, Method toMethod,
			Method fromMethod) {
		
		this.sourceClass = sourceClass;
		this.targetClass = targetClass;
		this.qualifier = qualifier == null ? DefaultBinding.class : qualifier;
		this.toMethod = toMethod;
		this.fromMethod = fromMethod;
		this.fromConstructor = null;
		
		this.bindingClass = null;
	}
	
	/**
	 * Create a new entry for the given options
	 * @param sourceClass The source class to be bound
	 * @param targetClass The foreign side of the relationship
	 * @param qualifier The qualifier
	 * @param toMethod The to method to be bound
	 * @param fromConstructor The from constructor to be bound
	 */
	public BindingConfigurationEntry(Class<?> sourceClass, Class<?> targetClass,
			Class<? extends Annotation> qualifier, Method toMethod,
			Constructor<?> fromConstructor) {
		
		this.sourceClass = sourceClass;
		this.targetClass = targetClass;
		this.qualifier = qualifier == null ? DefaultBinding.class : qualifier;
		this.toMethod = toMethod;
		this.fromConstructor = fromConstructor;
		this.fromMethod = null;
		
		this.bindingClass = null;
	}

	/**
	 * @return The Binding Class, if any
	 */
	public Class<?> getBindingClass() {
		return bindingClass;
	}

	/**
	 * @return The Source Class, if any
	 */
	public Class<?> getSourceClass() {
		return sourceClass;
	}

	/**
	 * @return The Target Class, if any
	 */
	public Class<?> getTargetClass() {
		return targetClass;
	}

	/**
	 * @return The Qualifier Annotation, if any
	 */
	public Class<? extends Annotation> getQualifier() {
		return qualifier;
	}

	/** 
	 * @return The To Method, if any
	 */
	public Method getToMethod() {
		return toMethod;
	}

	/** 
	 * @return The From Method, if any
	 */
	public Method getFromMethod() {
		return fromMethod;
	}

	/** 
	 * @return The From Constructor, if any
	 */
	public Constructor<?> getFromConstructor() {
		return fromConstructor;
	}
}