// Copyright 2000-2005 the Contributors, as shown in the revision logs.
// Licensed under the Apache Public Source License 2.0 ("the License").
// You may not use this file except in compliance with the License.

package org.ibex.js;

public class JSPrimitive extends JS.Immutable {
    private static final JS.Method METHOD = new JS.Method();

    public JS call(JS method, JS[] args) throws JSExn {
        String s = coerceToString();
        int slength = s.length();

        //#switch(JSU.str(method))
        case "toFixed": throw new JSExn("toFixed() not implemented");
        case "toExponential": throw new JSExn("toExponential() not implemented");
        case "toPrecision": throw new JSExn("toPrecision() not implemented");
        case "toString": return this instanceof JSString ? this : JSU.S(JSU.toString(this));
        case "substring": {
            int a = args.length >= 1 ? JSU.toInt(args[0]) : 0;
            int b = args.length >= 2 ? JSU.toInt(args[1]) : slength;
            if (a > slength) a = slength;
            if (b > slength) b = slength;
            if (a < 0) a = 0;
            if (b < 0) b = 0;
            if (a > b) { int tmp = a; a = b; b = tmp; }
            return JSU.S(s.substring(a,b));
        }
        case "substr": {
            int start = args.length >= 1 ? JSU.toInt(args[0]) : 0;
            int len = args.length >= 2 ? JSU.toInt(args[1]) : Integer.MAX_VALUE;
            if (start < 0) start = slength + start;
            if (start < 0) start = 0;
            if (len < 0) len = 0;
            if (len > slength - start) len = slength - start;
            if (len <= 0) return JSU.S("");
            return JSU.S(s.substring(start,start+len));
        }
        case "charAt": {
            int p = args.length >= 1 ? JSU.toInt(args[0]) : 0;
            if (p < 0 || p >= slength) return JSU.S("");
            return JSU.S(s.substring(p,p+1));
        }
        case "charCodeAt": {
            int p = args.length >= 1 ? JSU.toInt(args[0]) : 0;
            if (p < 0 || p >= slength) return JSU.N(Double.NaN);
            return JSU.N(s.charAt(p));
        }
        case "concat": {
            StringBuffer sb = new StringBuffer(slength*2).append(s);
            for (int i=0; i < args.length; i++) sb.append(args[i]);
            return JSU.S(sb.toString());
        }
        case "indexOf": {
            String search = args.length >= 1 ? JSU.toString(args[0]) : "null";
            int start = args.length >= 2 ? JSU.toInt(args[1]) : 0;
            // Java's indexOf handles an out of bounds start index, it'll return -1
            return JSU.N(s.indexOf(search,start));
        }
        case "lastIndexOf": {
            String search = args.length >= 1 ? JSU.toString(args[0]) : "null";
            int start = args.length >= 2 ? JSU.toInt(args[1]) : 0;
            // Java's indexOf handles an out of bounds start index, it'll return -1
            return JSU.N(s.lastIndexOf(search,start));            
        }
        case "match": return JSRegexp.stringMatch(this,args[0]);
        case "replace": return JSRegexp.stringReplace(this,args[0],args[1]);
        case "search": return JSRegexp.stringSearch(this,args[0]);
        case "split": return JSRegexp.stringSplit(this,args[0],args[1],args.length);
        case "toLowerCase": return JSU.S(s.toLowerCase());
        case "toUpperCase": return JSU.S(s.toUpperCase());
        case "slice": {
            int a = args.length >= 1 ? JSU.toInt(args[0]) : 0;
            int b = args.length >= 2 ? JSU.toInt(args[1]) : slength;
            if (a < 0) a = slength + a;
            if (b < 0) b = slength + b;
            if (a < 0) a = 0;
            if (b < 0) b = 0;
            if (a > slength) a = slength;
            if (b > slength) b = slength;
            if (a > b) return JSU.S("");
            return JSU.S(s.substring(a,b));
        }
        //#end
        return super.call(method, args);
    }
    
    public JS get(JS key) throws JSExn {
        //#switch(JSU.toString(key))
        case "length": return JSU.N(JSU.toString(this).length());
        case "substring": return METHOD;
        case "charAt": return METHOD;
        case "charCodeAt": return METHOD;
        case "concat": return METHOD;
        case "indexOf": return METHOD;
        case "lastIndexOf": return METHOD; 
        case "match": return METHOD;
        case "replace": return METHOD;
        case "search": return METHOD;
        case "slice": return METHOD;
        case "split": return METHOD;
        case "toLowerCase": return METHOD; 
        case "toUpperCase": return METHOD; 
        case "toString": return METHOD; 
        case "substr": return METHOD;  
        case "toPrecision": return METHOD;
        case "toExponential": return METHOD;
        case "toFixed": return METHOD;
        //#end
        return super.get(key);
    }
}