/*
    * 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.myfaces.mc.test.core.runner;
  
  import java.io.IOException;
  import java.util.List;
  import javax.faces.FacesException;
  import javax.faces.application.Application;
  import javax.faces.context.ExternalContext;
  import javax.faces.context.FacesContext;
  import javax.servlet.ServletRequestEvent;
  import org.apache.myfaces.mc.test.core.mock.MockMyFacesClient;
  import org.apache.myfaces.mc.test.core.mock.ServletMockContainer;
  import org.apache.myfaces.mc.test.core.annotation.AfterRequest;
  import org.apache.myfaces.mc.test.core.annotation.BeforeRequest;
  import org.apache.myfaces.mc.test.core.annotation.TestConfig;
  import org.apache.myfaces.test.mock.MockHttpServletRequest;
  import org.apache.myfaces.test.mock.MockHttpServletResponse;
  import org.apache.myfaces.test.mock.MockHttpSession;
  import org.apache.myfaces.test.mock.MockHttpSessionProxy;
  import org.junit.runners.model.FrameworkMethod;
  import org.junit.runners.model.TestClass;
  
  /**
   *
   */
  public class AbstractJsfRequestTestContainer extends AbstractJsfTestContainer
      implements ServletMockContainer
  {
  
      public AbstractJsfRequestTestContainer(TestClass testClass)
      {
          super(testClass);
      }
      
      @Override
      public void setUp(Object testInstance)
      {
          super.setUp(testInstance);
          
      }
  
      @Override
      public void tearDown()
      {
          endRequest();
          session = null;
          lastSession = null;
          if (client != null)
          {
              client.setTestCase(null);
          }
          client = null;
          super.tearDown();
      }
  
      protected void setupRequest()
      {
          setupRequest(null);
      }
  
      protected void setupRequest(String pathInfo)
      {
          if (pathInfo == null)
          {
              setupRequest(null, null);
          }
          else
          {
              int queryIndex = pathInfo.indexOf("?");
              if (queryIndex >= 0) 
              {
                  setupRequest(pathInfo.substring(0,queryIndex), pathInfo.substring(queryIndex+1));
              }
              else
              {
                  setupRequest(pathInfo, null);
              }
          }
      }
  
      protected void setupRequest(String pathInfo, String query)
      {
         if (request != null)
         {
             //tear down previous request
             endRequest();
         }
         request = lastSession == null ? 
             new MockHttpServletRequest() : new MockHttpServletRequest(lastSession);
         request.setServletContext(servletContext);
         requestInitializedCalled = false;
         if (session == null)
         {
             session = new MockHttpSessionProxy(servletContext, request);
         }
         else
         {
             session.setRequest(request);
         }
         session.setServletContext(servletContext);
         response = new MockHttpServletResponse();
         //TODO check if this is correct
         request.setPathElements(getContextPath(), getServletPath(), pathInfo, query);
 
         facesContext = facesContextFactory.getFacesContext(
             servletContext, request, response, lifecycle);
         externalContext = facesContext.getExternalContext();
         application = facesContext.getApplication();
         if (client != null)
         {
             client.apply(request);
             client.reset(facesContext);
         }
         else
         {
             client = createClient();
         }
     }
     
     protected MockMyFacesClient createClient()
     {
         return new MockMyFacesClient(facesContext, this);
     }
 
     /**
      * This method call startViewRequest(viewId) and doRequestInitialized()
      */
     public final void startViewRequest(String viewId)
     {
         setupRequest(viewId);
         doRequestInitialized();
     }
     
     /**
      * This method call startViewRequest(null) and doRequestInitialized()
      */
     public final void startRequest()
     {
         startViewRequest(null);
         doRequestInitialized();
     }
     
     public void doRequestInitialized()
     {
         if (!requestInitializedCalled)
         {
             List<FrameworkMethod> beforeRequestMethods = testClass.getAnnotatedMethods(BeforeRequest.class);
             if (beforeRequestMethods != null && !beforeRequestMethods.isEmpty())
             {
                 for (FrameworkMethod fm : beforeRequestMethods)
                 {
                     try
                     {
                         fm.invokeExplosively(testInstance);
                     }
                     catch (Throwable ex)
                     {
                         throw new FacesException(ex);
                     }
                 }
             }
             
             webContainer.requestInitialized(new ServletRequestEvent(servletContext, request));
             requestInitializedCalled = true;
         }
     }
     
     /**
      * This method call doRequestDestroyed() and then tearDownRequest(). 
      */
     public final void endRequest()
     {
         doRequestDestroyed();
         tearDownRequest();
     }
     
     public void doRequestDestroyed()
     {
         if (request != null)
         {
             List<FrameworkMethod> afterRequestMethods = testClass.getAnnotatedMethods(AfterRequest.class);
             if (afterRequestMethods != null && !afterRequestMethods.isEmpty())
             {
                 for (FrameworkMethod fm : afterRequestMethods)
                 {
                     try
                     {
                         fm.invokeExplosively(testInstance);
                     }
                     catch (Throwable ex)
                     {
                         throw new FacesException(ex);
                     }
                 }
             }
             lastSession = (MockHttpSession) request.getSession(false);
             webContainer.requestDestroyed(new ServletRequestEvent(servletContext, request));
         }
     }
     
     protected void tearDownRequest()
     {
         if (facesContext != null)
         {
             facesContext.release();
         }
         facesContext = null;
         externalContext = null;
         application = null;
         
         response = null;
         request = null;
         //session = null;
     }
     
     protected String getContextPath()
     {
         TestConfig testConfig = getTestJavaClass().getAnnotation(TestConfig.class);
         if (testConfig != null)
         {
             return testConfig.contextPath();
         }
         return "/test";
     }
     
     protected String getServletPath()
     {
         TestConfig testConfig = getTestJavaClass().getAnnotation(TestConfig.class);
         if (testConfig != null)
         {
             return testConfig.servletPath();
         }
         return "/faces";
     }
 
     public void processLifecycleExecute()
     {
         processLifecycleExecute(facesContext);
     }
 
     public void processLifecycleRender()
     {
         processLifecycleRender(facesContext);
     }
     
     public void processLifecycleExecuteAndRender()
     {
         processLifecycleExecute();
         renderResponse();
     }
 
     public void restoreView()
     {
         restoreView(facesContext);
     }
     
     public void applyRequestValues()
     {
         applyRequestValues(facesContext);
     }
 
     public void processValidations()
     {
         processValidations(facesContext);
     }
 
     public void updateModelValues()
     {
         updateModelValues(facesContext);
 
     }
 
     public void invokeApplication()
     {
         invokeApplication(facesContext);
     }
     
     public void renderResponse()
     {
         renderResponse(facesContext);
     }
     
     public void processRemainingExecutePhases()
     {
         processRemainingExecutePhases(facesContext);
     }
 
     public void processRemainingPhases()
     {
         processRemainingPhases(facesContext);
     }
     
     public void executeBeforeRender()
     {
         executeBeforeRender(facesContext);
     }
     
     public void executeViewHandlerRender()
     {
         executeViewHandlerRender(facesContext);
     }
         
     public void executeBuildViewCycle()
     {
         executeBuildViewCycle(facesContext);
     }
     
     public void executeAfterRender()
     {
         executeAfterRender(facesContext);
     }
     
     public String getRenderedContent() throws IOException
     {
         return getRenderedContent(facesContext);
     }
     
     protected MockMyFacesClient client = null;
     
     // Servlet objects 
     protected MockHttpServletRequest request = null;
     protected boolean requestInitializedCalled = false;
     protected MockHttpServletResponse response = null;
     protected MockHttpSessionProxy session = null;
     protected MockHttpSession lastSession = null;
     
     protected Application application = null;
     protected ExternalContext externalContext = null;
     protected FacesContext facesContext = null;
 
     @Override
     public MockHttpServletRequest getRequest()
     {
         return request;
     }
 
     @Override
     public MockHttpServletResponse getResponse()
     {
         return response;
     }
 
     @Override
     public FacesContext getFacesContext()
     {
         return facesContext;
     }
 
     public MockMyFacesClient getClient()
     {
         return client;
     }
 
     public Application getApplication()
     {
         return application;
     }
 
     public ExternalContext getExternalContext()
     {
         return externalContext;
     }
 
 }