/*
 * Copyright (c) 2003 The Visigoth Software Society. All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions 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.
 *
 * 3. The end-user documentation included with the redistribution, if
 *    any, must include the following acknowledgement:
 *       "This product includes software developed by the
 *        Visigoth Software Society (http://www.visigoths.org/)."
 *    Alternately, this acknowledgement may appear in the software itself,
 *    if and wherever such third-party acknowledgements normally appear.
 *
 * 4. Neither the name "FreeMarker", "Visigoth", nor any of the names of the
 *    project contributors may be used to endorse or promote products derived
 *    from this software without prior written permission. For written
 *    permission, please contact visigoths@visigoths.org.
 *
 * 5. Products derived from this software may not be called "FreeMarker" or "Visigoth"
 *    nor may "FreeMarker" or "Visigoth" appear in their names
 *    without prior written permission of the Visigoth Software Society.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE VISIGOTH SOFTWARE SOCIETY OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Visigoth Software Society. For more
 * information on the Visigoth Software Society, please see
 * http://www.visigoths.org/
 */

package freemarker.core;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import freemarker.core.DateBuiltins.iso_BI;
import freemarker.core.DateBuiltins.iso_tz_BI;
import freemarker.core.NodeBuiltins.ancestorsBI;
import freemarker.core.NodeBuiltins.childrenBI;
import freemarker.core.NodeBuiltins.node_nameBI;
import freemarker.core.NodeBuiltins.node_namespaceBI;
import freemarker.core.NodeBuiltins.node_typeBI;
import freemarker.core.NodeBuiltins.parentBI;
import freemarker.core.NodeBuiltins.rootBI;
import freemarker.core.NumericalBuiltins.absBI;
import freemarker.core.NumericalBuiltins.byteBI;
import freemarker.core.NumericalBuiltins.ceilingBI;
import freemarker.core.NumericalBuiltins.doubleBI;
import freemarker.core.NumericalBuiltins.floatBI;
import freemarker.core.NumericalBuiltins.floorBI;
import freemarker.core.NumericalBuiltins.intBI;
import freemarker.core.NumericalBuiltins.is_infiniteBI;
import freemarker.core.NumericalBuiltins.is_nanBI;
import freemarker.core.NumericalBuiltins.longBI;
import freemarker.core.NumericalBuiltins.number_to_dateBI;
import freemarker.core.NumericalBuiltins.roundBI;
import freemarker.core.NumericalBuiltins.shortBI;
import freemarker.core.SequenceBuiltins.chunkBI;
import freemarker.core.SequenceBuiltins.firstBI;
import freemarker.core.SequenceBuiltins.lastBI;
import freemarker.core.SequenceBuiltins.reverseBI;
import freemarker.core.SequenceBuiltins.seq_containsBI;
import freemarker.core.SequenceBuiltins.seq_index_ofBI;
import freemarker.core.SequenceBuiltins.sortBI;
import freemarker.core.SequenceBuiltins.sort_byBI;
import freemarker.core.StringBuiltins.cap_firstBI;
import freemarker.core.StringBuiltins.capitalizeBI;
import freemarker.core.StringBuiltins.chop_linebreakBI;
import freemarker.core.StringBuiltins.evalBI;
import freemarker.core.StringBuiltins.j_stringBI;
import freemarker.core.StringBuiltins.js_stringBI;
import freemarker.core.StringBuiltins.json_stringBI;
import freemarker.core.StringBuiltins.lower_caseBI;
import freemarker.core.StringBuiltins.numberBI;
import freemarker.core.StringBuiltins.substringBI;
import freemarker.core.StringBuiltins.uncap_firstBI;
import freemarker.core.StringBuiltins.upper_caseBI;
import freemarker.core.StringBuiltins.word_listBI;
import freemarker.log.Logger;
import freemarker.template.Configuration;
import freemarker.template.TemplateDateModel;
import freemarker.template.TemplateModel;
import freemarker.template.TemplateModelException;
import freemarker.template.TemplateNumberModel;
import freemarker.template.TemplateScalarModel;
import freemarker.template.utility.DateUtil;
import freemarker.template.utility.StringUtil;

/**
 * The {@code ?} operator used for things like {@code foo?upper_case}.
 * @author <a href="mailto:jon@revusky.com">Jonathan Revusky</a>
 */
abstract class BuiltIn extends Expression implements Cloneable {
    
    private static final Logger logger = Logger.getLogger("freemarker.runtime");
    
    protected Expression target;
    protected String key;

    static final HashMap builtins = new HashMap();
    static {
        builtins.put("abs", new absBI());
        builtins.put("ancestors", new ancestorsBI());
        builtins.put("byte", new byteBI());
        builtins.put("c", new MiscellaneousBuiltins.cBI());
        builtins.put("cap_first", new cap_firstBI());
        builtins.put("capitalize", new capitalizeBI());
        builtins.put("ceiling", new ceilingBI());
        builtins.put("children", new childrenBI());
        builtins.put("chop_linebreak", new chop_linebreakBI());
        builtins.put("contains", new StringBuiltins.containsBI());        
        builtins.put("date", new MiscellaneousBuiltins.dateBI(TemplateDateModel.DATE));
        builtins.put("datetime", new MiscellaneousBuiltins.dateBI(TemplateDateModel.DATETIME));
        builtins.put("default", new ExistenceBuiltins.defaultBI());
        builtins.put("double", new doubleBI());
        builtins.put("ends_with", new StringBuiltins.ends_withBI());
        builtins.put("eval", new evalBI());
        builtins.put("exists", new ExistenceBuiltins.existsBI());
        builtins.put("first", new firstBI());
        builtins.put("float", new floatBI());
        builtins.put("floor", new floorBI());
        builtins.put("chunk", new chunkBI());
        builtins.put("has_content", new ExistenceBuiltins.has_contentBI());
        builtins.put("html", new StringBuiltins.htmlBI());
        builtins.put("if_exists", new ExistenceBuiltins.if_existsBI());
        builtins.put("index_of", new StringBuiltins.index_ofBI(false));
        builtins.put("int", new intBI());
        builtins.put("interpret", new Interpret());
        builtins.put("is_boolean", new MiscellaneousBuiltins.is_booleanBI());
        builtins.put("is_collection", new MiscellaneousBuiltins.is_collectionBI());
        builtins.put("is_date", new MiscellaneousBuiltins.is_dateBI());
        builtins.put("is_directive", new MiscellaneousBuiltins.is_directiveBI());
        builtins.put("is_enumerable", new MiscellaneousBuiltins.is_enumerableBI());
        builtins.put("is_hash_ex", new MiscellaneousBuiltins.is_hash_exBI());
        builtins.put("is_hash", new MiscellaneousBuiltins.is_hashBI());
        builtins.put("is_infinite", new is_infiniteBI());
        builtins.put("is_indexable", new MiscellaneousBuiltins.is_indexableBI());
        builtins.put("is_macro", new MiscellaneousBuiltins.is_macroBI());
        builtins.put("is_method", new MiscellaneousBuiltins.is_methodBI());
        builtins.put("is_nan", new is_nanBI());
        builtins.put("is_node", new MiscellaneousBuiltins.is_nodeBI());
        builtins.put("is_number", new MiscellaneousBuiltins.is_numberBI());
        builtins.put("is_sequence", new MiscellaneousBuiltins.is_sequenceBI());
        builtins.put("is_string", new MiscellaneousBuiltins.is_stringBI());
        builtins.put("is_transform", new MiscellaneousBuiltins.is_transformBI());
        builtins.put("iso_utc", new iso_tz_BI(
                /* showOffset = */ true, DateUtil.ACCURACY_SECONDS, /* useUTC = */ true));
        builtins.put("iso_utc_nz", new iso_tz_BI(
                /* showOffset = */ false, DateUtil.ACCURACY_SECONDS, /* useUTC = */ true));
        builtins.put("iso_utc_ms", new iso_tz_BI(
                /* showOffset = */ true, DateUtil.ACCURACY_MILLISECONDS, /* useUTC = */ true));
        builtins.put("iso_utc_ms_nz", new iso_tz_BI(
                /* showOffset = */ false, DateUtil.ACCURACY_MILLISECONDS, /* useUTC = */ true));
        builtins.put("iso_utc_m", new iso_tz_BI(
                /* showOffset = */ true, DateUtil.ACCURACY_MINUTES, /* useUTC = */ true));
        builtins.put("iso_utc_m_nz", new iso_tz_BI(
                /* showOffset = */ false, DateUtil.ACCURACY_MINUTES, /* useUTC = */ true));
        builtins.put("iso_utc_h", new iso_tz_BI(
                /* showOffset = */ true, DateUtil.ACCURACY_HOURS, /* useUTC = */ true));
        builtins.put("iso_utc_h_nz", new iso_tz_BI(
                /* showOffset = */ false, DateUtil.ACCURACY_HOURS, /* useUTC = */ true));
        builtins.put("iso_local", new iso_tz_BI(
                /* showOffset = */ true, DateUtil.ACCURACY_SECONDS, /* useUTC = */ false));
        builtins.put("iso_local_nz", new iso_tz_BI(
                /* showOffset = */ false, DateUtil.ACCURACY_SECONDS, /* useUTC = */ false));
        builtins.put("iso_local_ms", new iso_tz_BI(
                /* showOffset = */ true, DateUtil.ACCURACY_MILLISECONDS, /* useUTC = */ false));
        builtins.put("iso_local_ms_nz", new iso_tz_BI(
                /* showOffset = */ false, DateUtil.ACCURACY_MILLISECONDS, /* useUTC = */ false));
        builtins.put("iso_local_m", new iso_tz_BI(
                /* showOffset = */ true, DateUtil.ACCURACY_MINUTES, /* useUTC = */ false));
        builtins.put("iso_local_m_nz", new iso_tz_BI(
                /* showOffset = */ false, DateUtil.ACCURACY_MINUTES, /* useUTC = */ false));
        builtins.put("iso_local_h", new iso_tz_BI(
                /* showOffset = */ true, DateUtil.ACCURACY_HOURS, /* useUTC = */ false));
        builtins.put("iso_local_h_nz", new iso_tz_BI(
                /* showOffset = */ false, DateUtil.ACCURACY_HOURS, /* useUTC = */ false));
        builtins.put("iso", new iso_BI(
                /* showOffset = */ true, DateUtil.ACCURACY_SECONDS));
        builtins.put("iso_nz", new iso_BI(
                /* showOffset = */ false, DateUtil.ACCURACY_SECONDS));
        builtins.put("iso_ms", new iso_BI(
                /* showOffset = */ true, DateUtil.ACCURACY_MILLISECONDS));
        builtins.put("iso_ms_nz", new iso_BI(
                /* showOffset = */ false, DateUtil.ACCURACY_MILLISECONDS));
        builtins.put("iso_m", new iso_BI(
                /* showOffset = */ true, DateUtil.ACCURACY_MINUTES));
        builtins.put("iso_m_nz", new iso_BI(
                /* showOffset = */ false, DateUtil.ACCURACY_MINUTES));
        builtins.put("iso_h", new iso_BI(
                /* showOffset = */ true, DateUtil.ACCURACY_HOURS));
        builtins.put("iso_h_nz", new iso_BI(
                /* showOffset = */ false, DateUtil.ACCURACY_HOURS));
        builtins.put("j_string", new j_stringBI());
        builtins.put("join", new SequenceBuiltins.joinBI());
        builtins.put("js_string", new js_stringBI());
        builtins.put("json_string", new json_stringBI());
        builtins.put("keys", new HashBuiltins.keysBI());
        builtins.put("last_index_of", new StringBuiltins.index_ofBI(true));
        builtins.put("last", new lastBI());
        builtins.put("left_pad", new StringBuiltins.padBI(true));
        builtins.put("length", new StringBuiltins.lengthBI());
        builtins.put("long", new longBI());
        builtins.put("lower_case", new lower_caseBI());
        builtins.put("namespace", new MiscellaneousBuiltins.namespaceBI());
        builtins.put("new", new NewBI());
        builtins.put("node_name", new node_nameBI());
        builtins.put("node_namespace", new node_namespaceBI());
        builtins.put("node_type", new node_typeBI());
        builtins.put("number", new numberBI());
        builtins.put("number_to_date", new number_to_dateBI(TemplateDateModel.DATE));
        builtins.put("number_to_time", new number_to_dateBI(TemplateDateModel.TIME));
        builtins.put("number_to_datetime", new number_to_dateBI(TemplateDateModel.DATETIME));
        builtins.put("parent", new parentBI());
        builtins.put("replace", new StringBuiltins.replaceBI());
        builtins.put("reverse", new reverseBI());
        builtins.put("right_pad", new StringBuiltins.padBI(false));
        builtins.put("root", new rootBI());
        builtins.put("round", new roundBI());
        builtins.put("rtf", new StringBuiltins.rtfBI());
        builtins.put("seq_contains", new seq_containsBI());
        builtins.put("seq_index_of", new seq_index_ofBI(1));
        builtins.put("seq_last_index_of", new seq_index_ofBI(-1));
        builtins.put("short", new shortBI());
        builtins.put("size", new MiscellaneousBuiltins.sizeBI());
        builtins.put("sort_by", new sort_byBI());
        builtins.put("sort", new sortBI());
        builtins.put("split", new StringBuiltins.splitBI());
        builtins.put("starts_with", new StringBuiltins.starts_withBI());
        builtins.put("string", new MiscellaneousBuiltins.stringBI());
        builtins.put("substring", new substringBI());
        builtins.put("time", new MiscellaneousBuiltins.dateBI(TemplateDateModel.TIME));
        builtins.put("trim", new StringBuiltins.trimBI());
        builtins.put("uncap_first", new uncap_firstBI());
        builtins.put("upper_case", new upper_caseBI());
        builtins.put("url", new StringBuiltins.urlBI());
        builtins.put("values", new HashBuiltins.valuesBI());
        builtins.put("web_safe", builtins.get("html"));  // deprecated; use ?html instead
        builtins.put("word_list", new word_listBI());
        builtins.put("xhtml", new StringBuiltins.xhtmlBI());
        builtins.put("xml", new StringBuiltins.xmlBI());
        try {
            Class.forName("java.util.regex.Pattern");
            builtins.put("matches", instantiateBI("freemarker.core._RegexBuiltins$matchesBI"));
            builtins.put("groups", instantiateBI("freemarker.core._RegexBuiltins$groupsBI"));
            builtins.put("replace", instantiateBI("freemarker.core._RegexBuiltins$replace_reBI"));
            builtins.put("split", instantiateBI("freemarker.core._RegexBuiltins$split_reBI"));
        } catch (Exception e) {
            logger.debug("Regular expression built-ins won't be avilable", e);
        }
    }

    private static Object instantiateBI(String className) throws Exception
    {
        return Class.forName(className).newInstance();
    }
    
    static BuiltIn newBuiltIn(int incompatibleImprovements, Expression target, String key) throws ParseException {
        BuiltIn bi = (BuiltIn) builtins.get(key);
        if (bi == null) {
            StringBuffer buf = new StringBuffer(
                    "Unknown built-in: " + StringUtil.jQuote(key) + ". "
                    + "Help (latest version): http://freemarker.org/docs/ref_builtins.html; "
                    + "you're using FreeMarker " + Configuration.getVersion() + ".\n" 
                    + "The alphabetical list of built-ins:");
            List names = new ArrayList(builtins.keySet().size());
            names.addAll(builtins.keySet());
            Collections.sort(names);
            char lastLetter = 0;
            for (Iterator it = names.iterator(); it.hasNext();) {
                String name = (String) it.next();
                char firstChar = name.charAt(0);
                if (firstChar != lastLetter) {
                    lastLetter = firstChar;
                    buf.append('\n');
                }
                buf.append(name);
                
                if (it.hasNext()) {
                    buf.append(", ");
                }
            }
            throw new ParseException(buf.toString(), target);
        }
        
        while (bi instanceof ICIChainMember
                && incompatibleImprovements < ((ICIChainMember) bi).getMinimumICIVersion()) {
            bi = (BuiltIn) ((ICIChainMember) bi).getPreviousICIChainMember();
        }
        
        try {
            bi = (BuiltIn) bi.clone();
        }
        catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
        bi.target = target;
        bi.key = key;
        return bi;
    }

    public String getCanonicalForm() {
        return target.getCanonicalForm() + getNodeTypeSymbol();
    }
    
    String getNodeTypeSymbol() {
        return "?" + key;
    }

    boolean isLiteral() {
        return false; // be on the safe side.
    }
    
    protected final void checkMethodArgCount(List args, int expectedCnt) throws TemplateModelException {
        checkMethodArgCount(args.size(), expectedCnt);
    }
    
    protected final void checkMethodArgCount(int argCnt, int expectedCnt) throws TemplateModelException {
        if (argCnt != expectedCnt) {
            throw MessageUtil.newArgCntError("?" + key, argCnt, expectedCnt);
        }
    }

    protected final void checkMethodArgCount(List args, int minCnt, int maxCnt) throws TemplateModelException {
        checkMethodArgCount(args.size(), minCnt, maxCnt);
    }
    
    protected final void checkMethodArgCount(int argCnt, int minCnt, int maxCnt) throws TemplateModelException {
        if (argCnt < minCnt || argCnt > maxCnt) {
            throw MessageUtil.newArgCntError("?" + key, argCnt, minCnt, maxCnt);
        }
    }

    /**
     * Same as {@link #getStringMethodArg}, but checks if {@code args} is big enough, and returns {@code null} if it
     * isn't.
     */
    protected final String getOptStringMethodArg(List args, int argIdx)
            throws TemplateModelException {
        return args.size() > argIdx ? getStringMethodArg(args, argIdx) : null;
    }
    
    /**
     * Gets a method argument and checks if it's a string; it does NOT check if {@code args} is big enough.
     */
    protected final String getStringMethodArg(List args, int argIdx)
            throws TemplateModelException {
        TemplateModel arg = (TemplateModel) args.get(argIdx);
        if (!(arg instanceof TemplateScalarModel)) {
            throw MessageUtil.newMethodArgMustBeStringException("?" + key, argIdx, arg);
        } else {
            return EvalUtil.modelToString((TemplateScalarModel) arg, null, null);
        }
    }

    /**
     * Gets a method argument and checks if it's a number; it does NOT check if {@code args} is big enough.
     */
    protected final Number getNumberMethodArg(List args, int argIdx)
            throws TemplateModelException {
        TemplateModel arg = (TemplateModel) args.get(argIdx);
        if (!(arg instanceof TemplateNumberModel)) {
            throw MessageUtil.newMethodArgMustBeNumberException("?" + key, argIdx, arg);
        } else {
            return EvalUtil.modelToNumber((TemplateNumberModel) arg, null);
        }
    }
    
    protected final Expression deepCloneWithIdentifierReplaced_inner(
            String replacedIdentifier, Expression replacement, ReplacemenetState replacementState) {
    	try {
	    	BuiltIn clone = (BuiltIn)clone();
	    	clone.target = target.deepCloneWithIdentifierReplaced(replacedIdentifier, replacement, replacementState);
	    	return clone;
        }
        catch (CloneNotSupportedException e) {
            throw new RuntimeException("Internal error: " + e);
        }
    }

    int getParameterCount() {
        return 2;
    }

    Object getParameterValue(int idx) {
        switch (idx) {
        case 0: return target;
        case 1: return key;
        default: throw new IndexOutOfBoundsException();
        }
    }

    ParameterRole getParameterRole(int idx) {
        switch (idx) {
        case 0: return ParameterRole.LEFT_HAND_OPERAND;
        case 1: return ParameterRole.RIGHT_HAND_OPERAND;
        default: throw new IndexOutOfBoundsException();
        }
    }
    
}