/*
 * Copyright (c) 2018, 2021, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * The Universal Permissive License (UPL), Version 1.0
 *
 * Subject to the condition set forth below, permission is hereby granted to any
 * person obtaining a copy of this software, associated documentation and/or
 * data (collectively the "Software"), free of charge and under any and all
 * copyright rights in the Software, and any and all patent rights owned or
 * freely licensable by each licensor hereunder covering either (i) the
 * unmodified Software as contributed to or provided by such licensor, or (ii)
 * the Larger Works (as defined below), to deal in both
 *
 * (a) the Software, and
 *
 * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
 * one is included with the Software each a "Larger Work" to which the Software
 * is contributed by such licensors),
 *
 * without restriction, including without limitation the rights to copy, create
 * derivative works of, display, perform, and distribute the Software and make,
 * use, sell, offer for sale, import, export, have made, and have sold the
 * Software and the Larger Work(s), and to sublicense the foregoing rights on
 * either these or other terms.
 *
 * This license is subject to the following condition:
 *
 * The above copyright notice and either this complete permission notice or at a
 * minimum a reference to the UPL must be included in all copies or substantial
 * portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
package jmri.script.jsr223graalpython;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.StandardCharsets;
import java.util.function.Predicate;

import javax.script.AbstractScriptEngine;
import javax.script.Bindings;
import javax.script.Compilable;
import javax.script.CompiledScript;
import javax.script.Invocable;
import javax.script.ScriptContext;
import javax.script.ScriptEngine;
import javax.script.ScriptException;

import org.graalvm.collections.EconomicMap;
import org.graalvm.collections.EconomicSet;
import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.Context.Builder;
import org.graalvm.polyglot.Engine;
import org.graalvm.polyglot.HostAccess;
import org.graalvm.polyglot.HostAccess.TargetMappingPrecedence;
import org.graalvm.polyglot.PolyglotException;
import org.graalvm.polyglot.Source;
import org.graalvm.polyglot.Value;
import org.graalvm.polyglot.proxy.Proxy;

/**
 * A Graal.JS implementation of the script engine. It provides access to the polyglot context using
 * {@link #getPolyglotContext()}.
 */
public final class GraalJSScriptEngine extends AbstractScriptEngine implements Compilable, Invocable, AutoCloseable {

    private static final String ID = "python";
    private static final String POLYGLOT_CONTEXT = "polyglot.context";
    private static final String OUT_SYMBOL = "$$internal.out$$";
    private static final String IN_SYMBOL = "$$internal.in$$";
    private static final String ERR_SYMBOL = "$$internal.err$$";
    private static final String JS_SYNTAX_EXTENSIONS_OPTION = "js.syntax-extensions";
    private static final String JS_SCRIPT_ENGINE_GLOBAL_SCOPE_IMPORT_OPTION = "js.script-engine-global-scope-import";
    private static final String JS_LOAD_OPTION = "js.load";
    private static final String JS_PRINT_OPTION = "js.print";
    private static final String JS_GLOBAL_ARGUMENTS_OPTION = "js.global-arguments";
    private static final String NASHORN_COMPATIBILITY_MODE_SYSTEM_PROPERTY = "polyglot.js.nashorn-compat";
    private static final String INSECURE_SCRIPTENGINE_ACCESS_SYSTEM_PROPERTY = "graaljs.insecure-scriptengine-access";
    static final String MAGIC_OPTION_PREFIX = "polyglot.js.";

    private static final HostAccess NASHORN_HOST_ACCESS = createNashornHostAccess();

    private static HostAccess createNashornHostAccess() {
        HostAccess.Builder b = HostAccess.newBuilder(HostAccess.ALL);
        // Last resort conversions similar to those in NashornBottomLinker.
        b.targetTypeMapping(Value.class, String.class, v -> !v.isNull(), v -> toString(v), TargetMappingPrecedence.LOWEST);
        b.targetTypeMapping(Number.class, Integer.class, n -> true, n -> n.intValue(), TargetMappingPrecedence.LOWEST);
        b.targetTypeMapping(Number.class, Double.class, n -> true, n -> n.doubleValue(), TargetMappingPrecedence.LOWEST);
        b.targetTypeMapping(Number.class, Long.class, n -> true, n -> n.longValue(), TargetMappingPrecedence.LOWEST);
        b.targetTypeMapping(Number.class, Boolean.class, n -> true, n -> toBoolean(n.doubleValue()), TargetMappingPrecedence.LOWEST);
        b.targetTypeMapping(String.class, Boolean.class, n -> true, n -> !n.isEmpty(), TargetMappingPrecedence.LOWEST);
        return b.build();
    }

    // ToString() operation
    private static String toString(Value value) {
        return toPrimitive(value).toString();
    }

    // "Type(result) is not Object" heuristic for the purpose of ToPrimitive() conversion
    private static boolean isPrimitive(Value value) {
        return value.isString() || value.isNumber() || value.isBoolean() || value.isNull();
    }

    // ToPrimitive()/OrdinaryToPrimitive() operation
    private static Value toPrimitive(Value value) {
        if (value.hasMembers()) {
            for (String methodName : new String[]{"toString", "valueOf"}) {
                if (value.canInvokeMember(methodName)) {
                    Value maybePrimitive = value.invokeMember(methodName);
                    if (isPrimitive(maybePrimitive)) {
                        return maybePrimitive;
                    }
                }
            }
        }
        if (isPrimitive(value)) {
            return value;
        } else {
            throw new ClassCastException();
        }
    }

    private static boolean toBoolean(double d) {
        return d != 0.0 && !Double.isNaN(d);
    }

    interface MagicBindingsOptionSetter {

        String getOptionKey();

        Context.Builder setOption(Builder builder, Object value);
    }

    private static boolean toBoolean(MagicBindingsOptionSetter optionSetter, Object value) {
        if (!(value instanceof Boolean)) {
            throw magicOptionValueErrorBool(optionSetter.getOptionKey(), value);
        }
        return (Boolean) value;
    }

    private static final MagicBindingsOptionSetter[] MAGIC_OPTION_SETTERS = new MagicBindingsOptionSetter[]{new MagicBindingsOptionSetter() {

        @Override
        public String getOptionKey() {
            return MAGIC_OPTION_PREFIX + "allowHostAccess";
        }

        @Override
        public Builder setOption(Builder builder, Object value) {
            return builder.allowHostAccess(toBoolean(this, value) ? HostAccess.ALL : HostAccess.NONE);
        }
    }, new MagicBindingsOptionSetter() {

        @Override
        public String getOptionKey() {
            return MAGIC_OPTION_PREFIX + "allowNativeAccess";
        }

        @Override
        public Builder setOption(Builder builder, Object value) {
            return builder.allowNativeAccess(toBoolean(this, value));
        }
    }, new MagicBindingsOptionSetter() {

        @Override
        public String getOptionKey() {
            return MAGIC_OPTION_PREFIX + "allowCreateThread";
        }

        @Override
        public Builder setOption(Builder builder, Object value) {
            return builder.allowCreateThread(toBoolean(this, value));
        }
    }, new MagicBindingsOptionSetter() {

        @Override
        public String getOptionKey() {
            return MAGIC_OPTION_PREFIX + "allowIO";
        }

        @Override
        public Builder setOption(Builder builder, Object value) {
            return builder.allowIO(toBoolean(this, value));
        }
    }, new MagicBindingsOptionSetter() {

        @Override
        public String getOptionKey() {
            return MAGIC_OPTION_PREFIX + "allowHostClassLookup";
        }

        @SuppressWarnings("unchecked")
        @Override
        public Builder setOption(Builder builder, Object value) {
            if (value instanceof Boolean) {
                boolean enabled = (Boolean) value;
                return builder.allowHostClassLookup(enabled ? s -> true : null);
            } else {
                try {
                    return builder.allowHostClassLookup((Predicate<String>) value);
                } catch (ClassCastException e) {
                    throw new IllegalArgumentException(String.format("failed to set graal-js option \"%s\": expected a boolean or Predicate<String> value, got \"%s\"", getOptionKey(), value));
                }
            }
        }
    }, new MagicBindingsOptionSetter() {

        @Override
        public String getOptionKey() {
            return MAGIC_OPTION_PREFIX + "allowHostClassLoading";
        }

        @Override
        public Builder setOption(Builder builder, Object value) {
            return builder.allowHostClassLoading(toBoolean(this, value));
        }
    }, new MagicBindingsOptionSetter() {

        @Override
        public String getOptionKey() {
            return MAGIC_OPTION_PREFIX + "allowAllAccess";
        }

        @Override
        public Builder setOption(Builder builder, Object value) {
            return builder.allowAllAccess(toBoolean(this, value));
        }
    }, new MagicBindingsOptionSetter() {

        @Override
        public String getOptionKey() {
            return MAGIC_OPTION_PREFIX + "nashorn-compat";
        }

        @Override
        public Builder setOption(Builder builder, Object value) {
            boolean val = toBoolean(this, value);
            if (val) {
                updateForNashornCompatibilityMode(builder);
            }
            return builder.option("js.nashorn-compat", String.valueOf(val));
        }
    }, new MagicBindingsOptionSetter() {

        @Override
        public String getOptionKey() {
            return MAGIC_OPTION_PREFIX + "ecmascript-version";
        }

        @Override
        public Builder setOption(Builder builder, Object value) {
            return builder.option("js.ecmascript-version", String.valueOf(value));
        }
    }};

    private static final EconomicSet<String> MAGIC_BINDINGS_OPTION_KEYS = EconomicSet.create();
    static final EconomicMap<String, MagicBindingsOptionSetter> MAGIC_BINDINGS_OPTION_MAP = EconomicMap.create();
    private static final boolean NASHORN_COMPATIBILITY_MODE  = true; // wasBoolean.getBoolean(NASHORN_COMPATIBILITY_MODE_SYSTEM_PROPERTY);

    static {
        for (MagicBindingsOptionSetter setter : MAGIC_OPTION_SETTERS) {
            MAGIC_BINDINGS_OPTION_KEYS.add(setter.getOptionKey());
            MAGIC_BINDINGS_OPTION_MAP.put(setter.getOptionKey(), setter);
        }
    }

    private final GraalJSEngineFactory factory;
    private final Context.Builder contextConfig;

    private boolean evalCalled;

    public GraalJSScriptEngine(GraalJSEngineFactory factory) {
        this(factory, factory.getPolyglotEngine(), null);
        log.debug("ctor(Factory) invoked");
    }

    GraalJSScriptEngine(GraalJSEngineFactory factory, Engine engine, Context.Builder contextConfig) {
        log.debug("ctor invoked");
        Engine engineToUse = engine;
        if (engineToUse == null) {
            engineToUse = Engine.newBuilder().allowExperimentalOptions(true).build();
        }
        Context.Builder contextConfigToUse = contextConfig;
        if (contextConfigToUse == null) {
            // default config
            contextConfigToUse = Context.newBuilder(ID).allowExperimentalOptions(true);
            contextConfigToUse.option(JS_SYNTAX_EXTENSIONS_OPTION, "true");
            contextConfigToUse.option(JS_LOAD_OPTION, "true");
            contextConfigToUse.option(JS_PRINT_OPTION, "true");
            contextConfigToUse.option(JS_GLOBAL_ARGUMENTS_OPTION, "true");
            if (NASHORN_COMPATIBILITY_MODE) {
                updateForNashornCompatibilityMode(contextConfigToUse);
            } else if (Boolean.getBoolean(INSECURE_SCRIPTENGINE_ACCESS_SYSTEM_PROPERTY)) {
                updateForScriptEngineAccessibility(contextConfigToUse);
            }
        }
        this.factory = (factory == null) ? new GraalJSEngineFactory(engineToUse) : factory;
        this.contextConfig = contextConfigToUse.option(JS_SCRIPT_ENGINE_GLOBAL_SCOPE_IMPORT_OPTION, "true").engine(engineToUse);
        this.context.setBindings(new GraalJSBindings(this.contextConfig, this.context), ScriptContext.ENGINE_SCOPE);
    }

    private static void updateForNashornCompatibilityMode(Context.Builder builder) {
        builder.allowAllAccess(true);
        builder.allowHostAccess(NASHORN_HOST_ACCESS);
        // builder.useSystemExit(true);
    }

    private static void updateForScriptEngineAccessibility(Context.Builder builder) {
        builder.allowHostAccess(HostAccess.ALL);
    }

    static Context createDefaultContext(Context.Builder builder) {
        DelegatingInputStream in = new DelegatingInputStream();
        DelegatingOutputStream out = new DelegatingOutputStream();
        DelegatingOutputStream err = new DelegatingOutputStream();
        builder
            .allowAllAccess(true)
            .in(in).out(out).err(err);
        Context ctx = builder.build();
        ctx.getPolyglotBindings().putMember(OUT_SYMBOL, out);
        ctx.getPolyglotBindings().putMember(ERR_SYMBOL, err);
        ctx.getPolyglotBindings().putMember(IN_SYMBOL, in);
        return ctx;
    }

    /**
     * Closes the current context and makes it unusable. Operations performed after closing will
     * throw an {@link IllegalStateException}.
     */
    @Override
    public void close() {
        log.debug("close invoked");
        getPolyglotContext().close();
    }

    /**
     * Returns the polyglot engine associated with this script engine.
     * @return the polyglot engine associated with this script engine.
     */
    public Engine getPolyglotEngine() {
        log.debug("getPolyglotEngine invoked");
        return factory.getPolyglotEngine();
    }

    /**
     * Returns the polyglot context associated with the default ScriptContext of the engine.
     *
     * @see #getPolyglotContext(ScriptContext) to access the polyglot context of a particular
     *      context.
     *
     * @return polyglot Context from the `context` member variable
     */
    public Context getPolyglotContext() {
        log.debug("getPolyglotContext invoked");
        return getPolyglotContext(context);
    }

    /**
     * Returns the polyglot context associated with a ScriptContext. If the context is not yet
     * initialized then it will be initialized using the default context builder specified in
     * {@link #create(Engine, org.graalvm.polyglot.Context.Builder)}.
     * @param ctxt Input to the creation
     * @return a Context from the ScriptContext
     */
    public Context getPolyglotContext(ScriptContext ctxt) {
        log.trace("getPolyglotContext with {}", ctxt);
        return getOrCreateGraalJSBindings(ctxt).getContext();
    }

    static Value evalInternal(Context context, String script) {
        log.trace("evalInternal with ID {} \"{}\", \"{}\"", ID, context, script);
        try {
            return context.eval(Source.newBuilder(ID, script, "internal-script").internal(true).buildLiteral());
        } catch (Exception e) {
            log.warn("exception in evalInternal", e);
            return null;
        }
    }

    @Override
    public Bindings createBindings() {
        log.debug("createBindings");
        return new GraalJSBindings(contextConfig, null);
    }

    @Override
    public void setBindings(Bindings bindings, int scope) {
        log.debug("setBindings {} scope: {}", bindings, scope);
        if (scope == ScriptContext.ENGINE_SCOPE) {
            Bindings oldBindings = getBindings(scope);
            if (oldBindings instanceof GraalJSBindings) {
                ((GraalJSBindings) oldBindings).updateEngineScriptContext(null);
            }
        }
        super.setBindings(bindings, scope);
        if (scope == ScriptContext.ENGINE_SCOPE && (bindings instanceof GraalJSBindings)) {
            ((GraalJSBindings) bindings).updateEngineScriptContext(getContext());
        }
    }

    @Override
    public Object eval(Reader reader, ScriptContext ctxt) throws ScriptException {
        return eval(createSource(read(reader), ctxt), ctxt);
    }

    static String read(Reader reader) throws ScriptException {
        final StringBuilder builder = new StringBuilder();
        final char[] buffer = new char[1024];
        try {
            try {
                while (true) {
                    final int count = reader.read(buffer);
                    if (count == -1) {
                        break;
                    }
                    builder.append(buffer, 0, count);
                }
            } finally {
                reader.close();
            }
            return builder.toString();
        } catch (IOException ioex) {
            throw new ScriptException(ioex);
        }
    }

    @Override
    public Object eval(String script, ScriptContext ctxt) throws ScriptException {
        return eval(createSource(script, ctxt), ctxt);
    }

    private static Source createSource(String script, ScriptContext ctxt) throws ScriptException {
        log.trace("createSource ctxt {}", ctxt);
        final Object val = ctxt.getAttribute(ScriptEngine.FILENAME);
        if (val == null) {
            return Source.newBuilder(ID, script, "<eval>").buildLiteral();
        } else {
            try {
                return Source.newBuilder(ID, new File(val.toString())).content(script).build();
            } catch (IOException ioex) {
                throw new ScriptException(ioex);
            }
        }
    }

    private static void updateDelegatingIOStreams(Context polyglotContext, ScriptContext scriptContext) {
        Value polyglotBindings = polyglotContext.getPolyglotBindings();
        ((DelegatingOutputStream) polyglotBindings.getMember(OUT_SYMBOL).asProxyObject()).setWriter(scriptContext.getWriter());
        ((DelegatingOutputStream) polyglotBindings.getMember(ERR_SYMBOL).asProxyObject()).setWriter(scriptContext.getErrorWriter());
        ((DelegatingInputStream) polyglotBindings.getMember(IN_SYMBOL).asProxyObject()).setReader(scriptContext.getReader());
    }

    private Object eval(Source source, ScriptContext scriptContext) throws ScriptException {
        log.debug("eval({},{}) called", source, scriptContext);
        GraalJSBindings engineBindings = getOrCreateGraalJSBindings(scriptContext);
        log.trace("   engineBindings {}", engineBindings);
        Context polyglotContext = engineBindings.getContext();
        updateDelegatingIOStreams(polyglotContext, scriptContext);
        try {
            log.trace("   try evalCalled = {}", evalCalled);
            if (!evalCalled) {
                jrunscriptInitWorkaround(source, polyglotContext);
            }
            log.trace("    start engineBindings.importGlobalBindings");
            engineBindings.importGlobalBindings(scriptContext);
            log.trace("    return polyglotContext.eval(..)");
            return polyglotContext.eval(source).as(Object.class);
        } catch (PolyglotException e) {
            log.warn("Exception in eval", e.getCause());
            throw toScriptException(e);
        } finally {
            evalCalled = true;
        }
    }

    private static ScriptException toScriptException(PolyglotException ex) {
        ScriptException sex;
        if (ex.isHostException()) {
            Throwable hostException = ex.asHostException();
            // ScriptException (unlike almost any other exception) does not
            // accept Throwable cause (requires the cause to be Exception)
            Exception cause;
            if (hostException instanceof Exception) {
                cause = (Exception) hostException;
            } else {
                cause = new Exception(hostException);
            }
            // Make the host exception accessible through the cause chain
            sex = new ScriptException(cause);
            // Re-use the stack-trace of PolyglotException (with guest-language stack-frames)
            sex.setStackTrace(ex.getStackTrace());
        } else {
            sex = new ScriptException(ex);
        }
        return sex;
    }

    private GraalJSBindings getOrCreateGraalJSBindings(ScriptContext scriptContext) {
        log.debug("getOrCreateGraalJSBindings invoked with {}", scriptContext);
        Bindings engineB = scriptContext.getBindings(ScriptContext.ENGINE_SCOPE);
        if (engineB instanceof GraalJSBindings) {
            log.trace("   return engineB: {}", engineB);
            return ((GraalJSBindings) engineB);
        } else {
            GraalJSBindings bindings = new GraalJSBindings(createContext(engineB), scriptContext);
            bindings.putAll(engineB);
            log.trace("   recreate bindings: {} engineB {}", bindings, engineB);
            return bindings;
        }
    }

    private Context createContext(Bindings engineB) {
        log.debug("createContext bindings: {}", engineB);
        Object ctx = engineB.get(POLYGLOT_CONTEXT);
        if (!(ctx instanceof Context)) {
            Context.Builder builder = contextConfig;
            log.trace("   invoking MAGIC_OPTION_SETTERS");
            for (MagicBindingsOptionSetter optionSetter : MAGIC_OPTION_SETTERS) {
                log.trace("      optionSetter: {}", optionSetter);
                Object value = engineB.get(optionSetter.getOptionKey());
                if (value != null) {
                    log.trace("         value: {}", value);
                    builder = optionSetter.setOption(builder, value);
                    engineB.remove(optionSetter.getOptionKey());
                }
            }
            ctx = createDefaultContext(builder);
            log.trace("   createDefaultContext returns {} for {}", ctx, POLYGLOT_CONTEXT);
            engineB.put(POLYGLOT_CONTEXT, ctx);
        }
        return (Context) ctx;
    }

    @Override
    public GraalJSEngineFactory getFactory() {
        return factory;
    }

    @Override
    public Object invokeMethod(Object thiz, String name, Object... args) throws ScriptException, NoSuchMethodException {
        log.trace("invokeMethod {} {}", thiz, name);
        if (thiz == null) {
            throw new IllegalArgumentException("thiz is not a valid object.");
        }
        GraalJSBindings engineBindings = getOrCreateGraalJSBindings(context);
        engineBindings.importGlobalBindings(context);
        Value thisValue = engineBindings.getContext().asValue(thiz);

        if (!thisValue.canInvokeMember(name)) {
            if (!thisValue.hasMember(name)) {
                throw noSuchMethod(name);
            } else {
                throw notCallable(name);
            }
        }
        try {
            return thisValue.invokeMember(name, args).as(Object.class);
        } catch (PolyglotException e) {
            throw toScriptException(e);
        }
    }

    @Override
    public Object invokeFunction(String name, Object... args) throws ScriptException, NoSuchMethodException {
        log.trace("invokeFunction {}", name);
        GraalJSBindings engineBindings = getOrCreateGraalJSBindings(context);
        engineBindings.importGlobalBindings(context);
        Value function = engineBindings.getContext().getBindings(ID).getMember(name);

        if (function == null) {
            throw noSuchMethod(name);
        } else if (!function.canExecute()) {
            throw notCallable(name);
        }
        try {
            return function.execute(args).as(Object.class);
        } catch (PolyglotException e) {
            throw toScriptException(e);
        }
    }

    private static NoSuchMethodException noSuchMethod(String name) throws NoSuchMethodException {
        throw new NoSuchMethodException(name);
    }

    private static NoSuchMethodException notCallable(String name) throws NoSuchMethodException {
        throw new NoSuchMethodException(name + " is not a function");
    }

    @Override
    public <T> T getInterface(Class<T> clasz) {
        checkInterface(clasz);
        log.trace("getInterface of {}", clasz);
        var retval = getInterfaceInner(evalInternal(getPolyglotContext(), "locals()"), clasz); // was "this" in Javascript
        log.trace("  returns {}", retval);
        return retval;
    }

    @Override
    public <T> T getInterface(Object thiz, Class<T> clasz) {
        if (thiz == null) {
            throw new IllegalArgumentException("this cannot be null");
        }
        checkInterface(clasz);
        Value thisValue = getPolyglotContext().asValue(thiz);
        checkThis(thisValue);
        return getInterfaceInner(thisValue, clasz);
    }

    private static void checkInterface(Class<?> clasz) {
        if (clasz == null || !clasz.isInterface()) {
            throw new IllegalArgumentException("interface Class expected in getInterface");
        }
    }

    private static void checkThis(Value thiz) {
        if (thiz.isHostObject() || !thiz.hasMembers()) {
            throw new IllegalArgumentException("getInterface cannot be called on non-script object");
        }
    }

    private static <T> T getInterfaceInner(Value thiz, Class<T> iface) {
        if (!isInterfaceImplemented(iface, thiz)) {
            return null;
        }
        return thiz.as(iface);
    }

    @Override
    public CompiledScript compile(String script) throws ScriptException {
        Source source = createSource(script, getContext());
        return compile(source);
    }

    @Override
    public CompiledScript compile(Reader reader) throws ScriptException {
        Source source = createSource(read(reader), getContext());
        return compile(source);
    }

    private CompiledScript compile(Source source) throws ScriptException {
        checkSyntax(source);
        return new CompiledScript() {
            @Override
            public ScriptEngine getEngine() {
                return GraalJSScriptEngine.this;
            }

            @Override
            public Object eval(ScriptContext ctx) throws ScriptException {
                return GraalJSScriptEngine.this.eval(source, ctx);
            }
        };
    }

    private void checkSyntax(Source source) throws ScriptException {
        try {
            getPolyglotContext().parse(source);
        } catch (PolyglotException pex) {
            throw toScriptException(pex);
        }
    }

    private static class DelegatingInputStream extends InputStream implements Proxy {

        private Reader reader;
        private CharsetEncoder encoder = StandardCharsets.UTF_8.newEncoder();
        private CharBuffer charBuffer = CharBuffer.allocate(2);
        private ByteBuffer byteBuffer = ByteBuffer.allocate((int) encoder.maxBytesPerChar() * 2);

        DelegatingInputStream() {
            byteBuffer.flip();
        }

        @Override
        public int read() throws IOException {
            if (reader != null) {
                while (!byteBuffer.hasRemaining()) {
                    int c = reader.read();
                    if (c == -1) {
                        return -1;
                    }
                    byteBuffer.clear();
                    charBuffer.put((char) c);
                    charBuffer.flip();
                    encoder.encode(charBuffer, byteBuffer, false);
                    charBuffer.compact();
                    byteBuffer.flip();
                }
                return byteBuffer.get();
            }
            return 0;
        }

        void setReader(Reader reader) {
            this.reader = reader;
        }

    }

    private static class DelegatingOutputStream extends OutputStream implements Proxy {

        private Writer writer;
        private CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder();
        private ByteBuffer byteBuffer = ByteBuffer.allocate((int) StandardCharsets.UTF_8.newEncoder().maxBytesPerChar() * 2);
        private CharBuffer charBuffer = CharBuffer.allocate(byteBuffer.capacity() * (int) decoder.maxCharsPerByte());

        @Override
        public void write(int b) throws IOException {
            if (writer != null) {
                byteBuffer.put((byte) b);
                byteBuffer.flip();
                decoder.decode(byteBuffer, charBuffer, false);
                byteBuffer.compact();
                charBuffer.flip();
                while (charBuffer.hasRemaining()) {
                    char c = charBuffer.get();
                    writer.write(c);
                }
                charBuffer.clear();
                writer.flush();  // was needed to get tests to actually print
            }
        }

        @Override
        public void flush() throws IOException {
            if (writer != null) {
                writer.flush();
            }
        }

        void setWriter(Writer writer) {
            this.writer = writer;
        }

    }

    /**
     * Creates a new GraalJSScriptEngine with default configuration.
     *
     * @see #create(Engine, Context.Builder) to customize the configuration.
     * @return A new script engine created with null parameters
     */
    public static GraalJSScriptEngine create() {
        log.debug("create invoked");
        return create(null, null);
    }

    /**
     * Creates a new GraalJS script engine from a polyglot Engine instance with a base configuration
     * for new polyglot {@link Context} instances. Polyglot context instances can be accessed from
     * {@link ScriptContext} instances using {@link #getPolyglotContext()}. The
     * {@link Builder#out(OutputStream) out},{@link Builder#err(OutputStream) err} and
     * {@link Builder#in(InputStream) in} stream configuration are not inherited from the provided
     * polyglot context config. Instead {@link ScriptContext} output and input streams are used.
     *
     * @param engine the engine to be used for context configurations or <code>null</code> if a
     *            default engine should be used.
     * @param newContextConfig a base configuration to create new context instances or
     *            <code>null</code> if the default configuration should be used to construct new
     *            context instances.
     * @return A new script engine
     */
    public static GraalJSScriptEngine create(Engine engine, Context.Builder newContextConfig) {
        log.debug("create(stuff) invoked");
        return new GraalJSScriptEngine(null, engine, newContextConfig);
    }

    private static boolean isInterfaceImplemented(final Class<?> iface, final Value obj) {
        for (final Method method : iface.getMethods()) {
            // ignore methods of java.lang.Object class
            if (method.getDeclaringClass() == Object.class) {
                continue;
            }

            // skip check for default methods - non-abstract, interface methods
            if (!Modifier.isAbstract(method.getModifiers())) {
                continue;
            }

            if (!obj.canInvokeMember(method.getName())) {
                return false;
            }
        }
        return true;
    }

    /**
     * Detects jrunscript "init.js" and installs a JSAdapter polyfill if needed.
     */
    private static void jrunscriptInitWorkaround(Source source, Context polyglotContext) {
        log.trace("jrunscriptInitWorkaround with {}, {}", source, polyglotContext);
        if (source.getName().equals(JRUNSCRIPT_INIT_NAME)) {
            log.trace("   passed 1st if with match on {}", source.getName());
            String initCode = source.getCharacters().toString();
            log.trace("   creates initCode = {}", initCode);
            if (initCode.contains("jrunscript") && initCode.contains("JSAdapter") && !polyglotContext.getBindings(ID).hasMember("JSAdapter")) {
                log.trace("        polyglotContext.eval {} {}", ID, JSADAPTER_POLYFILL);
                polyglotContext.eval(ID, JSADAPTER_POLYFILL);
            }
        }
    }

    private static final String JRUNSCRIPT_INIT_NAME = "<system-init>";
    private static final String JSADAPTER_POLYFILL = "this.JSAdapter || " +
                    "Object.defineProperty(this, \"JSAdapter\", {configurable:true, writable:true, enumerable: false, value: function(t) {\n" +
                    "    var target = {};\n" +
                    "    var handler = {\n" +
                    "        get: function(target, name) {return typeof t.__get__ == 'function' ? t.__get__.call(target, name) : undefined;},\n" +
                    "        has: function(target, name) {return typeof t.__has__ == 'function' ? t.__has__.call(target, name) : false;},\n" +
                    "        deleteProperty: function(target, name) {return typeof t.__delete__ == 'function' ? t.__delete__.call(target, name) : true;},\n" +
                    "        set: function(target, name, value) {return typeof t.__put__ == 'function' ? t.__put__.call(target, name, value) : undefined;},\n" +
                    "        ownKeys: function(target) {return typeof t.__getIds__ == 'function' ? t.__getIds__.call(target) : [];},\n" +
                    "    }\n" +
                    "    return new Proxy(target, handler);\n" +
                    "}});\n";

    private static IllegalArgumentException magicOptionValueErrorBool(String name, Object v) {
        return new IllegalArgumentException(String.format("failed to set graal-js option \"%s\": expected a boolean value, got \"%s\"", name, v));
    }

    private final static org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(GraalJSScriptEngine.class);
}