package org.andromda.cartridges.meta.metafacades;

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

/**
 * @author <a href="http://www.mbohlen.de">Matthias Bohlen </a>
 * @author Chad Brandon
 * @author Cyril Combe
 * @since 10.12.2003
 */
public class MethodData implements Comparable
{
    private String metafacadeName;
    private String visibility;
    private boolean isAbstract;
    private String name;
    private String returnTypeName;
    private String documentation;
    private final List<ArgumentData> arguments = new ArrayList<ArgumentData>();
    private final List<String> exceptions = new ArrayList<String>();

    /**
     * @param metafacadeNameIn
     * @param visibilityIn
     * @param isAbstractIn
     * @param returnTypeNameIn
     * @param nameIn
     * @param documentationIn
     */
    public MethodData(
        String metafacadeNameIn,
        String visibilityIn,
        boolean isAbstractIn,
        String returnTypeNameIn,
        String nameIn,
        String documentationIn)
    {
        this.metafacadeName = metafacadeNameIn;
        this.visibility = visibilityIn;
        this.isAbstract = isAbstractIn;
        this.name = nameIn;
        this.returnTypeName = returnTypeNameIn;
        this.documentation = documentationIn;
    }

    /**
     * @param argument
     */
    public void addArgument(ArgumentData argument)
    {
        this.arguments.add(argument);
    }

    /**
     * @return arguments
     */
    public Collection<ArgumentData> getArguments()
    {
        return this.arguments;
    }

    /**
     * @param typeName
     */
    public void addException(String typeName)
    {
        this.exceptions.add(typeName);
    }

    /**
     * @return exceptions
     */
    public Collection<String> getExceptions()
    {
        return this.exceptions;
    }

    /**
     * Gets the metafacade name.
     *
     * @return the name of the metafacade
     */
    public String getMetafacadeName()
    {
        return this.metafacadeName;
    }

    /**
     * Gets the name of the method.
     *
     * @return the name.
     */
    public String getName()
    {
        return this.name;
    }

    /**
     * Gets the name of the return type for this method.
     *
     * @return the return type name.
     */
    public String getReturnTypeName()
    {
        return this.returnTypeName;
    }

    /**
     * Builds a string representing a declaration for this method.
     *
     * @param suppressAbstractDeclaration
     *            optionally suppress the "abstract" modifier
     * @return String the declaration
     */
    public String buildMethodDeclaration(boolean suppressAbstractDeclaration)
    {
        String declaration = this.visibility + ' '
                + ((this.isAbstract && !suppressAbstractDeclaration) ? "abstract " : "")
                + ((this.returnTypeName != null) ? (this.returnTypeName + ' ') : "") + this.name + '(';

        declaration += getTypedArgumentList();
        /*for (final Iterator iterator = this.arguments.iterator(); iterator.hasNext();)
        {
            final ArgumentData argument = (ArgumentData)iterator.next();
            declaration += (argument.getFullyQualifiedTypeName() + " " + argument.getName());
            if (iterator.hasNext())
            {
                declaration += ", ";
            }
        }*/
        declaration += ')';

        if (!this.exceptions.isEmpty())
        {
            declaration += " throws ";
            for (final Iterator<String> iterator = this.exceptions.iterator(); iterator.hasNext();)
            {
                String exception = iterator.next();
                declaration += exception;
                if (iterator.hasNext())
                {
                    declaration += ", ";
                }
            }
        }

        return declaration;
    }

    /**
     * Builds a string representing a comma separated parameter type + name list.
     *
     * @return String the declaration
     */
    public String getTypedArgumentList()
    {
        return getTypedArgumentList(null);
    }

    /**
     * Builds a string representing a comma separated parameter type + name list.
     *
     * @param modifier Optional modifier before each parameter
     * @return String the declaration
     */
    public String getTypedArgumentList(String modifier)
    {
        String declaration = "";

        for (final Iterator<ArgumentData> iterator = this.arguments.iterator(); iterator.hasNext();)
        {
            final ArgumentData argument = iterator.next();
            if (modifier!=null)
            {
                declaration += modifier + ' ';
            }
            declaration += (argument.getFullyQualifiedTypeName() + ' ' + argument.getName());
            if (iterator.hasNext())
            {
                declaration += ", ";
            }
        }
        return declaration;
    }

    /**
     * Builds a string representing a call to the method.
     *
     * @return String how a call would look like
     */
    public String buildMethodCall()
    {
        String call = getName() + '(';

        for (final Iterator<ArgumentData> iterator = this.arguments.iterator(); iterator.hasNext();)
        {
            final ArgumentData argument = iterator.next();
            call += argument.getName();
            if (iterator.hasNext())
            {
                call += ", ";
            }
        }
        call += ')';
        return call;
    }

    /**
     * Builds a signature which can be used as a key into a map. Consists of the methodName, number of arguments,
     * return type, the name and the f.q. types of the arguments.
     *
     * @return String the key that identifies this method
     */
    public String buildCharacteristicKey()
    {
        String key = ((this.returnTypeName != null) ? (this.returnTypeName + ' ') : "") + this.name + '(';

        for (final Iterator<ArgumentData> iterator = this.arguments.iterator(); iterator.hasNext();)
        {
            final ArgumentData argument = iterator.next();
            key += argument.getFullyQualifiedTypeName();
            if (iterator.hasNext())
            {
                key += ',';
            }
        }
        key += ')';

        return key;
    }

    /**
     * Indicates whether or not this method is abstract.
     *
     * @return true/false
     */
    public boolean isAbstract()
    {
        return this.isAbstract;
    }

    /**
     * Gets the visibility of this method.
     *
     * @return the visibility.
     */
    public String getVisibility()
    {
        return this.visibility;
    }

    /**
     * Gets the documentation for this method.
     *
     * @return the documentation.
     */
    public String getDocumentation()
    {
        return this.documentation;
    }

    /**
     * Tells if this method returns something.
     *
     * @return boolean
     */
    public boolean isReturnTypePresent()
    {
        return this.returnTypeName != null && !"void".equals(this.returnTypeName);
    }

    /**
     * @see Comparable#compareTo(Object)
     */
    public int compareTo(final Object object)
    {
        MethodData other = (MethodData)object;
        final int result = getMetafacadeName().compareTo(other.getMetafacadeName());

        // Use the characteristic key in order to have a deterministic order, starting with method name and number of arguments
        return (result != 0) ? result : (name + arguments.size() + ", " + buildCharacteristicKey())
            .compareTo(other.getName() + other.getArguments().size() + ", " + other.buildCharacteristicKey());
    }

    /**
     * @see Object#toString()
     */
    @Override
    public String toString()
    {
        return this.buildMethodDeclaration(false);
    }
}