/**

  * Back 2 Browser Bytecode Translator

  * Copyright (C) 2012 Jaroslav Tulach <jaroslav.tulach@apidesign.org>

  *

  * This program 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, version 2 of the License.

  *

  * This program 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.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program. Look for COPYING file in the top folder.

  * If not, see http://opensource.org/licenses/GPL-2.0.

  */

 package org.apidesign.bck2brwsr.launcher.fximpl;

 import com.sun.javafx.scene.web.Debugger;

 import java.io.File;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.InterruptedIOException;

 import java.io.OutputStream;

 import java.io.UnsupportedEncodingException;

 import java.lang.reflect.Method;

 import java.util.concurrent.ArrayBlockingQueue;

 import java.util.concurrent.Executors;

 import java.util.concurrent.TimeUnit;

 import java.util.concurrent.atomic.AtomicReference;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javafx.application.Platform;

 import javafx.util.Callback;

 /** Simulates WebKit protocol over WebSockets.

  *

  * @author Jaroslav Tulach

  */

 abstract class WebDebug extends OutputStream 

 implements Callback<String, Void>, Runnable {

     private static final Logger LOG = Logger.getLogger(WebDebug.class.getName());

     private final Debugger debug;

     private final StringBuilder cmd = new StringBuilder();

     private final ToDbgInputStream toDbg;

     private final String ud;

     WebDebug(Debugger debug, String ud) throws Exception {

         this.debug = debug;

         this.ud = ud;

         toDbg = new ToDbgInputStream();

         debug.setEnabled(true);

         debug.setMessageCallback(this);

     }

     static WebDebug create(Debugger debug, String ud) throws Exception {

         WebDebug web = new WebDebug(debug, ud) {};

         Executors.newFixedThreadPool(1).execute(web);

         return web;

     }

     @Override

     public void run() {

         try {

             String p = System.getProperty("startpage.file");

             File f;

             if (p != null && (f = new File(p)).exists()) {

                 String[] args = {"--livehtml", f.getAbsolutePath()};

                 File dir = f.getParentFile();

                 cliHandler(args, toDbg, this, System.err, dir);

             }

         } catch (Exception ex) {

             LOG.log(Level.SEVERE, null, ex);

         }

     }

     @Override

     public void close() {

         try {

             toDbg.close();

         } catch (IOException ex) {

             LOG.log(Level.SEVERE, null, ex);

         }

     }

     @Override

     public Void call(String p) {

         assert p.indexOf('\n') == -1 : "No new line: " + p;

         LOG.log(Level.INFO, "toDbgr: {0}", p);

         toDbg.pushMsg(p);

         return null;

     }

     @Override

     public void write(int b) throws IOException {

         if (b == '\n') {

             final String msg = cmd.toString();

             Platform.runLater(new Runnable() {

                 @Override

                 public void run() {

                     LOG.log(Level.INFO, "toView: {0}", msg);

                     debug.sendMessage(msg);

                 }

             });

             cmd.setLength(0);

         } else {

             if (cmd.length() > 100000) {

                 LOG.log(Level.WARNING, "Too big:\n{0}", cmd);

             }

             cmd.append((char)b);

         }

     }   

     private void cliHandler(

         String[] args, InputStream is, OutputStream os, OutputStream err, File dir

     ) {

         try {

             Class<?> main = Class.forName("org.netbeans.MainImpl");

             Method m = main.getDeclaredMethod("execute", String[].class, InputStream.class, 

                 OutputStream.class, OutputStream.class, AtomicReference.class

             );

             m.setAccessible(true);

             System.setProperty("netbeans.user", ud);

             int ret = (Integer)m.invoke(null, args, is, os, err, null);

             LOG.log(Level.INFO, "Return value: {0}", ret);

         } catch (Exception ex) {

             LOG.log(Level.SEVERE, null, ex);

         } finally {

             LOG.info("Communication is over");

         }

     }

     private class ToDbgInputStream extends InputStream {

         private byte[] current;

         private int currentPos;

         private final ArrayBlockingQueue<byte[]> pending = new ArrayBlockingQueue<byte[]>(64);

         public ToDbgInputStream() {

         }

         @Override

         public int read() throws IOException {

             return read(null, 0, 1);

         }

         @Override

         public int read(byte[] arr, int offset, int len) throws IOException {

             if (current == null || current.length <= currentPos) {

                 for (;;) {

                     WebDebug.this.flush();

                     try {

                         current = pending.poll(5, TimeUnit.MILLISECONDS);

                         if (current == null) {

                             return 0;

                         }

                         break;

                     } catch (InterruptedException ex) {

                         throw (InterruptedIOException)new InterruptedIOException().initCause(ex);

                     }

                 }

                 LOG.info("Will return: " + new String(current));

                 currentPos = 0;

             }

             int cnt = 0;

             while (len-- > 0 && currentPos < current.length) {

                 final byte nextByte = current[currentPos++];

                 if (arr == null) {

                     return nextByte;

                 }

                 arr[offset + cnt++] = nextByte;

             }

             LOG.log(Level.INFO, "read returns: {0}", new String(arr, offset, cnt));

             return cnt;

         }

         private void pushMsg(String p) {

             try {

                 pending.offer((p + '\n').getBytes("UTF-8"));

             } catch (UnsupportedEncodingException ex) {

                 throw new IllegalStateException(ex);

             }

         }

     }

 }