/*
 * Copyright (c) 2003-2005 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * - Redistribution of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * - Redistribution in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * Neither the name of Sun Microsystems, Inc. or the names of
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
 * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
 * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
 * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
 * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
 * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
 * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
 * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
 * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that this software is not designed or intended for use
 * in the design, construction, operation or maintenance of any nuclear
 * facility.
 *
 * Sun gratefully acknowledges that this software was originally authored
 * and developed by Kenneth Bradley Russell and Christopher John Kline.
 */
package com.jogamp.gluegen.procaddress;

import static java.util.logging.Level.INFO;

import com.jogamp.gluegen.JavaConfiguration;
import com.jogamp.gluegen.cgram.types.AliasedSymbol;
import com.jogamp.gluegen.cgram.types.FunctionSymbol;

import java.io.*;
import java.text.*;
import java.util.*;

public class ProcAddressConfiguration extends JavaConfiguration {

    private boolean emitProcAddressTable = false;
    private boolean forceProcAddressGen4All = false;

    private String tableClassPackage;
    private String tableClassName = "ProcAddressTable";
    private String getProcAddressTableExpr;
    private String localProcAddressCallingConvention4All = null;

    private ConvNode procAddressNameConverter;
    private final Set<String> skipProcAddressGen = new HashSet<String>();
    private final List<String> forceProcAddressGen = new ArrayList<String>();
    private final Set<String> forceProcAddressGenSet = new HashSet<String>();

    // This is needed only on Windows. Ideally we would modify the
    // HeaderParser and PCPP to automatically pick up the calling
    // convention from the headers
    private final Map<String, String> localProcAddressCallingConventionMap = new HashMap<String, String>();

    @Override
    protected void dispatch(final String cmd, final StringTokenizer tok, final File file, final String filename, final int lineNo) throws IOException {
        if (cmd.equalsIgnoreCase("EmitProcAddressTable")) {
            emitProcAddressTable = readBoolean("EmitProcAddressTable", tok, filename, lineNo).booleanValue();
        } else if (cmd.equalsIgnoreCase("ProcAddressTablePackage")) {
            tableClassPackage = readString("ProcAddressTablePackage", tok, filename, lineNo);
        } else if (cmd.equalsIgnoreCase("ProcAddressTableClassName")) {
            tableClassName = readString("ProcAddressTableClassName", tok, filename, lineNo);
        } else if (cmd.equalsIgnoreCase("SkipProcAddressGen")) {
            final String sym = readString("SkipProcAddressGen", tok, filename, lineNo);
            skipProcAddressGen.add(sym);
        } else if (cmd.equalsIgnoreCase("ForceProcAddressGen")) {
            final String funcName = readString("ForceProcAddressGen", tok, filename, lineNo);
            if (funcName.equals("__ALL__")) {
                forceProcAddressGen4All = true;
            } else {
                addForceProcAddressGen(funcName);
            }
        } else if (cmd.equalsIgnoreCase("GetProcAddressTableExpr")) {
            setProcAddressTableExpr( readGetProcAddressTableExpr(tok, filename, lineNo) );
        } else if (cmd.equalsIgnoreCase("ProcAddressNameExpr")) {
            readProcAddressNameExpr(tok, filename, lineNo);
        } else if (cmd.equalsIgnoreCase("LocalProcAddressCallingConvention")) {
            readLocalProcAddressCallingConvention(tok, filename, lineNo);
        } else {
            super.dispatch(cmd, tok, file, filename, lineNo);
        }
    }

    protected String readGetProcAddressTableExpr(final StringTokenizer tok, final String filename, final int lineNo) {
        try {
            final String restOfLine = tok.nextToken("\n\r\f");
            return restOfLine.trim();
        } catch (final NoSuchElementException e) {
            throw new RuntimeException("Error parsing \"GetProcAddressTableExpr\" command at line " + lineNo
                    + " in file \"" + filename + "\"", e);
        }
    }

    protected void setProcAddressNameExpr(final String expr) {
        // Parse this into something allowing us to map from a function
        // name to the typedef'ed function pointer name
        final List<String> tokens = new ArrayList<String>();
        final StringTokenizer tok1 = new StringTokenizer(expr);
        while (tok1.hasMoreTokens()) {
            final String sstr = tok1.nextToken();
            final StringTokenizer tok2 = new StringTokenizer(sstr, "$()", true);
            while (tok2.hasMoreTokens()) {
                tokens.add(tok2.nextToken());
            }
        }

        // Now that the string is flattened out, convert it to nodes
        procAddressNameConverter = makeConverter(tokens.iterator());
        if (procAddressNameConverter == null) {
            throw new NoSuchElementException("Error creating converter from string");
        }
    }

    protected void readProcAddressNameExpr(final StringTokenizer tok, final String filename, final int lineNo) {
        try {
            String restOfLine = tok.nextToken("\n\r\f");
            restOfLine = restOfLine.trim();
            setProcAddressNameExpr(restOfLine);
        } catch (final NoSuchElementException e) {
            throw new RuntimeException("Error parsing \"ProcAddressNameExpr\" command at line " + lineNo
                    + " in file \"" + filename + "\"", e);
        }
    }

    protected void readLocalProcAddressCallingConvention(final StringTokenizer tok, final String filename, final int lineNo) throws IOException {
        try {
            final String functionName = tok.nextToken();
            final String callingConvention = tok.nextToken();
            if (functionName.equals("__ALL__")) {
                localProcAddressCallingConvention4All = callingConvention;
            } else {
                localProcAddressCallingConventionMap.put(functionName, callingConvention);
            }
        } catch (final NoSuchElementException e) {
            throw new RuntimeException("Error parsing \"LocalProcAddressCallingConvention\" command at line " + lineNo
                    + " in file \"" + filename + "\"", e);
        }
    }

    private static ConvNode makeConverter(final Iterator<String> iter) {
        final List<ConvNode> result = new ArrayList<ConvNode>();

        while (iter.hasNext()) {
            final String str = iter.next();
            if (str.equals("$")) {
                final String command = iter.next();
                final String openParen = iter.next();
                if (!openParen.equals("(")) {
                    throw new NoSuchElementException("Expected \"(\"");
                }
                boolean uppercase = false;
                if (command.equalsIgnoreCase("UPPERCASE")) {
                    uppercase = true;
                } else if (!command.equalsIgnoreCase("LOWERCASE")) {
                    throw new NoSuchElementException("Unknown ProcAddressNameExpr command \"" + command + "\"");
                }
                result.add(new CaseNode(uppercase, makeConverter(iter)));
            } else if (str.equals(")")) {
                // Fall through and return
            } else if (str.indexOf('{') >= 0) {
                result.add(new FormatNode(str));
            } else {
                result.add(new ConstStringNode(str));
            }
        }
        if (result.isEmpty()) {
            return null;
        } else if (result.size() == 1) {
            return result.get(0);
        } else {
            return new ConcatNode(result);
        }
    }

    /** Helper class for converting a function name to the typedef'ed
    function pointer name */
    static abstract class ConvNode {
        abstract String convert(String funcName);
    }

    static class FormatNode extends ConvNode {

        private final MessageFormat msgFmt;

        FormatNode(final String fmt) {
            msgFmt = new MessageFormat(fmt);
        }

        @Override
        String convert(final String funcName) {
            final StringBuffer buf = new StringBuffer();
            msgFmt.format(new Object[]{funcName}, buf, null);
            return buf.toString();
        }
    }

    static class ConstStringNode extends ConvNode {

        private final String str;

        ConstStringNode(final String str) {
            this.str = str;
        }

        @Override
        String convert(final String funcName) {
            return str;
        }
    }

    static class ConcatNode extends ConvNode {

        private final List<ConvNode> children;

        ConcatNode(final List<ConvNode> children) {
            this.children = children;
        }

        @Override
        String convert(final String funcName) {
            final StringBuilder res = new StringBuilder();
            for (final ConvNode node : children) {
                res.append(node.convert(funcName));
            }
            return res.toString();
        }
    }

    static class CaseNode extends ConvNode {

        private final boolean upperCase;
        private final ConvNode child;

        CaseNode(final boolean upperCase, final ConvNode child) {
            this.upperCase = upperCase;
            this.child = child;
        }

        @Override
        public String convert(final String funcName) {
            if (upperCase) {
                return child.convert(funcName).toUpperCase();
            } else {
                return child.convert(funcName).toLowerCase();
            }
        }
    }

    public boolean emitProcAddressTable() {
        return emitProcAddressTable;
    }

    public String tableClassPackage() {
        return tableClassPackage;
    }

    public String tableClassName() {
        return tableClassName;
    }

    public boolean skipProcAddressGen(final FunctionSymbol symbol) {
      if ( skipProcAddressGen.contains( symbol.getName() ) ||
           oneInSet(skipProcAddressGen, symbol.getAliasedNames())
         )
      {
          LOG.log(INFO, symbol.getASTLocusTag(), "Skip ProcAddress: {0}", symbol);
          return true;
      }
      return false;
    }

    public boolean isForceProcAddressGen4All() {
        return forceProcAddressGen4All;
    }

    public List<String> getForceProcAddressGen() {
        return forceProcAddressGen;
    }

    public String getProcAddressTableExpr() {
        if (getProcAddressTableExpr == null) {
            throw new RuntimeException("GetProcAddressTableExpr was not defined in .cfg file");
        }
        return getProcAddressTableExpr;
    }
    protected void setProcAddressTableExpr(final String s) {
        getProcAddressTableExpr = s;
    }

    public String convertToFunctionPointerName(final String funcName) {
        if (procAddressNameConverter == null) {
            throw new RuntimeException("ProcAddressNameExpr was not defined in .cfg file");
        }
        return procAddressNameConverter.convert(funcName);
    }

    public boolean forceProcAddressGen(final FunctionSymbol symbol) {
        if( forceProcAddressGen4All ) {
            if(!forceProcAddressGen4AllOnce) {
                forceProcAddressGen4AllOnce = true;
                LOG.log(INFO, symbol.getASTLocusTag(), "Force ALL ProcAddress");
            }
            return true;
        }

        if ( forceProcAddressGenSet.contains( symbol.getName() ) ||
             oneInSet(forceProcAddressGenSet, symbol.getAliasedNames())
           )
        {
            LOG.log(INFO, symbol.getASTLocusTag(), "Force ProcAddress: {0}", symbol);
            return true;
        }
        return false;
    }
    private static boolean forceProcAddressGen4AllOnce = false;

    public void addForceProcAddressGen(final String funcName) {
        forceProcAddressGen.add(funcName);
        forceProcAddressGenSet.add(funcName);
    }

    public void addLocalProcAddressCallingConvention(final String funcName, final String callingConvention) {
        localProcAddressCallingConventionMap.put(funcName, callingConvention);
    }

    public String getLocalProcAddressCallingConvention(final FunctionSymbol symbol) {
        if ( isLocalProcAddressCallingConvention4All() ) {
            return getLocalProcAddressCallingConvention4All();
        }
        final String res = localProcAddressCallingConventionMap.get(symbol.getName());
        if( null != res ) {
            return res;
        }
        return oneInMap(localProcAddressCallingConventionMap, symbol.getAliasedNames());
    }

    public boolean isLocalProcAddressCallingConvention4All() {
        return localProcAddressCallingConvention4All != null;
    }

    public String getLocalProcAddressCallingConvention4All() {
        return localProcAddressCallingConvention4All;
    }
}