/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *   Free SoftwareFoundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.es;

import com.caucho.VersionFactory;
import com.caucho.es.parser.Parser;
import com.caucho.server.util.CauchoSystem;
import com.caucho.vfs.MergePath;
import com.caucho.vfs.Path;
import com.caucho.vfs.ReadStream;
import com.caucho.vfs.Vfs;
import com.caucho.vfs.VfsStream;
import com.caucho.vfs.WriteStream;

import java.io.IOException;
import java.util.HashMap;

/**
 * Resin is the primary public entry to the JavaScript compiler.
 *
 * <p>The script must first be compiled, then executed.
 *
 * <p>JavaScript import uses a script path to located the imported
 * script.  The scriptPath is just an array of Paths.  If the scriptPath
 * is null, Resin will default to the script's directory, followed
 * by $RESIN_HOME/scripts.
 * <p>Here's the default, where 'is' is the input stream:
 *
 * <pre><code>
 * Path scriptPath[] = new Path[] {
 *   is.getPath().getParent(),
 *   CauchoSystem.getResinHome().lookup("scripts")
 * }
 * </code></pre>
 *
 * <p>As described in the Script object, programs set global variables
 * with a hash map.  So a simple call might look like:
 *
 * <pre><code>
 * Script script = Resin.parse(Pwd.lookup("foo.js"), scriptPath);
 *
 * HashMap props = new HashMap();
 * props.put("out", System.out);
 *
 * script.execute(props, null);
 * </code></pre>
 *
 * <p>Executing the Script object is threadsafe. 
 * The ScriptClosure object, of course, is not threadsafe.
 */
public class Resin {
  static final String COPYRIGHT =
    "Copyright (c) 1998-2011 Caucho Technology.  All rights reserved.";
      
  private static WriteStream dbg;

  private Resin()
  {
  }

  public static void init(ESFactory factory)
  {
    ESBase.init(factory);
  }
  
  public static Parser getParser()
    throws IOException, ESException
  {
    init(null);

    return new Parser();
  }

  public static void main(String []argv)
  {
    String resinConf = CauchoSystem.getResinConfig();
    boolean verbose = false;

    try {
      ReadStream is;
      String name;
      int shift = 0;

      while (argv.length > shift) {
        if (argv[shift].equals("-v")) {
          verbose = true;
          shift++;
        } else if (shift + 1 < argv.length && argv[shift].equals("-conf")) {
          resinConf = argv[shift + 1];
          shift += 2;
        } else if (argv[shift].equals("--version")) {
          System.out.println(VersionFactory.getVersion());
          System.exit(0);
        } else
          break;
      }

      if (argv.length == shift) {
        is = VfsStream.openRead(System.in);
        name = "stdin";
      }
      else {
        is = Vfs.lookupNative(argv[shift]).openRead();
        name = argv[shift++];
      }

      Path conf = Vfs.lookup(resinConf);
      // Registry.setDefault(Registry.parse(conf));

      String []args;
      if (argv.length > shift)
        args = new String[argv.length - shift];
      else
        args = new String[0];
      for (int i = 0; i < argv.length - shift; i++)
        args[i] = argv[i + shift];

      Path scriptPath = null;

      int p;
      if ((p = name.lastIndexOf('/')) >= 0) {
        Path subpath = Vfs.lookupNative(name.substring(0, p));

        MergePath mergePath = new MergePath();
        mergePath.addMergePath(Vfs.lookup());
        mergePath.addMergePath(subpath);
        mergePath.addMergePath(CauchoSystem.getResinHome().lookup("scripts"));
        mergePath.addClassPath(Thread.currentThread().getContextClassLoader());
        scriptPath = mergePath;
      }

      Parser parser = new Parser();
      parser.setScriptPath(scriptPath);
      
      Script script = parser.parse(is);

      WriteStream stream = VfsStream.openWrite(System.out);
      HashMap properties = new HashMap();
      properties.put("out", stream);
      properties.put("arguments", args);
      properties.put("File", Vfs.lookup());

      script.execute(properties, null);

      stream.flush();
    } catch (ESParseException e) {
      System.err.println(e.getMessage());
    } catch (ESException e) {
      System.err.println(e.getMessage());
      if (verbose)
        e.printStackTrace();
      else
        e.printESStackTrace();
    } catch (Throwable e) {
      System.out.println("Exception: " + e);
      e.printStackTrace();
    }
  }
}