/**

 * HTML via Java(tm) Language Bindings

 * Copyright (C) 2013 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. apidesign.org

 * designates this particular file as subject to the

 * "Classpath" exception as provided by apidesign.org

 * in the License file that accompanied this code.

 *

 * 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://wiki.apidesign.org/wiki/GPLwithClassPathException

 */

package org.apidesign.html.wstyrus;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.Reader;

import java.net.URI;

import java.net.URISyntaxException;

import java.util.ArrayList;

import java.util.List;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.glassfish.grizzly.PortRange;

import org.glassfish.grizzly.http.server.HttpHandler;

import org.glassfish.grizzly.http.server.HttpServer;

import org.glassfish.grizzly.http.server.NetworkListener;

import org.glassfish.grizzly.http.server.Request;

import org.glassfish.grizzly.http.server.Response;

import org.glassfish.grizzly.http.server.ServerConfiguration;

import org.glassfish.grizzly.websockets.WebSocket;

import org.glassfish.grizzly.websockets.WebSocketAddOn;

import org.glassfish.grizzly.websockets.WebSocketApplication;

import org.glassfish.grizzly.websockets.WebSocketEngine;

/**

 *

 * @author Jaroslav Tulach <jtulach@netbeans.org>

 */

final class TyrusDynamicHTTP extends HttpHandler {

    private static int resourcesCount;

    private static List<Resource> resources;

    private static ServerConfiguration conf;

    private static HttpServer server;

    private TyrusDynamicHTTP() {

    }

    static URI initServer() throws Exception {

        server = HttpServer.createSimpleServer(null, new PortRange(8080, 65535));

        final WebSocketAddOn addon = new WebSocketAddOn();

        for (NetworkListener listener : server.getListeners()) {

            listener.registerAddOn(addon);

        }        

        resources = new ArrayList<Resource>();

        conf = server.getServerConfiguration();

        final TyrusDynamicHTTP dh = new TyrusDynamicHTTP();

        conf.addHttpHandler(dh, "/");

        server.start();

        return pageURL("http", server, "/test.html");

    }

    @Override

    public void service(Request request, Response response) throws Exception {

        if ("/test.html".equals(request.getRequestURI())) {

            response.setContentType("text/html");

            final InputStream is = TyrusDynamicHTTP.class.getResourceAsStream("test.html");

            copyStream(is, response.getOutputStream(), null);

            return;

        }

        if ("/dynamic".equals(request.getRequestURI())) {

            String mimeType = request.getParameter("mimeType");

            List<String> params = new ArrayList<String>();

            boolean webSocket = false;

            for (int i = 0;; i++) {

                String p = request.getParameter("param" + i);

                if (p == null) {

                    break;

                }

                if ("protocol:ws".equals(p)) {

                    webSocket = true;

                    continue;

                }

                params.add(p);

            }

            final String cnt = request.getParameter("content");

            String mangle = cnt.replace("%20", " ").replace("%0A", "\n");

            ByteArrayInputStream is = new ByteArrayInputStream(mangle.getBytes("UTF-8"));

            URI url;

            final Resource res = new Resource(is, mimeType, "/dynamic/res" + ++resourcesCount, params.toArray(new String[params.size()]));

            if (webSocket) {

                url = registerWebSocket(res);

            } else {

                url = registerResource(res);

            }

            response.getWriter().write(url.toString());

            response.getWriter().write("\n");

            return;

        }

        for (Resource r : resources) {

            if (r.httpPath.equals(request.getRequestURI())) {

                response.setContentType(r.httpType);

                r.httpContent.reset();

                String[] params = null;

                if (r.parameters.length != 0) {

                    params = new String[r.parameters.length];

                    for (int i = 0; i < r.parameters.length; i++) {

                        params[i] = request.getParameter(r.parameters[i]);

                        if (params[i] == null) {

                            if ("http.method".equals(r.parameters[i])) {

                                params[i] = request.getMethod().toString();

                            } else if ("http.requestBody".equals(r.parameters[i])) {

                                Reader rdr = request.getReader();

                                StringBuilder sb = new StringBuilder();

                                for (;;) {

                                    int ch = rdr.read();

                                    if (ch == -1) {

                                        break;

                                    }

                                    sb.append((char) ch);

                                }

                                params[i] = sb.toString();

                            }

                        }

                        if (params[i] == null) {

                            params[i] = "null";

                        }

                    }

                }

                copyStream(r.httpContent, response.getOutputStream(), null, params);

            }

        }

    }

    private URI registerWebSocket(Resource r) {

        WebSocketEngine.getEngine().register("", r.httpPath, new WS(r));

        return pageURL("ws", server, r.httpPath);

    }

    private URI registerResource(Resource r) {

        if (!resources.contains(r)) {

            resources.add(r);

            conf.addHttpHandler(this, r.httpPath);

        }

        return pageURL("http", server, r.httpPath);

    }

    private static URI pageURL(String proto, HttpServer server, final String page) {

        NetworkListener listener = server.getListeners().iterator().next();

        int port = listener.getPort();

        try {

            return new URI(proto + "://localhost:" + port + page);

        } catch (URISyntaxException ex) {

            throw new IllegalStateException(ex);

        }

    }

    static final class Resource {

        final InputStream httpContent;

        final String httpType;

        final String httpPath;

        final String[] parameters;

        Resource(InputStream httpContent, String httpType, String httpPath,

            String[] parameters) {

            httpContent.mark(Integer.MAX_VALUE);

            this.httpContent = httpContent;

            this.httpType = httpType;

            this.httpPath = httpPath;

            this.parameters = parameters;

        }

    }

    static void copyStream(InputStream is, OutputStream os, String baseURL, String... params) throws IOException {

        for (;;) {

            int ch = is.read();

            if (ch == -1) {

                break;

            }

            if (ch == '$' && params.length > 0) {

                int cnt = is.read() - '0';

                if (baseURL != null && cnt == 'U' - '0') {

                    os.write(baseURL.getBytes("UTF-8"));

                } else {

                    if (cnt >= 0 && cnt < params.length) {

                        os.write(params[cnt].getBytes("UTF-8"));

                    } else {

                        os.write('$');

                        os.write(cnt + '0');

                    }

                }

            } else {

                os.write(ch);

            }

        }

    }

    private static class WS extends WebSocketApplication {

        private final Resource r;

        private WS(Resource r) {

            this.r = r;

        }

        @Override

        public void onMessage(WebSocket socket, String text) {

            try {

                r.httpContent.reset();

                ByteArrayOutputStream out = new ByteArrayOutputStream();

                copyStream(r.httpContent, out, null, text);

                String s = new String(out.toByteArray(), "UTF-8");

                socket.send(s);

            } catch (IOException ex) {

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

            }

        }

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

    }

}