/**********************************************************************
 * Copyright (c) 2002,2003 Rational Software Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Common Public License v0.5
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v05.html
 * 
 * Contributors: 
 * IBM Rational Software - Initial API and implementation
***********************************************************************/
package org.eclipse.cdt.internal.core.parser;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import org.eclipse.cdt.core.parser.ITokenDuple;
import org.eclipse.cdt.core.parser.ast.ASTPointerOperator;
import org.eclipse.cdt.core.parser.ast.ASTSemanticException;
import org.eclipse.cdt.core.parser.ast.IASTAbstractDeclaration;
import org.eclipse.cdt.core.parser.ast.IASTClassSpecifier;
import org.eclipse.cdt.core.parser.ast.IASTDeclaration;
import org.eclipse.cdt.core.parser.ast.IASTFactory;
import org.eclipse.cdt.core.parser.ast.IASTField;
import org.eclipse.cdt.core.parser.ast.IASTFunction;
import org.eclipse.cdt.core.parser.ast.IASTMethod;
import org.eclipse.cdt.core.parser.ast.IASTScope;
import org.eclipse.cdt.core.parser.ast.IASTSimpleTypeSpecifier;
import org.eclipse.cdt.core.parser.ast.IASTTemplate;
import org.eclipse.cdt.core.parser.ast.IASTTypeSpecifier;
import org.eclipse.cdt.core.parser.ast.IASTTypedefDeclaration;
import org.eclipse.cdt.core.parser.ast.IASTVariable;
import org.eclipse.cdt.core.parser.ast.IASTSimpleTypeSpecifier.Type;
/**
 * @author jcamelon
 *
 */
public class DeclarationWrapper implements IDeclaratorOwner
{ 
    private boolean imaginary, complex;
    private boolean restrict;
    private int endOffset;
    private ITokenDuple name;
    private Type simpleType =
        IASTSimpleTypeSpecifier.Type.UNSPECIFIED;
    private boolean isSigned;
    private boolean isLong;
    private boolean isShort;
    private boolean isUnsigned;
    private final IASTTemplate templateDeclaration;
    private final IASTScope scope;
    private IASTTypeSpecifier typeSpecifier;
    private List declarators = new ArrayList();
    private boolean typeNamed = false;
    private boolean volatil = false;
    private boolean virtual = false;
    private boolean typedef = false;
    private boolean staticc = false;
    private boolean register = false;
    private boolean extern = false;
    private boolean explicit = false;
    private boolean constt = false;
    private int startingOffset = 0;
    private boolean auto = false,
        mutable = false,
        friend = false,
        inline = false;
    /**
     * @param b
     */
    public void setAuto(boolean b)
    {
        auto = b;
    }
    /**
     * @return
     */
    public IASTScope getScope()
    {
        return scope;
    }
    /**
     * @param scope
     */
    public DeclarationWrapper(
        IASTScope scope,
        int startingOffset,
        IASTTemplate templateDeclaration)
    {
        this.scope = scope;
        this.startingOffset = startingOffset;
        this.templateDeclaration = templateDeclaration;
    }
    /**
     * @param b
     */
    public void setTypenamed(boolean b)
    {
        typeNamed = b;
    }
    /**
     * @param b
     */
    public void setMutable(boolean b)
    {
        mutable = b;
    }
    /**
     * @param b
     */
    public void setFriend(boolean b)
    {
        friend = b;
    }
    /**
     * @param b
     */
    public void setInline(boolean b)
    {
        inline = b;
    }
    /**
     * @param b
     */
    public void setRegister(boolean b)
    {
        register = b;
    }
    /**
     * @param b
     */
    public void setStatic(boolean b)
    {
        staticc = b;
    }
    /**
     * @param b
     */
    public void setTypedef(boolean b)
    {
        typedef = b;
    }
    /**
     * @param b
     */
    public void setVirtual(boolean b)
    {
        virtual = b;
    }
    /**
     * @param b
     */
    public void setVolatile(boolean b)
    {
        volatil = b;
    }
    /**
     * @param b
     */
    public void setExtern(boolean b)
    {
        extern = b;
    }
    /**
     * @param b
     */
    public void setExplicit(boolean b)
    {
        explicit = b;
    }
    /**
     * @param b
     */
    public void setConst(boolean b)
    {
        constt = b;
    }
    /**
     * @return
     */
    public boolean isAuto()
    {
        return auto;
    }
    /**
     * @return
     */
    public boolean isConst()
    {
        return constt;
    }
    /**
     * @return
     */
    public boolean isExplicit()
    {
        return explicit;
    }
    /**
     * @return
     */
    public boolean isExtern()
    {
        return extern;
    }
    /**
     * @return
     */
    public boolean isFriend()
    {
        return friend;
    }
    /**
     * @return
     */
    public boolean isInline()
    {
        return inline;
    }
    /**
     * @return
     */
    public boolean isMutable()
    {
        return mutable;
    }
    /**
     * @return
     */
    public boolean isRegister()
    {
        return register;
    }
    /**
     * @return
     */
    public int getStartingOffset()
    {
        return startingOffset;
    }
    /**
     * @return
     */
    public boolean isStatic()
    {
        return staticc;
    }
    /**
     * @return
     */
    public boolean isTypedef()
    {
        return typedef;
    }
    /**
     * @return
     */
    public boolean isTypeNamed()
    {
        return typeNamed;
    }
    /**
     * @return
     */
    public boolean isVirtual()
    {
        return virtual;
    }
    /**
     * @return
     */
    public boolean isVolatile()
    {
        return volatil;
    }
    public void addDeclarator(Declarator d)
    {
        declarators.add(d);
    }
    public Iterator getDeclarators()
    {
        return Collections.unmodifiableList(declarators).iterator();
    }
    /**
     * @return
     */
    public IASTTypeSpecifier getTypeSpecifier()
    {
        return typeSpecifier;
    }
    /**
     * @param specifier
     */
    public void setTypeSpecifier(IASTTypeSpecifier specifier)
    {
        typeSpecifier = specifier;
    }
    private IASTFactory astFactory = null;
    /**
     * @param requestor
     */
    public List createASTNodes(IASTFactory astFactory) throws ASTSemanticException
    {
        this.astFactory = astFactory;
        Iterator i = declarators.iterator();
        List l = new ArrayList();
        while (i.hasNext())
            l.add(createASTNode((Declarator)i.next()));
        return l;
    }
    /**
     * @param declarator
     */
    private IASTDeclaration createASTNode(Declarator declarator) throws ASTSemanticException
    {
        boolean isWithinClass = (getScope() instanceof IASTClassSpecifier); //TODO fix this for COMPLETE_PARSE
        boolean isFunction = declarator.isFunction();
        boolean hasInnerDeclarator = ( declarator.getOwnedDeclarator() != null );
                
        if( hasInnerDeclarator )
        	return createIndirectDeclaration( declarator ); 
        	
        if (isTypedef())
            return createTypedef(declarator, false);

        if (isWithinClass )
        {
        	if( isFunction)
           		return createMethodASTNode(declarator, false);
        	else 
            	return createFieldASTNode(declarator, false );
        }
        else 
        {	
        	if (isFunction)
               		return createFunctionASTNode(declarator, false);
        	else 
            	return createVariableASTNode(declarator, false);
        }
    }
    /**
     * @param declarator
     * @return
     */
    private IASTDeclaration createIndirectDeclaration(Declarator declarator) throws ASTSemanticException
    {    
        if( declarator.getOwnedDeclarator().getOwnedDeclarator() == null )
        {

        	Declarator d = declarator.getOwnedDeclarator();
        	Iterator i = d.getPointerOperators().iterator();
        	if( !i.hasNext() )
        	{
                boolean isWithinClass = scope instanceof IASTClassSpecifier;
				boolean isFunction = (declarator.getParameters().size() != 0); 
				if (isTypedef())
					return createTypedef(declarator, true);

				if (isWithinClass )
				{
					if( isFunction)
						return createMethodASTNode(declarator, true);
					else 
						return createFieldASTNode(declarator, true );
				}
				else 
				{	
					if (isFunction)
						return createFunctionASTNode(declarator, true);
					else 
						return createVariableASTNode(declarator, true);
				}

        	}
        	
			List convertedParms = createParameterList( declarator.getParameters() );        	
        	IASTAbstractDeclaration abs = null;
            try
            {
                abs =
                    astFactory.createAbstractDeclaration(
                        constt,
                        volatil,
                        getTypeSpecifier(),
                        declarator.getPointerOperators(),
                        declarator.getArrayModifiers(),
                        convertedParms,
                        (ASTPointerOperator)i.next());
            }
            catch (Exception e)
            {
                throw new ASTSemanticException();
            }
        	String name = ( d.getPointerOperatorNameDuple() != null ) ? d.getPointerOperatorNameDuple().toString() + d.getName() : d.getName(); 
        	if( typedef )
				try
                {
                    return astFactory.createTypedef(
                    	scope,
                    	name,
                    	abs, getStartingOffset(), d.getNameStartOffset(), d.getNameEndOffset() );
                }
                catch (ASTSemanticException e1)
                {
                    throw e1;
                }
                catch (Exception e1)
                {
                    throw new ASTSemanticException();
                } 
        	else
        		try
                {
                    return astFactory.createVariable( scope, name, auto, d.getInitializerClause(), d.getBitFieldExpression(), abs, mutable, extern, register, staticc, getStartingOffset(), d.getNameStartOffset(), d.getNameEndOffset(), d.getConstructorExpression() );
                }
                catch (Exception e2)
                {
                    throw new ASTSemanticException();
                }
        	
        }
        else
        {
        	throw new ASTSemanticException(); 	
        }
        
    }
    
    /**
     * @param declarator
     * @return
     */
    private IASTTypedefDeclaration createTypedef(Declarator declarator, boolean nested ) throws ASTSemanticException
    {
        try
        {
            return astFactory.createTypedef(
                scope,
                nested ? declarator.getOwnedDeclarator().getName() : declarator.getName(),
                astFactory.createAbstractDeclaration(
                    constt,
                    volatil,
                    getTypeSpecifier(),
                    declarator.getPointerOperators(), declarator.getArrayModifiers(), null, null), startingOffset, declarator.getNameStartOffset(), declarator.getNameEndOffset());
        }
        catch (ASTSemanticException e)
        {
            throw e;
        }
        catch (Exception e)
        {
            throw new ASTSemanticException();
        }
    }
    /**
     * @param declarator
     * @return
     */
    private IASTMethod createMethodASTNode(Declarator declarator, boolean nested) throws ASTSemanticException
    {
        try
        {
            return astFactory
                .createMethod(
                    scope,
                    nested ? declarator.getOwnedDeclarator().getNameDuple() : declarator.getNameDuple(),
            		createParameterList(declarator.getParameters()),
                    astFactory.createAbstractDeclaration(
                        constt,
            			volatil,
                        getTypeSpecifier(),
                        declarator.getPointerOperators(), declarator.getArrayModifiers(), null, null),
                    declarator.getExceptionSpecification(),
                    inline,
                    friend,
                    staticc,
                    startingOffset,
                    declarator.getNameStartOffset(),
                    declarator.getNameEndOffset(),
                    templateDeclaration,
                    declarator.isConst(),
                    declarator.isVolatile(),
                    virtual,
                    explicit,
                    declarator.isPureVirtual(), ((IASTClassSpecifier)scope).getCurrentVisibilityMode(), 
                    declarator.getConstructorMemberInitializers(), declarator.hasFunctionBody(), declarator.hasFunctionTryBlock(), declarator.isVarArgs());
        }
        catch (ASTSemanticException e)
        {
            throw e;
        }
        catch (Exception e)
        {
            throw new ASTSemanticException();
        }
    }
    /**
     * @param declarator
     * @return
     */
    private IASTFunction createFunctionASTNode(Declarator declarator, boolean nested) throws ASTSemanticException
    {
        try
        {
            return astFactory.createFunction(
                scope,
            	nested ? declarator.getOwnedDeclarator().getNameDuple() : declarator.getNameDuple(),
                createParameterList(declarator.getParameters()),
                astFactory.createAbstractDeclaration(
                    constt,
            		volatil,
                    getTypeSpecifier(),
                    declarator.getPointerOperators(), declarator.getArrayModifiers(), null, null),
                declarator.getExceptionSpecification(),
                inline,
                friend,
                staticc,
                startingOffset,
                declarator.getNameStartOffset(),
                declarator.getNameEndOffset(),
            templateDeclaration,
            declarator.isConst(),
            declarator.isVolatile(),
            virtual,
            explicit,
            declarator.isPureVirtual(),
            declarator.getConstructorMemberInitializers(), declarator.hasFunctionBody(), declarator.hasFunctionTryBlock(), 
			declarator.isVarArgs() );
        }
        catch (ASTSemanticException e)
        {
            throw e;
        }
        catch (Exception e)
        {
            throw new ASTSemanticException();
        }
    }
    /**
     * @param declarator
     * @return
     */
    private IASTField createFieldASTNode(Declarator declarator, boolean nested) throws ASTSemanticException
    {
        try
        {
            return astFactory.createField(
                scope,
            	nested ? declarator.getOwnedDeclarator().getName() : declarator.getName(),
                auto,
                declarator.getInitializerClause(),
                declarator.getBitFieldExpression(),
                astFactory.createAbstractDeclaration(
                    constt,
            		volatil,
                    getTypeSpecifier(),
                    declarator.getPointerOperators(), declarator.getArrayModifiers(), null, null),
                mutable,
                extern,
                register,
                staticc,
                startingOffset,
                declarator.getNameStartOffset(),
            	declarator.getNameEndOffset(), declarator.getConstructorExpression(), ((IASTClassSpecifier)scope).getCurrentVisibilityMode());
        }
        catch (ASTSemanticException e)
        {
            throw e;
        }
        catch (Exception e)
        {
            throw new ASTSemanticException();
        }
    }
    private List createParameterList(List currentParameters) throws ASTSemanticException
    {
        List result = new ArrayList();
        Iterator i = currentParameters.iterator();
        while (i.hasNext())
        {
            DeclarationWrapper wrapper = (DeclarationWrapper)i.next();
            Iterator j = wrapper.getDeclarators();
            while (j.hasNext())
            {
                Declarator declarator = (Declarator)j.next();
                try
                {
                    result.add(
                        astFactory.createParameterDeclaration(
                            wrapper.isConst(),
                            wrapper.isVolatile(),
                            wrapper.getTypeSpecifier(),
                            declarator.getPointerOperators(),
                            declarator.getArrayModifiers(),
                            null, null, declarator.getName() == null
                                            ? ""
                                            : declarator.getName(), declarator.getInitializerClause(), wrapper.getStartingOffset(), declarator.getNameStartOffset(), declarator.getNameEndOffset(), wrapper.getEndOffset()));
                }
                catch (Exception e)
                {
                    throw new ASTSemanticException();
                }
            }
        }
        return result;
    }
    /**
     * @param declarator
     * @return
     */
    private IASTVariable createVariableASTNode(Declarator declarator, boolean nested ) throws ASTSemanticException
    {
        try
        {
            return astFactory.createVariable(
                scope,
            	nested ? declarator.getOwnedDeclarator().getName() : declarator.getName(),
                isAuto(),
                declarator.getInitializerClause(),
                declarator.getBitFieldExpression(),
                astFactory.createAbstractDeclaration(
                    constt,
                    volatil,
                    getTypeSpecifier(),
                    declarator.getPointerOperators(), declarator.getArrayModifiers(), null, null),
                mutable,
                extern,
                register,
                staticc,
                getStartingOffset(),
                declarator.getNameStartOffset(), declarator.getNameEndOffset(), declarator.getConstructorExpression());
        }
        catch (ASTSemanticException e)
        {
            throw e;
        }
        catch (Exception e)
        {
            throw new ASTSemanticException();
        }
    }        
    
    /* (non-Javadoc)
     * @see org.eclipse.cdt.internal.core.parser.IDeclaratorOwner#getDeclarationWrapper()
     */
    public DeclarationWrapper getDeclarationWrapper()
    {
        return this;
    }
    /**
     * @return
     */
    public boolean isUnsigned()
    {
        return isUnsigned;
    }
    /**
     * @return
     */
    public boolean isSigned()
    {
        return isSigned;
    }
    /**
     * @return
     */
    public boolean isShort()
    {
        return isShort;
    }
    /**
     * @return
     */
    public boolean isLong()
    {
        return isLong;
    }
    /**
     * @param b
     */
    public void setLong(boolean b)
    {
        isLong = b;
    }
    /**
     * @param b
     */
    public void setShort(boolean b)
    {
        isShort = b;
    }
    /**
     * @param b
     */
    public void setSigned(boolean b)
    {
        isSigned = b;
    }
    /**
     * @param b
     */
    public void setUnsigned(boolean b)
    {
        isUnsigned = b;
    }
    /**
     * @return
     */
    public Type getSimpleType()
    {
        return simpleType;
    }
    /**
     * @param type
     */
    public void setSimpleType(Type type)
    {
        simpleType = type;
    }
    /**
     * @param duple
     */
    public void setTypeName(ITokenDuple duple)
    {
        name = duple;
    }
    /**
     * @return
     */
    public ITokenDuple getName()
    {
        return name;
    }
    /**
     * @param duple
     */
    public void setName(ITokenDuple duple)
    {
        name = duple;
    }
    /**
     * @return
     */
    public IASTTemplate getOwnerTemplate()
    {
        return templateDeclaration;
    }
    /**
     * @param i
     */
    public void setEndingOffset(int i)
    {
        endOffset = i;
    }
    /**
     * @return
     */
    public int getEndOffset()
    {
        return endOffset;
    }
    /**
     * @param b
     */
    public void setRestrict(boolean b)
    {
        restrict = b;
    }
    

    /**
     * @return
     */
    public boolean isRestrict()
    {
        return restrict;
    }
    /**
     * @param b
     */
    public void setImaginary(boolean b)
    {
        imaginary = b;
    }

    /**
     * @return
     */
    public boolean isComplex()
    {
        return complex;
    }

    /**
     * @return
     */
    public boolean isImaginary()
    {
        return imaginary;
    }

    /**
     * @param b
     */
    public void setComplex(boolean b)
    {
        complex = b;
    }
}