/*

   * Licensed to the Apache Software Foundation (ASF) under one or more

   * contributor license agreements.  See the NOTICE file distributed with

   * this work for additional information regarding copyright ownership.

   * The ASF licenses this file to You under the Apache License, Version 2.0

   * (the "License"); you may not use this file except in compliance with

   * the License.  You may obtain a copy of the License at

   *

   *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.sling.api.servlets;

 import java.io.IOException;

 import java.io.OutputStreamWriter;

 import java.io.PrintWriter;

 import java.io.UnsupportedEncodingException;

 import java.lang.reflect.Method;

 import java.lang.reflect.Modifier;

 import java.util.Enumeration;

 import java.util.HashMap;

 import java.util.Map;

 import javax.servlet.GenericServlet;

 import javax.servlet.ServletException;

 import javax.servlet.ServletOutputStream;

 import javax.servlet.ServletRequest;

 import javax.servlet.ServletResponse;

 import javax.servlet.http.HttpServletResponse;

 import org.apache.sling.api.SlingHttpServletRequest;

 import org.apache.sling.api.SlingHttpServletResponse;

 import org.apache.sling.api.wrappers.SlingHttpServletResponseWrapper;

 public class SlingSafeMethodsServlet extends GenericServlet {

    

     protected void doHead(SlingHttpServletRequest request,

             SlingHttpServletResponse response) throws ServletException,

             IOException {

         // the null-output wrapper

         NoBodyResponse wrappedResponse = new NoBodyResponse(response);

         // do a normal get request, dropping the output

         doGet(request, wrappedResponse);

        // ensure the content length is set as gathered by the null-output

        wrappedResponse.setContentLength();

    }

    

    protected void doGet(SlingHttpServletRequest request,

            SlingHttpServletResponse response) throws ServletException,

            IOException {

        handleMethodNotImplemented(request, response);

    }

    

    protected void doOptions(SlingHttpServletRequest request,

            SlingHttpServletResponse response) throws ServletException,

            IOException {

        Map<String, Method> methods = getAllDeclaredMethods(getClass());

        StringBuffer allowBuf = getAllowedRequestMethods(methods);

        response.setHeader("Allow", allowBuf.toString());

    }

    

    protected void doTrace(SlingHttpServletRequest request,

            SlingHttpServletResponse response) throws ServletException,

            IOException {

        String CRLF = "\r\n";

        StringBuffer responseString = new StringBuffer();

        responseString.append("TRACE ").append(request.getRequestURI());

        responseString.append(' ').append(request.getProtocol());

        Enumeration<?> reqHeaderEnum = request.getHeaderNames();

        while (reqHeaderEnum.hasMoreElements()) {

            String headerName = (String) reqHeaderEnum.nextElement();

            Enumeration<?> reqHeaderValEnum = request.getHeaders(headerName);

            while (reqHeaderValEnum.hasMoreElements()) {

                responseString.append(CRLF);

                responseString.append(headerName).append(": ");

                responseString.append(reqHeaderValEnum.nextElement());

            }

        }

        responseString.append(CRLF);

        String charset = "UTF-8";

        byte[] rawResponse = responseString.toString().getBytes(charset);

        int responseLength = rawResponse.length;

        response.setContentType("message/http");

        response.setCharacterEncoding(charset);

        response.setContentLength(responseLength);

        ServletOutputStream out = response.getOutputStream();

        out.write(rawResponse);

    }

    

    protected void doGeneric(SlingHttpServletRequest request,

            SlingHttpServletResponse response) throws ServletException,

            IOException {

        handleMethodNotImplemented(request, response);

    }

    

    protected boolean mayService(SlingHttpServletRequest request,

            SlingHttpServletResponse response) throws ServletException,

            IOException {

        // assume the method is known for now

        boolean methodKnown = true;

        String method = request.getMethod();

        if (HttpConstants.METHOD_HEAD.equals(method)) {

            doHead(request, response);

        } else if (HttpConstants.METHOD_GET.equals(method)) {

            doGet(request, response);

        } else if (HttpConstants.METHOD_OPTIONS.equals(method)) {

            doOptions(request, response);

        } else if (HttpConstants.METHOD_TRACE.equals(method)) {

            doTrace(request, response);

        } else {

            // actually we do not know the method

            methodKnown = false;

        }

        // return whether we actually knew the request method or not

        return methodKnown;

    }

    

    protected void handleMethodNotImplemented(SlingHttpServletRequest request,

            SlingHttpServletResponse response) throws IOException {

        String protocol = request.getProtocol();

        String msg = "Method " + request.getMethod() + " not supported";

        if (protocol.endsWith("1.1")) {

            // for HTTP/1.1 use 405 Method Not Allowed

            response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);

        } else {

            // otherwise use 400 Bad Request

            response.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);

        }

    }

    

    protected void service(SlingHttpServletRequest request,

            SlingHttpServletResponse response) throws ServletException,

            IOException {

        // first try to handle the request by the known methods

        boolean methodKnown = mayService(request, response);

        // otherwise try to handle it through generic means

        if (!methodKnown) {

            doGeneric(request, response);

        }

    }

    

    public void service(ServletRequest req, ServletResponse res)

            throws ServletException, IOException {

        if ((req instanceof SlingHttpServletRequest)

            && (res instanceof SlingHttpServletResponse)) {

            service((SlingHttpServletRequest) req,

                (SlingHttpServletResponse) res);

        } else {

            throw new ServletException("Not a Sling HTTP request/response");

        }

    }

    

    public String getServletInfo() {

        return getClass().getSimpleName();

    }

    

    protected StringBuffer getAllowedRequestMethods(

            Map<String, Method> declaredMethods) {

        StringBuffer allowBuf = new StringBuffer();

        // OPTIONS and TRACE are always supported by this servlet

        allowBuf.append(HttpConstants.METHOD_OPTIONS);

        allowBuf.append(", ").append(HttpConstants.METHOD_TRACE);

        // add more method names depending on the methods found

        if (declaredMethods.containsKey("doHead")

            && !declaredMethods.containsKey("doGet")) {

            allowBuf.append(", ").append(HttpConstants.METHOD_HEAD);

        } else if (declaredMethods.containsKey("doGet")) {

            allowBuf.append(", ").append(HttpConstants.METHOD_GET);

            allowBuf.append(", ").append(HttpConstants.METHOD_HEAD);

        }

        return allowBuf;

    }

    

    private Map<String, Method> getAllDeclaredMethods(Class<?> c) {

        // stop (and do not include) the AbstractSlingServletClass

        if (c == null

            || c.getName().equals(SlingSafeMethodsServlet.class.getName())) {

            return new HashMap<String, Method>();

        }

        // get the declared methods from the base class

        Map<String, Method> methodSet = getAllDeclaredMethods(c.getSuperclass());

        // add declared methods of c (maybe overwrite base class methods)

        Method[] declaredMethods = c.getDeclaredMethods();

        for (Method method : declaredMethods) {

            // only consider public and protected methods

            if (Modifier.isProtected(method.getModifiers())

                || Modifier.isPublic(method.getModifiers())) {

                methodSet.put(method.getName(), method);

            }

        }

        return methodSet;

    }

    

    private class NoBodyResponse extends SlingHttpServletResponseWrapper {

        

        private NoBodyOutputStream noBody;

        

        private PrintWriter writer;

        

        private boolean didSetContentLength;

        NoBodyResponse(SlingHttpServletResponse wrappedResponse) {

            super(wrappedResponse);

            noBody = new NoBodyOutputStream();

        }

        

        void setContentLength() {

            if (!didSetContentLength) {

                setContentLength(noBody.getContentLength());

            }

        }

        

        public void setContentLength(int len) {

            super.setContentLength(len);

            didSetContentLength = true;

        }

        

        public ServletOutputStream getOutputStream() {

            return noBody;

        }

        

        public PrintWriter getWriter() throws UnsupportedEncodingException {

            if (writer == null) {

                OutputStreamWriter w;

                w = new OutputStreamWriter(noBody, getCharacterEncoding());

                writer = new PrintWriter(w);

            }

            return writer;

        }

    }

    

    private class NoBodyOutputStream extends ServletOutputStream {

        private int contentLength = 0;

        

        int getContentLength() {

            return contentLength;

        }

        public void write(int b) {

            contentLength++;

        }

        public void write(byte buf[], int offset, int len) {

            if (len >= 0) {

                contentLength += len;

            } else {

                throw new IndexOutOfBoundsException();

            }

        }

    }

}