// Copyright 2004 Adam Megacz, see the COPYING file for licensing [GPL]
package org.xwt;

import java.io.*;
import java.util.zip.*;
import java.util.*;
import java.lang.*;
import org.xwt.js.*;
import org.xwt.translators.*;
import org.xwt.util.*;

/**
 *  Encapsulates a template node (the <template/> element of a
 *  .xwt file, or any child element thereof).
 *
 *  Note that the Template instance corresponding to the
 *  <template/> node carries all the header information -- hence
 *  some of the instance members are not meaningful on non-root
 *  Template instances. We refer to these non-root instances as
 *  <i>anonymous templates</i>.
 *
 *  See the XWT reference for information on the order in which
 *  templates are applied, attributes are put, and scripts are run.
 */
public class Template {

    // Instance Members ///////////////////////////////////////////////////////

    String id = null;                   ///< the id of this box
    String redirect = null;             ///< the id of the redirect target; only meaningful on a root node
    private String[] keys;              ///< keys to be "put" to instances of this template; elements correspond to those of vals
    private Object[] vals;              ///< values to be "put" to instances of this template; elements correspond to those of keys
    private Vec children = new Vec();   ///< during XML parsing, this holds the list of currently-parsed children; null otherwise
    private JS script = null;           ///< the script on this node
    private String tagname = null;      ///< template to preapply (if any)


    // Instance Members that are only meaningful on root Template //////////////////////////////////////

    private JSScope staticScope = null;   ///< the scope in which the static block is executed
    private JS staticscript = null;       ///< the script on the static node of this template, null already performed


    // Only used during parsing /////////////////////////////////////////////////////////////////

    private StringBuffer content = null;   ///< during XML parsing, this holds partially-read character data; null otherwise
    private int content_start = 0;         ///< line number of the first line of <tt>content</tt>
    private int startLine = -1;            ///< the line number that this element starts on
    private XWT xwt;


    // Static data/methods ///////////////////////////////////////////////////////////////////

    // for non-root nodes
    private Template(XWT xwt) { this.xwt = xwt; }
    public Template(InputStream is, XWT xwt) throws IOException, JSExn, XML.Exn {
        this.xwt = xwt; new TemplateHelper().parseit(is, this);
    }
    

    // Methods to apply templates ////////////////////////////////////////////////////////

    /** called before this template is applied or its static object can be externally referenced */
    JSScope getStatic() throws JSExn {
        if (staticScope == null) staticScope = new PerInstantiationScope(null, xwt, null, null);
        if (staticscript == null) return staticScope;
        JS temp = staticscript;
        staticscript = null;
        JS.cloneWithNewParentScope(temp, staticScope).call(null, null, null, null, 0);
        return staticScope;
    }
    
    /** Applies the template to Box b
     *  @param pboxes a vector of all box parents on which to put $-references
     *  @param ptemplates a vector of the fileNames to recieve private references on the pboxes
     */
    void apply(Box b) throws JSExn {
        try {
            apply(b, null);
        } catch (IOException e) {
            b.clear(b.VISIBLE);
            b.mark_for_repack();
            Log.warn(this, e);
            throw new JSExn(e.toString());
        } catch (JSExn e) {
            b.clear(b.VISIBLE);
            b.mark_for_repack();
            Log.warn(this, e);
            throw e;
        }
    }

    private void apply(Box b, PerInstantiationScope parentPis) throws JSExn, IOException {
        getStatic();

        // FIXME this dollar stuff is all wrong
        if (id != null) parentPis.putDollar(id, b);
        if (tagname != null) xwt.resolveString(tagname, false).call(b, null, null, null, 1);

        PerInstantiationScope pis = new PerInstantiationScope(b, xwt, parentPis, staticScope);

        // FIXME needs to obey the new application-ordering rules
        for (int i=0; children != null && i<children.size(); i++) {
            Box kid = new Box();
            ((Template)children.elementAt(i)).apply(kid, pis);
            b.putAndTriggerTraps(b.get("numchildren"), kid);
        }

        if (script != null) JS.cloneWithNewParentScope(script, pis).call(null, null, null, null, 0);

        Object key, val;
        for(int i=0; keys != null && i < keys.length; i++) {
            if (keys[i] == null) continue;
            key = keys[i];
            val = vals[i];

            if ("null".equals(val)) val = null;

            if (val != null && val instanceof String && ((String)val).length() > 0) {
                switch (((String)val).charAt(0)) {
                    case '$':
                        val = pis.get(val);
                        if (val == null) throw new JSExn("unknown box id '"+vals[i]+"' referenced in XML attribute");
                        break;
                    case '.':
                        val = xwt.resolveString(((String)val).substring(1), false);
                    // FIXME: url case
                    // FIXME: should we be resolving all of these in the XML-parsing code?
                }
            }

            b.putAndTriggerTraps(key, val);
        }
    }



    // XML Parsing /////////////////////////////////////////////////////////////////

    /** handles XML parsing; builds a Template tree as it goes */
    static final class TemplateHelper extends XML {

        TemplateHelper() { }

        private int state;
        private static final int STATE_INITIAL = 0;
        private static final int STATE_IN_XWT_NODE = 1;
        private static final int STATE_IN_TEMPLATE_NODE = 2;
        private static final int STATE_FINISHED_TEMPLATE_NODE = 3;

        private String nameOfHeaderNodeBeingProcessed;

        Vec nodeStack = new Vec();  ///< stack of Templates whose XML elements we have seen open-tags for but not close-tags
        Template t = null;          ///< the template we're currently working on

        /** parse an XML input stream, building a Template tree off of <tt>root</tt> */
        void parseit(InputStream is, Template root) throws XML.Exn, IOException {
            state = STATE_INITIAL;
            nameOfHeaderNodeBeingProcessed = null;
            nodeStack.setSize(0);
            t = root;
            parse(new InputStreamReader(is)); 
        }

        public void startElement(XML.Element c) throws XML.Exn {
            switch(state) {
            case STATE_INITIAL:
                if (!"xwt".equals(c.getLocalName()))
                    throw new XML.Exn("root element was not <xwt>", XML.Exn.SCHEMA, getLine(), getCol());
                if (c.getAttrLen() != 0)
                    throw new XML.Exn("root element must not have attributes", XML.Exn.SCHEMA, getLine(), getCol());
                state = STATE_IN_XWT_NODE;
                return;

            case STATE_IN_XWT_NODE:
                if (nameOfHeaderNodeBeingProcessed != null)
                    throw new XML.Exn("can't nest header nodes", XML.Exn.SCHEMA, getLine(), getCol());
                nameOfHeaderNodeBeingProcessed = c.getLocalName();
                //#switch(c.getLocalName())
                case "doc":
                    // FEATURE
                    return;
                case "static":
                    if (t.staticscript != null)
                        throw new XML.Exn("the <static> header node may only appear once", XML.Exn.SCHEMA, getLine(), getCol());
                    if (c.getAttrLen() > 0)
                        throw new XML.Exn("the <static> node may not have attributes", XML.Exn.SCHEMA, getLine(), getCol());
                    return;
                case "template":
                    t.startLine = getLine();
                    state = STATE_IN_TEMPLATE_NODE;
                    processBodyElement(c);
                    return;
                //#end
                throw new XML.Exn("unrecognized header node \"" + c.getLocalName() + "\"", XML.Exn.SCHEMA, getLine(), getCol());

            case STATE_IN_TEMPLATE_NODE:
                // push the last node we were in onto the stack
                nodeStack.addElement(t);
                // instantiate a new node, and set its fileName/importlist/preapply
                Template t2 = new Template(t.xwt);
                t2.startLine = getLine();
                if (!c.getLocalName().equals("box") && !c.getLocalName().equals("template"))
                    t2.tagname = ((c.getUri().equals("") ? "" : (c.getUri() + ".")) + c.getLocalName());
                // make the new node the current node
                t = t2;
                processBodyElement(c);
                return;

            case STATE_FINISHED_TEMPLATE_NODE:
                throw new XML.Exn("no elements may appear after the <template> node", XML.Exn.SCHEMA, getLine(), getCol());
            }
        }        

        private void processBodyElement(XML.Element c) {
            Vec keys = new Vec(c.getAttrLen());
            Vec vals = new Vec(c.getAttrLen());

            // process attributes into Vecs, dealing with any XML Namespaces in the process
            ATTR: for (int i=0; i < c.getAttrLen(); i++) {
                //#switch(c.getAttrKey(i))
                case "id":
                    t.id = c.getAttrVal(i).toString().intern();
                    continue ATTR;
                //#end

                // treat value starting with '.' as resource reference
                String uri = c.getAttrUri(i); if (!uri.equals("")) uri = '.' + uri;
                keys.addElement(c.getAttrKey(i));
                vals.addElement((c.getAttrVal(i).startsWith(".") ? uri : "") + c.getAttrVal(i));
            }

            if (keys.size() == 0) return;

            // sort the attributes lexicographically
            Vec.sort(keys, vals, new Vec.CompareFunc() { public int compare(Object a, Object b) {
                return ((String)a).compareTo((String)b);
            } });

            t.keys = new String[keys.size()];
            t.vals = new Object[vals.size()];
            keys.copyInto(t.keys);
            vals.copyInto(t.vals);

            // convert attributes to appropriate types and intern strings
            for(int i=0; i<t.keys.length; i++) {
                t.keys[i] = t.keys[i].intern();

                String valString = t.vals[i].toString();
                
                if (valString.equals("true")) t.vals[i] = Boolean.TRUE;
                else if (valString.equals("false")) t.vals[i] = Boolean.FALSE;
                else if (valString.equals("null")) t.vals[i] = null;
                else {
                    boolean hasNonNumeral = false;
                    boolean periodUsed = false;
                    for(int j=0; j<valString.length(); j++)
                        if (j == 0 && valString.charAt(j) == '-') {
                        } else if (valString.charAt(j) == '.' && !periodUsed && j != valString.length() - 1) {
                            periodUsed = true;
                        } else if (!Character.isDigit(valString.charAt(j))) {
                            hasNonNumeral = true;
                            break;
                        }
                    if (valString.length() > 0 && !hasNonNumeral) t.vals[i] = new Double(valString);
                    else t.vals[i] = valString.intern();
                }
            }
        }

        private JS parseScript(boolean isstatic) throws IOException {
            JS thisscript = null;
            String contentString = t.content.toString();
            if (contentString.trim().length() > 0)
                thisscript = JS.fromReader("FIXME", t.content_start, new StringReader(contentString));
            t.content = null;
            t.content_start = 0;
            return thisscript;
        }

        public void endElement(XML.Element c) throws XML.Exn, IOException {
            if (state == STATE_IN_XWT_NODE) {
                if ("static".equals(nameOfHeaderNodeBeingProcessed) && t.content != null) t.staticscript = parseScript(true);
                nameOfHeaderNodeBeingProcessed = null;
                
            } else if (state == STATE_IN_TEMPLATE_NODE) {
                if (t.content != null) t.script = parseScript(false);
                if (nodeStack.size() == 0) {
                    // </template>
                    state = STATE_FINISHED_TEMPLATE_NODE;
                    
                } else {
                    // add this template as a child of its parent
                    Template oldt = t;
                    t = (Template)nodeStack.lastElement();
                    nodeStack.setSize(nodeStack.size() - 1);
                    t.children.addElement(oldt);

                    int oldt_lines = getLine() - oldt.startLine;
                    for (int i=0; oldt_lines > i; i++) t.content.append('\n');
                }
            }
         }

        public void characters(char[] ch, int start, int length) throws XML.Exn {
            // invoke the no-tab crusade
            for (int i=0; length >i; i++) if (ch[start+i] == '\t')
                Log.error(Template.class, "tabs are not allowed in XWT files ("+getLine()+":"+getCol()+")");

            if ("static".equals(nameOfHeaderNodeBeingProcessed) || state == STATE_IN_TEMPLATE_NODE) {
                if (t.content == null) {
                    t.content_start = getLine();
                    t.content = new StringBuffer();
                }

                t.content.append(ch, start, length);

            } else if (nameOfHeaderNodeBeingProcessed != null && state != STATE_FINISHED_TEMPLATE_NODE) { throw new XML.Exn(
                "header node <" +nameOfHeaderNodeBeingProcessed+ "> cannot have text content", XML.Exn.SCHEMA, getLine(), getCol());
            }
        }

        public void whitespace(char[] ch, int start, int length) throws XML.Exn { }
    }

    private static class PerInstantiationScope extends JSScope {
        XWT xwt = null;
        PerInstantiationScope parentBoxPis = null;
        JSScope myStatic = null;
        void putDollar(String key, Box target) throws JSExn {
            if (parentBoxPis != null) parentBoxPis.putDollar(key, target);
            declare("$" + key);
            put("$" + key, target);
        }
        public PerInstantiationScope(JSScope parentScope, XWT xwt, PerInstantiationScope parentBoxPis, JSScope myStatic) {
            super(parentScope);
            this.parentBoxPis = parentBoxPis;
            this.xwt = xwt;
            this.myStatic = myStatic;
        }
        public Object get(Object key) throws JSExn {
            if (super.has(key)) return super.get(key);
            if (key.equals("xwt")) return xwt;
            if (key.equals("")) return xwt.get("");
            if (key.equals("static")) return myStatic;
            return super.get(key);
        }
        public void put(Object key, Object val) throws JSExn {
            if (super.has(key)) super.put(key, val);
            else super.put(key, val);
        }
    }

}