/**********************************************************************
 * Copyright (c) 2006,2007 IBM Corporation.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.ptp.pldt.openmp.analysis;

import java.util.Set;
import java.util.Stack;

import org.eclipse.cdt.core.dom.CDOM;
import org.eclipse.cdt.core.dom.IASTServiceProvider;
import org.eclipse.cdt.core.dom.ast.IASTNode;
import org.eclipse.cdt.core.dom.ast.IASTPreprocessorStatement;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.core.resources.IFile;
import org.eclipse.jface.text.IDocument;
import org.eclipse.ptp.pldt.common.util.Utility;
import org.eclipse.ptp.pldt.openmp.analysis.PAST.PASTElif;
import org.eclipse.ptp.pldt.openmp.analysis.PAST.PASTElse;
import org.eclipse.ptp.pldt.openmp.analysis.PAST.PASTEndif;
import org.eclipse.ptp.pldt.openmp.analysis.PAST.PASTFactory;
import org.eclipse.ptp.pldt.openmp.analysis.PAST.PASTIf;
import org.eclipse.ptp.pldt.openmp.analysis.PAST.PASTIfdef;
import org.eclipse.ptp.pldt.openmp.analysis.PAST.PASTIfndef;
import org.eclipse.ptp.pldt.openmp.analysis.PAST.PASTNode;
import org.eclipse.ptp.pldt.openmp.analysis.PAST.PASTOMPFactory;
import org.eclipse.ptp.pldt.openmp.analysis.PAST.PASTOMPPragma;
import org.eclipse.ptp.pldt.openmp.analysis.PAST.PASTPragma;
import org.eclipse.ptp.pldt.openmp.analysis.dictionary.Dictionary;
import org.eclipse.ptp.pldt.openmp.analysis.dictionary.DictionaryFactory;
import org.eclipse.ptp.pldt.openmp.analysis.ompcfg.factory.FileConcurrencyAnalysis;
import org.eclipse.ptp.pldt.openmp.analysis.ompcfg.factory.FileStatementMap;
import org.eclipse.ptp.pldt.openmp.analysis.ompcfg.factory.FunctionConcurrencyAnalysis;

/**
 * @author pazel
 */
public class OpenMPAnalysisManager 
{
	protected IASTTranslationUnit         astTransUnit_ = null;
	protected IFile                       iFile_        = null;
	protected PASTNode []                 past_         = null;
    protected PASTOMPPragma []            ompPragmas_   = null; 
    
    protected FileConcurrencyAnalysis     fileAnalysis_ = null;
    protected FunctionConcurrencyAnalysis   [] analyses_     = null;
    
    protected FileStatementMap            fileMap_      = null;
	private static final boolean          traceOn       = false;
    
    protected Dictionary                  dictionary_   = null;
    protected OpenMPErrorManager          errorManager_ = new OpenMPErrorManager();
    
        protected static OpenMPAnalysisManager   currentManager_ = null;
    

    /**
     * Constructor called by eclipse
     * @param file
     * @throws OpenMPAnalysisException
     */
	public OpenMPAnalysisManager(final IFile iFile) throws OpenMPAnalysisException
	{
		try {
	       astTransUnit_ = CDOM.getInstance().getASTService().getTranslationUnit(iFile, 
			   CDOM.getInstance().getCodeReaderFactory(CDOM.PARSE_SAVED_RESOURCES));
		}
		catch(IASTServiceProvider.UnsupportedDialectException e) {
		  throw new OpenMPAnalysisException(e.toString());	
		}
		iFile_ = iFile;
        init();
        
        currentManager_ = this;
    }
    
    /**
     * Constructor used by testing mechanism
     * @param astTransUnit
     */
    public OpenMPAnalysisManager(IASTTranslationUnit astTransUnit, IFile iFile)
    {
        astTransUnit_ = astTransUnit;
        iFile_    = iFile;
        init();
        currentManager_ = this;
    }
    
    /**
     * Get the last analysis manager built
     * @return OpenMPAnalysisManager
     */
    public static OpenMPAnalysisManager getCurrentManager()
    {
        return currentManager_;
    }
    
    /**
     * main logic invoked by both constructors
     *
     */
    private void init()
    {
        // Note: throughout all this, it is best to use the same AST instance, i.e.
        //       don't re-gen it, as references to nodes may be made by various components
        //       that should hold up under equality.
        buildPreprocessorAST();
        
        buildDictionary();
        
        buildOMPPragmas();
        
        buildOMPConcurrencyAnalysis();
        
        buildFileMap();
        
        //buildDomoCDT();
    }
	
    /**
     * Build all the nodes, compute which compiled
     *
     */
	private void buildPreprocessorAST()
	{
        IASTPreprocessorStatement[] plist = astTransUnit_.getAllPreprocessorStatements();
        
        past_ = new PASTNode[plist.length];
        
        for(int i=0; i<plist.length; i++) 
          past_[i] = PASTFactory.PASTFactoryMake(plist[i]);	
        
        // Set the compiled flags to show live and dead preprocessor statements
        computeCompiled();
        
	}
    
    /**
     * Build the "variable" dictionary
     *
     */
    private void buildDictionary()
    {
        dictionary_ = DictionaryFactory.buildDictionary(astTransUnit_);
    }
    
//    private void buildDomoCDT()
//    {
//        CDTTranslateToCAst ctrans = new CDTAST2CAstTranslator(new IASTNodeFactory_c());
//        CAstEntity entity = ctrans.translate(astTransUnit_);
//
//        PrintWriter printWriter= new PrintWriter(System.out);
//
//        CAstPrinter.printTo(entity, printWriter);
//        printWriter.flush();
//
//    }
    
    /**
     * Build the OMP style pragmas
     *
     */
    private void buildOMPPragmas()
    {
        int        pCount   = 0;
        IDocument  pragmaDoc = null;
        String     filename  = "";
        
        for(int i=0; i<past_.length; i++) {
           if (past_[i] instanceof PASTPragma) {
               PASTPragma pragma = (PASTPragma)past_[i];
               //
               // For each of these, get the content
               //
               String newFileName = ((PASTPragma)past_[i]).getContainingFilename();
               if (!filename.equals(newFileName)) {
                   filename = newFileName;
                   pragmaDoc = Utility.getDocument(filename);
               }
               if (pragmaDoc!=null) {
                   try {
                     String content = pragmaDoc.get(pragma.getLocalOffset(), pragma.getLength());
                     pragma.setContent(content);
                   }
                   catch(Exception e) {}
               }
               
               past_[i] = PASTOMPFactory.makePASTOMP((PASTPragma)past_[i], astTransUnit_, dictionary_);
               // if successful, would be an omp
               if (past_[i] instanceof PASTOMPPragma)
                 pCount++;
           }
        }
        
        // build the pragma list
        int  index = 0;
        ompPragmas_ = new PASTOMPPragma[pCount];
        for(int i=0; i<past_.length; i++) {
            if (past_[i] instanceof PASTOMPPragma) 
                ompPragmas_[index++] = (PASTOMPPragma)past_[i];
        }
        
        if(traceOn)printPASTResults();
    }
    
    /**
     * Build concurrency analysis
     *
     */
    private void buildOMPConcurrencyAnalysis()
    {
        fileAnalysis_ = new FileConcurrencyAnalysis(astTransUnit_,
                                                    iFile_,
                                                    getOMPPragmas());
        /*DefVisitor dv = new DefVisitor(astTransUnit_, iFile_, getOMPPragmas());
        analyses_ = dv.buildAnalyses();
        
        // build the phase analysis
        for(int i=0; i<analyses_.length; i++) {
            FunctionConcurrencyAnalysis oca = analyses_[i];
            oca.doPhaseAnalysis();
            if (traceOn) oca.printAnalysis(System.out);
        }*/
    }

    /**
     * Build the location-->stmt/expr map
     *
     */
    protected void buildFileMap()
    {
        // Note - important that we use SAME AST for all analysis and lookup
        fileMap_ = new FileStatementMap(astTransUnit_); 
        fileMap_.buildMap();
    }
    
    /**
     * Get the pragma AST tree
     * @return PASTNode []
     */
    public PASTNode [] getPAST()
    {
        return past_;
    }
    
    /**
     * Return a list of PASTOMPPragmas
     * @return
     */
    public PASTOMPPragma [] getOMPPragmas()
    {
        return ompPragmas_;
    }
    
    /**
     * Return IASTTranslationUnit
     * @return IASTTranslationUnit
     */
    public IASTTranslationUnit getTU()
    {
        return astTransUnit_;
    }
    
    /**
     * Accessor to the file map for analyzed file
     * @return FileStatementMap
     */
    public FileStatementMap getFileMap()
    {
        return fileMap_;
    }
    
    /**
     * Get the analysis for each function
     * @return FunctionConcurrencyAnalysis []
     */
    public FunctionConcurrencyAnalysis [] getAnalyses() 
    { return analyses_; }
    
    
    /**
     * Get all nodes concurrent to given node
     * @param node - IASTNode
     * @return Set
     */
    public Set getNodesConcurrentTo(IASTNode node)
    {
        return fileAnalysis_.getNodesConcurrentTo(node);
    }
   
    /**
     * Prints out results for debugging
     *
     */
    protected void printPASTResults()
    {
        // output the results
        for(int i=0; i<past_.length; i++) {
            System.out.print(past_[i].getType()+" "+(past_[i].isCompiled() ? "compiled": "not compiled"));
            System.out.print(" at ("+ past_[i].getFilename()+","+past_[i].getStartingLine()+","+
                    past_[i].getStartLocation()+","+past_[i].getEndLocation()+") ");
            if (past_[i] instanceof PASTOMPPragma) {
                int t = ((PASTOMPPragma)past_[i]).getOMPType();
                System.out.println(" OMPPragma type="+t);
            }
            else System.out.println("");
        }
    }
	
    /**
     * Compute which statements compiled
     *
     */
	private void computeCompiled()
	{
		Stack   context = new Stack();
        boolean currentEvaluation = true;
        int     currentLevel      = 0;
        int     lastNonIgnoredIf  = currentLevel;
		context.push(new CompiledContext(currentLevel, currentEvaluation));
        
        int   ifcount=0;
        int   endifcount=0;

        int i=0;
        for(i=0; i<past_.length; i++) {
        	PASTNode node = past_[i];
        	if(node==null){
        		int stopHere=0;
        	}
        	if (currentEvaluation) {
        		if (isIf(node)) {
        			currentEvaluation = ifDecision(node);
        			currentLevel++;  lastNonIgnoredIf++;
        			context.push(new CompiledContext(currentLevel, currentEvaluation));
                    ifcount++;
        		}
        		else if (isElse(node)) {
       				currentEvaluation = false;
                    if (context.empty())  break;
      				((CompiledContext)(context.peek())).setEvaluation(currentEvaluation);
        		}
                else if (isElseif(node)) {
                    CompiledContext cc = ((CompiledContext)(context.peek()));
                    cc.setWasTrue(true);
                    currentEvaluation = false;
                    // Don't bump the level
                    cc.setEvaluation(false);
                }
        		else if (isEnd(node)) {
                    if (context.empty()) break;
      				context.pop();
       				currentLevel--;  lastNonIgnoredIf--;
                    if (context.empty())  break;
       				currentEvaluation = ((CompiledContext)(context.peek())).getEvaluation();
                    endifcount++;
        		}
        		node.setCompiled(true);
        	}
        	else { // current evaluation == false
        		if (currentLevel==lastNonIgnoredIf) {
                    if (isIf(node)) {
                        currentLevel++;
                        node.setCompiled(false);
                        ifcount++;
                    }
                    else if (isElse(node)) {
                        CompiledContext cc = ((CompiledContext)(context.peek()));
                        if (cc.wasTrue())
                            currentEvaluation = false;
                        else
        				  currentEvaluation = true;
                        if (context.empty()) break;
        				((CompiledContext)(context.peek())).setEvaluation(currentEvaluation);
                        node.setCompiled(true);  // means was not ignored - had effect
        			}
                    else if (isElseif(node)) {
                        CompiledContext cc = ((CompiledContext)(context.peek()));
                        if (cc.wasTrue())
                          currentEvaluation = false;
                        else {
                          currentEvaluation = ifDecision(node);
                          if (currentEvaluation) cc.setWasTrue(true);
                        }
                        // Don't bump the level
                        cc.setEvaluation(currentEvaluation);
                    }
        			else if (isEnd(node)) {
        				context.pop();
        				currentLevel--;  lastNonIgnoredIf--;
                        if (context.empty()) break;
        				currentEvaluation = ((CompiledContext)(context.peek())).getEvaluation();
                        node.setCompiled(currentEvaluation);
                        endifcount++;
        			}
                    else
            		  node.setCompiled(false);
        		}
                else {
                	if (isIf(node)) {
                		currentLevel++;
                		ifcount++;
                	}
                	else if (isEnd(node)) {
                        currentLevel--;
                        endifcount++;
                    }
                    node.setCompiled(false);
                }
        	}

        }
	}
	
    /**
     * Determine if node is a branch
     * @param node
     * @return
     */
	private boolean isIf(PASTNode node)
	{
		return (node instanceof PASTIf) || (node instanceof PASTIfdef) || (node instanceof PASTIfndef);
	}
	
    /**
     * Retrieve the compile decision of the 'if' condition
     * @param node
     * @return
     */
	private boolean ifDecision(PASTNode node)
	{
		if (node instanceof PASTIf) return ((PASTIf)node).taken();
		else if (node instanceof PASTIfdef) return ((PASTIfdef)node).taken();
		else if (node instanceof PASTIfndef) return ((PASTIfndef)node).taken();
		else
			return false;
	}
	
    /**
     * Determine if the node is of 'else' kind
     * @param node
     * @return
     */
	private boolean isElse(PASTNode node)
	{
		return (node instanceof PASTElse);
	}
    
    /**
     * Determine if the node is of 'elseif' kind
     * @param node
     * @return
     */
    private boolean isElseif(PASTNode node)
    {
        return (node instanceof PASTElif);
    }
	
    /**
     * Determine if node is of 'end' kind
     * @param node
     * @return
     */
	private boolean isEnd(PASTNode node)
	{
		return (node instanceof PASTEndif);
	}
	
	
    /**
    * Stack object used for evaluating "compiled" state of PP's
    */
	private static class CompiledContext
	{
		private boolean evaluation_  = false;
		private int     nestedLevel_ = 0;
        private boolean wasTrue_     = false;  // used for elif situations
		
		public CompiledContext(int nestedLevel, boolean evaluation)
		{
			evaluation_  = evaluation;
			nestedLevel_ = nestedLevel;
		}
		
		public boolean getEvaluation()
		{
			return evaluation_;
		}
		
		public void setEvaluation(boolean evaluation)
		{
			evaluation_ = evaluation;
		}
		
		public int getNestedLevel()
		{
			return nestedLevel_;
		}
        
        public boolean wasTrue()              { return wasTrue_; }
        public void    setWasTrue(boolean tf) { wasTrue_=tf; }
	}
}