/*******************************************************************************
 * Copyright (c) 2007 University of Illinois at Urbana-Champaign 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:
 *     UIUC - Initial API and implementation
 *******************************************************************************/
package org.eclipse.photran.internal.core.model;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

import org.eclipse.cdt.core.model.CModelException;
import org.eclipse.cdt.core.model.IContributedModelBuilder;
import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.cdt.internal.core.model.Parent;
import org.eclipse.cdt.internal.core.model.TranslationUnit;
import org.eclipse.core.resources.IFile;
import org.eclipse.photran.internal.core.lexer.FixedFormLexerPhase2;
import org.eclipse.photran.internal.core.lexer.FreeFormLexerPhase1;
import org.eclipse.photran.internal.core.lexer.FreeFormLexerPhase2;
import org.eclipse.photran.internal.core.lexer.ILexer;
import org.eclipse.photran.internal.core.lexer.IToken;
import org.eclipse.photran.internal.core.lexer.SimpleToken;
import org.eclipse.photran.internal.core.lexer.SimpleTokenFactory;
import org.eclipse.photran.internal.core.lexer.Terminal;

/**
 * This is a minimal Fortran model builder based only on lexical analysis.  See
 * {@link IFortranModelBuilder}.
 * <p>
 * <i>This is probably <b>not</b> the model builder you are looking for.</i>  Generally, Photran
 * uses a parser-based model builder from the cdtinterface.vpg plug-in instead.  This one is used
 * only if the VPG plug-ins are not available, or if the user specifically chooses to use this
 * model builder instead (in the workspace preferences).
 * <p>
 * Editors can force the model builder to use fixed or free format for a given file by calling
 * {@link #setIsFixedForm(boolean)}.  Otherwise, the format is determined by content type (i.e., by
 * the filename extension and the user's workspace preferences).
 * 
 * @author Jeff Overbey
 *
 * @see IFortranModelBuilder
 * @see IContributedModelBuilder
 */
@SuppressWarnings("restriction")
public class SimpleFortranModelBuilder implements IFortranModelBuilder
{
    private TranslationUnit translationUnit = null;
    private Map newElements = null;
    private boolean isFixedForm = false;

    public void setTranslationUnit(ITranslationUnit tu)
    {
        if (!(tu instanceof ITranslationUnit)) throw new Error("Unexpected subclass of ITranslationUnit");
        
        this.translationUnit = (TranslationUnit)tu;
    }

    public void setIsFixedForm(boolean isFixedForm)
    {
        this.isFixedForm = isFixedForm;
    }

    public void parse(boolean quickParseMode) throws Exception
    {
        this.newElements = new HashMap();
        
        InputStream in = new ByteArrayInputStream(translationUnit.getBuffer().getContents().getBytes());
        String filename = translationUnit.getElementName();
        boolean wasSuccessful = true;

        try
        {
//            FortranElement note = new FortranElement.UnknownNode(translationUnit, isFixedForm ? "<Fixed Form Source>" : "<Free Form Source>");
//            this.addF90Element(note);

              IFile file = translationUnit.getFile();
              ILexer lexer =
                  isFixedForm ? (ILexer)new FixedFormLexerPhase2(in, file, filename, SimpleTokenFactory.getInstance())
                              : (ILexer)new FreeFormLexerPhase2(new FreeFormLexerPhase1(in, file, filename, SimpleTokenFactory.getInstance(), false));

              createSourceFormNode();
              buildModel(lexer);

                
              /* For whatever reason, we have to only set the *parent* while we
               * parse, then go back through (now) and traverse the model in
               * preorder, executing addChild().  This doesn't make any sense,
               * but the "obvious" way of doing it all while parsing (in
               * BuildModelParserAction.java) doesn't work.
               */
              //newElements.putAll(newElts);
              //this.addF90Elements(newElements);
        }
        catch (Exception e)
        {
            createParseFailureNode(translationUnit, e.getMessage());
            wasSuccessful = false;
        }

        // From CDT: important to know if the unit has parse errors or not
        setIsStructureKnown(wasSuccessful);
    }

    public void setIsStructureKnown(boolean isStructureKnown)
    {
        translationUnit.setIsStructureKnown(isStructureKnown);
    }

    private FortranElement createSourceFormNode() throws CModelException
    {
        String sourceForm = isFixedForm ? "<Fixed Form Source>" : "<Free Form Source>";
        FortranElement element = new FortranElement.UnknownNode(translationUnit, sourceForm);
        translationUnit.addChild(element);
        this.newElements.put(element, element.getElementInfo());
        return element;

    }

    private FortranElement createParseFailureNode(Parent parent, String errorMessage)
        throws CModelException
    {

        FortranElement element = new FortranElement.ErrorNode(parent, errorMessage);
        parent.addChild(element);
        this.newElements.put(element, element.getElementInfo());
        return element;

    }

//    private void addF90Elements(Map elts) throws CModelException
//    {
//        // Add all top-level elements (those with no parent) and recurse
//        addF90ElementsFor(null, elts);
//    }
//
//    private void addF90ElementsFor(Parent parent, Map elts) throws CModelException
//    {
//        Iterator it = elts.keySet().iterator();
//        while (it.hasNext())
//        {
//            FortranElement e = (FortranElement)it.next();
//            if (e.getParent() == parent)
//            {
//                e.setIdentifier(e.getIdentifier()); // It seems to forget position info
//                addF90ElementsFor(e, elts);
//            }
//        }
//    }
    
    // --NODE HIERARCHY--------------------------------------------------
    
    private Stack/*<Parent>*/ stack = new Stack/*<Parent>*/();
    
    private Parent currentParent()
    {
        return stack.isEmpty() ? translationUnit : (Parent)stack.peek();
    }
    
    private void startNesting(FortranElement element) throws CModelException
    {
        //System.out.println("Begin " + element.getElementName());
        
        currentParent().addChild(element);
        newElements.put(element, element.getElementInfo());

        stack.add(element);
    }
    
    private void doneNesting()
    {
        //System.out.println("End");
        
        if (!stack.isEmpty()) stack.pop();
    }

    // --STAREMENT ANALYSIS----------------------------------------------
    
    private ArrayList/*<IToken>*/ statement = new ArrayList/*<IToken>*/(64);

    private boolean readStatement(ILexer lexer) throws Exception
    {
        statement.clear();
        IToken tok;
        do
        {
            tok = lexer.yylex();
            statement.add(tok);
        } while (tok.getTerminal() != Terminal.T_EOS && tok.getTerminal() != Terminal.END_OF_INPUT);
        
        return tok.getTerminal() != Terminal.END_OF_INPUT;
    }
    
    private boolean statementStartsWith(Terminal t)
    {
        boolean startsWithLabel = ((IToken)statement.get(0)).getTerminal() == Terminal.T_ICON;
        int firstTokenIndex = startsWithLabel ? 1 : 0;
        return (((IToken)statement.get(firstTokenIndex)).getTerminal() == t);
    }
    
    private boolean statementContains(Terminal t)
    {
        for (int i = 0, length = statement.size(); i < length; i++)
            if (((IToken)statement.get(i)).getTerminal() == t)
                return true;
        
        return false;
    }
    
    private IToken tokenFollowing(Terminal afterTerminal)
    {
        boolean foundToken = (afterTerminal == null);
        
        for (int i = 0, length = statement.size(); i < length; i++)
        {
            IToken thisToken = (IToken)statement.get(i);
            
            if (thisToken.getTerminal() == afterTerminal)
                foundToken = true;
            else if (foundToken)
                return thisToken;
        }
        
        return new SimpleToken(Terminal.T_IDENT, "???");
    }
    
    private IToken firstIdentifierAfter(Terminal afterTerminal)
    {
        return firstIdentifierAfter(afterTerminal, "(anonymous)");
    }
        
    private IToken firstIdentifierAfter(Terminal afterTerminal, String textIfNotFound)
    {
        boolean foundToken = (afterTerminal == null);
        
        for (int i = 0, length = statement.size(); i < length; i++)
        {
            IToken thisToken = (IToken)statement.get(i);
            
            if (thisToken.getTerminal() == afterTerminal)
                foundToken = true;
            else if (foundToken && thisToken.getTerminal() == Terminal.T_IDENT)
                return thisToken;
        }
        
        return new SimpleToken(Terminal.T_IDENT, textIfNotFound);
    }
    
    private boolean isEndStatement()
    {
        if (statementStartsWith(Terminal.T_ENDBLOCK)
         || statementStartsWith(Terminal.T_ENDBLOCKDATA)
         || statementStartsWith(Terminal.T_ENDFUNCTION)
         || statementStartsWith(Terminal.T_ENDINTERFACE)
         || statementStartsWith(Terminal.T_ENDMODULE)
         || statementStartsWith(Terminal.T_ENDPROGRAM)
         || statementStartsWith(Terminal.T_ENDSUBROUTINE))
         //|| statementStartsWith(Terminal.T_ENDTYPE)
         {
            return true;
         }
         else if (statementStartsWith(Terminal.T_END))
         {
             Terminal next = tokenFollowing(Terminal.T_END).getTerminal();
             
             return next == Terminal.T_BLOCK
                 || next == Terminal.T_BLOCKDATA
                 || next == Terminal.T_FUNCTION
                 || next == Terminal.T_INTERFACE
                 || next == Terminal.T_MODULE
                 || next == Terminal.T_PROGRAM
                 || next == Terminal.T_SUBROUTINE;
                 //|| next == Terminal.T_TYPE;
         }
         else return false;
    }

    // --NODE CREATION METHODS-------------------------------------------
    
    private void buildModel(ILexer lexer) throws Exception
    {
        while (readStatement(lexer))
            processStatement();
    }

    private void processStatement() throws CModelException
    {
        if (isEndStatement()) // Make sure this is checked before the check for T_FUNCTION below
            doneNesting();

        else if (statementStartsWith(Terminal.T_PROGRAM))
            startNesting(new FortranElement.MainProgram(currentParent(), firstIdentifierAfter(Terminal.T_PROGRAM)));
        
        else if (statementStartsWith(Terminal.T_MODULE))
            startNesting(new FortranElement.Module(currentParent(), firstIdentifierAfter(Terminal.T_MODULE)));
        
//        else if (statementStartsWith(Terminal.T_TYPE))
//            startNesting(new FortranElement.Module(currentParent(), firstIdentifierAfter(Terminal.T_MODULE)));
        
        else if (statementContains(Terminal.T_FUNCTION))
            startNesting(new FortranElement.Function(currentParent(), firstIdentifierAfter(Terminal.T_FUNCTION)));
        
        else if (statementStartsWith(Terminal.T_SUBROUTINE))
            startNesting(new FortranElement.Subroutine(currentParent(), firstIdentifierAfter(Terminal.T_SUBROUTINE)));
        
        else if (statementStartsWith(Terminal.T_INTERFACE))
            startNesting(new FortranElement.Interface(currentParent(), firstIdentifierAfter(Terminal.T_INTERFACE, "(Interface Block)")));
        
        else if (statementStartsWith(Terminal.T_BLOCK))
            startNesting(new FortranElement.BlockData(currentParent(), firstIdentifierAfter(Terminal.T_BLOCK)));
        else if (statementStartsWith(Terminal.T_BLOCKDATA))
            startNesting(new FortranElement.BlockData(currentParent(), firstIdentifierAfter(Terminal.T_BLOCKDATA)));
    }
}