/*
 * (C) Copyright 2006-2012 Nuxeo SA (http://nuxeo.com/) and others.
 *
 * Licensed 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.
 *
 * Contributors:
 *     bstefanescu
 *
 */

package org.nuxeo.ecm.webengine.model;

import java.io.Writer;
import java.security.Principal;
import java.text.ParseException;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.UriInfo;

import org.apache.commons.logging.Log;
import org.nuxeo.ecm.core.api.CoreSession;
import org.nuxeo.ecm.core.api.DocumentModel;
import org.nuxeo.ecm.webengine.WebEngine;
import org.nuxeo.ecm.webengine.WebException;
import org.nuxeo.ecm.webengine.forms.FormData;
import org.nuxeo.ecm.webengine.scripting.ScriptFile;
import org.nuxeo.ecm.webengine.session.UserSession;
import org.nuxeo.runtime.model.Adaptable;

import com.sun.jersey.api.core.HttpContext;
import com.sun.jersey.server.impl.inject.ServerInjectableProviderContext;

/**
 * @author <a href="mailto:bs@nuxeo.com">Bogdan Stefanescu</a>
 */
public interface WebContext extends Adaptable {

    /**
     * <p>
     * This variable is used in a proxy setting. The proxy should send a header with this name. Webengine will assume
     * that the base path of the application is this value.
     * <p>
     * If your application is on server localhost:8080/nuxeo/site/myapp and you proxy it via mysite.com/myapp, then the
     * header should have an empty string value.
     */
    String NUXEO_WEBENGINE_BASE_PATH = "nuxeo-webengine-base-path";

    /**
     * Gets the current web application.
     *
     * @return the web root. Cannot return null.
     */
    Module getModule();

    /**
     *
     * Gets the jersey server injection context
     *
     * @since 9.1
     */
    ServerInjectableProviderContext getServerInjectableProviderContext();

    /**
     * Gets the jersey server http context
     *
     * @since 9.1
     */
    HttpContext getServerHttpContext();

    /**
     * Gets the root resource if any resource was defined as being the root
     * <p>
     * A root resource can be any resource from the resource chain.
     *
     * @return the root resource or null if no root was defined
     */
    Resource getRoot();

    /**
     * Set the root resource of this context
     */
    void setRoot(Resource root);

    /**
     * Gets the i18n message for the given key.
     * <p>
     * The current module i18n messages are queried first then if no message is found the global message pool is queried
     * (the one living in WEB-INF/i18n). If no message is found the key surrounded by exclamation marks is returned.
     *
     * @param key the message key
     * @return the message
     */
    String getMessage(String key);

    /**
     * The same as {@link #getMessage(String)} but with parameter support
     */
    String getMessage(String key, Object... args);

    /**
     * The same as {@link #getMessage(String)} but with parameter support
     */
    String getMessage(String key, List<Object> args);

    /**
     * Same as {@link #getMessage(String)} but uses the given locale.
     *
     * @param key the message key
     * @param locale the locale to use
     * @return the message
     */
    String getMessageL(String key, String locale);

    /**
     * The same as {@link #getMessage(String)} but uses the given locale, with parameter support
     */
    String getMessageL(String key, String locale, Object... args);

    /**
     * The same as {@link #getMessage(String)} but uses the given locale, with parameter support.
     */
    String getMessageL(String key, String locale, List<Object> args);

    /**
     * Gets the context locale.
     * <p>
     * If the locale has been set using {@link #setLocale(Locale)}, returns the last locale set. Otherwise, compute it
     * from the Accept-Language language sent by the client, using {@link HttpServletRequest#getLocale()}.
     *
     * @return the context locale
     */
    Locale getLocale();

    /**
     * Sets the current locale, that will be kept in context.
     */
    void setLocale(Locale locale);

    /**
     * Gets the web engine instance.
     *
     * @return the web engine instance. Cannot return null
     */
    WebEngine getEngine();

    /**
     * Gets the current user session.
     * <p>
     * The user session is a WebEngine abstraction for the current user session and can be used to retrieve current
     * login, core session, and to set or get user session variables.
     *
     * @return the user session. Never returns null.
     */
    UserSession getUserSession();

    /**
     * Gets the Core Session (or Repository Session) corresponding to that request.
     *
     * @return the core session. Cannot return null
     */
    CoreSession getCoreSession();

    /**
     * Gets the principal identifying the user that originated the request.
     *
     * @return the current principal. Can return null if the user has not been authenticated.
     */
    Principal getPrincipal();

    /**
     * Gets the JAX-RS UriInfo.
     *
     * @return the uri info
     */
    UriInfo getUriInfo();

    /**
     * Gets HTTP Headers as defined by JAX-RS.
     *
     * @return HTTP headers object
     */
    HttpHeaders getHttpHeaders();

    /**
     * Gets the underlying HTTP servlet request object.
     *
     * @return the HTTP Request object. Cannot return null
     */
    HttpServletRequest getRequest();

    /**
     * Get HTTP Method.
     *
     * @return the method
     */
    String getMethod();

    /**
     * Gets the representation of the data form submitted by the user.
     * <p>
     * This provides access to both POST and GET parameters, or to multipart form data requests.
     *
     * @return the request form data. Cannot return null
     */
    FormData getForm();

    /**
     * Gets the URL requested by the client. Same as {@link HttpServletRequest#getRequestURL()}.
     *
     * @return the request URL. Cannot return null.
     */
    String getURL();

    /**
     * Returns the part of this request's URL from the protocol name up to the query string in the first line of the
     * HTTP request. This is the same as {@link HttpServletRequest#getRequestURI()}.
     *
     * @return the request URI. Cannot return null.
     */
    String getURI();

    /**
     * Gets the path portion of the request URL.
     *
     * @return the path portion of the request URL. Cannot return null.
     */
    String getUrlPath();

    /**
     * Gets the login path for the current context.
     * <p>
     * This is the path you can use as a login form action to perform a login or a logout. After the login/logout is
     * done the current page in that context will be served.
     */
    String getLoginPath();

    /**
     * Get the path prefix that identify the current web application.
     * <p>
     * The application path will include the base path (context + servlet path).
     *
     * @return the application path. Cannot be null
     */
    String getModulePath();

    /**
     * Gets the path of the servlet. Same as servlet context path + servlet path.
     *
     * @return the site path
     */
    String getBasePath();

    /**
     * Gets the URL of the base path. This is the same as {@link #getURL()} after removing the path segments over the
     * base path.
     *
     * @return the base URL
     */
    String getBaseURL();

    /**
     * Gets the server URL without any path or trailing /. The returned string builder can be used to build the wanted
     * URL. If the server is behind a proxy, return the server url of the proxy so writing the url in a webpage is safe.
     *
     * @return a string builder
     */
    StringBuilder getServerURL();

    /**
     * Get a suitable URI path for the given Nuxeo document, that can be used to invoke this document. This method is
     * working only for root objects that implement {@link ModuleResource}
     *
     * @param document the nuxeo document
     * @return the path if any or null if no suitable path can be found XXX can this method return null?
     * @throws ClassCastException if the module root does not implementing {@link ModuleResource}
     */
    // TODO: should we remove this method from the context and create a
    // specialized service to resolve document models to paths?
    String getUrlPath(DocumentModel document);

    /**
     * Sets a context variable.
     *
     * @param key the variable key
     * @param value the variable value
     * @see #getProperty(String)
     */
    void setProperty(String key, Object value);

    /**
     * Gets a context variable.
     * <p>
     * Context variables can be used to share data between the scripts that are called in that request (and between Java
     * code too of course).
     *
     * @param key the variable key
     * @return the variable value or null if none
     */
    Object getProperty(String key);

    /**
     * Gets a context variable.
     * <p>
     * Context variables can be used to share data between the scripts that are called in that request (and between java
     * code too of course).
     *
     * @param key the variable key
     * @param defaultValue the default value to use if the property doesn't exists
     * @return the variable value or the given default value if none
     */
    Object getProperty(String key, Object defaultValue);

    /**
     * Convenience method to get a cookie value.
     *
     * @param name the cookie name
     * @return the cookie value if any null otherwise
     */
    String getCookie(String name);

    /**
     * Convenience method to get a cookie value using a default value.
     *
     * @param name the cookie name
     * @param defaultValue the value to return when cookie is not set
     * @return the cookie value if any or the default if none
     */
    String getCookie(String name, String defaultValue);

    /**
     * Gets a logger to be used by scripts for logging.
     *
     * @return a logger
     */
    Log getLog();

    Resource newObject(String typeName, Object... args);

    Resource newObject(ResourceType type, Object... args);

    AdapterResource newAdapter(Resource ctx, String adapterName, Object... args);

    /* object stack API */

    Resource push(Resource obj);

    Resource pop();

    Resource tail();

    Resource head();

    Resource getTargetObject();

    AdapterResource getTargetAdapter();

    /* template and script resolver */

    /**
     * Resolves the given path into a file.
     * <p>
     * The path is resolved as following:
     * <ol>
     * <li>if the path begin with a dot '.' then a local path is assumed and the path will be resolved relative to the
     * current executed script if any. Note that the directory stack will be consulted as well. If there is no current
     * executed script then the path will be transformed into an absolute path and next step is entered.
     * <li>the resolving is delegated to the current {@link Module#getFile(String)} that will try to resolve the path
     * relative to each directory in the directory stack
     * </ol>
     *
     * @param path the path to resolve into a file
     * @return the file or null if the path couldn't be resolved
     */
    ScriptFile getFile(String path);

    /* running scripts and rendering templates */

    /**
     * Renders the given template using the rendering engine registered in that web engine.
     * <p>
     * This is similar to the {@link #render(String, Object, Writer)} method with a null value for the <i>args</i>
     * argument.
     *
     * @param template the template to render. Can be a path absolute to the web directory or relative to the caller
     *            script if any.
     * @param writer the writer to use
     * @see #render(String, Object, Writer)
     */
    void render(String template, Writer writer);

    /**
     * Renders the given template using the rendering engine registered in that web engine. The given arguments are
     * passed to the rendering process as context variables
     *
     * @param template the template to render
     * @param args the arguments to pass
     * @param writer the writer to use
     * @throws WebException
     */
    void render(String template, Object args, Writer writer);

    /**
     * Renders the given template using the rendering engine registered in that web engine.
     * <p>
     * The given arguments are passed to the rendering process as context variables.
     *
     * @param script the template to render
     * @param args the arguments to pass
     * @param writer the writer to use
     * @throws WebException
     */
    void render(ScriptFile script, Object args, Writer writer);

    /**
     * Runs the given script.
     *
     * @param script the script path. Can be a path absolute to the web directory or relative to the caller script if
     *            any.
     * @param args the arguments to pass
     */
    Object runScript(String script, Map<String, Object> args);

    /**
     * Runs the given script.
     * <p>
     * This is similar to {@link #runScript(String, Map)} with a null value for the <i>args</i> argument
     *
     * @param script the script path. Can be a path absolute to the web directory or relative to the caller script if
     *            any.
     * @see #runScript(String, Map)
     */
    Object runScript(String script);

    /**
     * Runs the script using given arguments
     * <p>
     * This is similar to {@link #runScript(String, Map)} with a null value for the <i>args</i> argument
     *
     * @param script the script path. Can be a path absolute to the web directory or relative to the caller script if
     *            any.
     * @param args a map of arguments
     * @see #runScript(String, Map)
     */
    Object runScript(ScriptFile script, Map<String, Object> args);

    /**
     * Check the given expression in this context and return true if the expression is verified or false otherwise. Any
     * valid guard expression is accepted
     *
     * @see org.nuxeo.ecm.webengine.security.Guard
     * @param guard the guard to check
     */
    boolean checkGuard(String guard) throws ParseException;

    /**
     * Sets the repository name that will be used by {@link #getCoreSession()}.
     *
     * @param repoName
     * @throws IllegalArgumentException if the repository is not found.
     * @since 5.7.3
     */
    void setRepositoryName(String repoName);

}