/*
    *  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.mina.proxy.session;
  
  import java.net.InetSocketAddress;
  import java.nio.charset.Charset;
  import java.util.List;
  
  import org.apache.mina.core.session.IoSession;
  import org.apache.mina.proxy.ProxyConnector;
  import org.apache.mina.proxy.ProxyLogicHandler;
  import org.apache.mina.proxy.event.IoSessionEventQueue;
  import org.apache.mina.proxy.filter.ProxyFilter;
  import org.apache.mina.proxy.handlers.ProxyRequest;
  import org.apache.mina.proxy.handlers.http.HttpAuthenticationMethods;
  import org.apache.mina.proxy.handlers.http.HttpSmartProxyHandler;
  
  /**
   * ProxyIoSession.java - Class that contains all informations for the current proxy 
   * authentication session.
   * 
   * @author <a href="http://mina.apache.org">Apache MINA Project</a>
   * @since MINA 2.0.0-M3
   */
  public class ProxyIoSession {
      /** The proxy session name */
      public static final String PROXY_SESSION = ProxyConnector.class.getName() + ".ProxySession";
  
      private static final String DEFAULT_ENCODING = "ISO-8859-1";
  
      /**
       * The list contains the authentication methods to use. 
       * The order in the list is revelant : if first method is available 
       * then it will be used etc ...
       */
      private List<HttpAuthenticationMethods> preferedOrder;
  
      /**
       * The request to send to the proxy.
       */
      private ProxyRequest request;
  
      /**
       * The currently selected proxy handler. 
       */
      private ProxyLogicHandler handler;
  
      /**
       * Parent {@link ProxyFilter} handling the session.
       */
      private ProxyFilter proxyFilter;
  
      /**
       * The session.
       */
      private IoSession session;
  
      /**
       * The proxy connector.
       */
      private ProxyConnector connector;
  
      /**
       * Address of the proxy server.
       */
      private InetSocketAddress proxyAddress = null;
  
      /**
       * A flag that indicates that the proxy closed the connection before handshake 
       * is done. So we need to reconnect to the proxy to continue the handshaking 
       * process.  
       */
      private boolean reconnectionNeeded = false;
  
      /**
       * Name of the charset used for string encoding & decoding.
       */
      private String charsetName;
  
      /**
       * The session event queue.
       */
     private IoSessionEventQueueQueue.html#IoSessionEventQueue">IoSessionEventQueue eventQueue = new IoSessionEventQueue(this);
 
     /**
      * Set to true when an exception has been thrown or if authentication failed.
      */
     private boolean authenticationFailed;
 
     /**
      * Constructor.
      * 
      * @param proxyAddress the IP address of the proxy server
      * @param request the proxy request
      */
     public ProxyIoSession(InetSocketAddress proxyAddress, ProxyRequest request) {
         setProxyAddress(proxyAddress);
         setRequest(request);
     }
 
     /**
      * @return the pending event queue.
      */
     public IoSessionEventQueue getEventQueue() {
         return eventQueue;
     }
 
     /**
      * @return the list of the prefered order for the authentication methods.
      * This list is used by the {@link HttpSmartProxyHandler} to determine
      * which authentication mechanism to use first between those accepted by the
      * proxy server. This list is only used when connecting to an http proxy.
      */
     public List<HttpAuthenticationMethods> getPreferedOrder() {
         return preferedOrder;
     }
 
     /**
      * Sets the ordered list of prefered authentication mechanisms.
      * 
      * @param preferedOrder the ordered list
      */
     public void setPreferedOrder(List<HttpAuthenticationMethods> preferedOrder) {
         this.preferedOrder = preferedOrder;
     }
 
     /**
      * @return the {@link ProxyLogicHandler} currently in use.
      */
     public ProxyLogicHandler getHandler() {
         return handler;
     }
 
     /**
      * Sets the {@link ProxyLogicHandler} to use.
      * 
      * @param handler the {@link ProxyLogicHandler} instance
      */
     public void setHandler(ProxyLogicHandler handler) {
         this.handler = handler;
     }
 
     /**
      * @return the {@link ProxyFilter}.
      */
     public ProxyFilter getProxyFilter() {
         return proxyFilter;
     }
 
     /**
      * Sets the {@link ProxyFilter}.
      * Note : Please do not call this method from your code it could result 
      * in an unexpected behaviour.
      * 
      * @param proxyFilter the filter
      */
     public void setProxyFilter(ProxyFilter proxyFilter) {
         this.proxyFilter = proxyFilter;
     }
 
     /**
      * @return the proxy request.
      */
     public ProxyRequest getRequest() {
         return request;
     }
 
     /**
      * Sets the proxy request.
      * 
      * @param request the proxy request
      */
     private void setRequest(ProxyRequest request) {
         if (request == null) {
             throw new IllegalArgumentException("request cannot be null");
         }
 
         this.request = request;
     }
 
     /**
      * @return the current {@link IoSession}.
      */
     public IoSession getSession() {
         return session;
     }
 
     /**
      * Sets the {@link IoSession} in use.
      * Note : Please do not call this method from your code it could result in an
      * unexpected behaviour.
      * 
      * @param session the current io session
      */
     public void setSession(IoSession session) {
         this.session = session;
     }
 
     /**
      * @return the proxy connector.
      */
     public ProxyConnector getConnector() {
         return connector;
     }
 
     /**
      * Sets the connector reference of this proxy session.
      * Note : Please do not call this method from your code it could result in an
      * unexpected behaviour.
      * 
      * @param connector the proxy connector
      */
     public void setConnector(ProxyConnector connector) {
         this.connector = connector;
     }
 
     /**
      * @return the IP address of the proxy server.
      */
     public InetSocketAddress getProxyAddress() {
         return proxyAddress;
     }
 
     /**
      * Sets the IP address of the proxy server.
      * 
      * @param proxyAddress the IP address of the proxy server
      */
     private void setProxyAddress(InetSocketAddress proxyAddress) {
         if (proxyAddress == null) {
             throw new IllegalArgumentException("proxyAddress object cannot be null");
         }
 
         this.proxyAddress = proxyAddress;
     }
 
     /**
      * @return true if the current authentication process is not finished
      * but the server has closed the connection.
      */
     public boolean isReconnectionNeeded() {
         return reconnectionNeeded;
     }
 
     /**
      * Sets the reconnection needed flag. If set to true, it means that an
      * authentication process is currently running but the proxy server did not
      * kept the connection alive. So we need to reconnect to the server to complete
      * the process.
      * Note : Please do not call this method from your code it could result in an
      * unexpected behaviour.
      * 
      * @param reconnectionNeeded the value to set the flag to
      */
     public void setReconnectionNeeded(boolean reconnectionNeeded) {
         this.reconnectionNeeded = reconnectionNeeded;
     }
 
     /**
      * @return a charset instance of the in use charset name.
      */
     public Charset getCharset() {
         return Charset.forName(getCharsetName());
     }
 
     /**
      * @return the used charset name or DEFAULT_ENCODING if null.
      */
     public String getCharsetName() {
         if (charsetName == null) {
             charsetName = DEFAULT_ENCODING;
         }
 
         return charsetName;
     }
 
     /**
      * Sets the charset to use.
      * 
      * @param charsetName the charset name
      */
     public void setCharsetName(String charsetName) {
         this.charsetName = charsetName;
     }
 
     /**
      * @return true if authentication failed.
      */
     public boolean isAuthenticationFailed() {
         return authenticationFailed;
     }
 
     /**
      * Sets the authentication failed flag.
      * 
      * @param authenticationFailed the value to set the flag to
      */
     public void setAuthenticationFailed(boolean authenticationFailed) {
         this.authenticationFailed = authenticationFailed;
     }
 }