/*

  * Copyright 2004-2011 the Seasar Foundation and the 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.

  */

 package org.seasar.teeda.core.context.servlet;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.Iterator;

 import java.util.List;

 import javax.faces.application.Application;

 import javax.faces.application.FacesMessage;

 import javax.faces.application.FacesMessage.Severity;

 import javax.faces.component.UIViewRoot;

 import javax.faces.context.ExternalContext;

 import javax.faces.context.FacesContext;

 import javax.faces.context.ResponseStream;

 import javax.faces.context.ResponseWriter;

 import javax.faces.internal.FactoryFinderUtil;

 import javax.faces.render.RenderKit;

 import org.seasar.framework.util.AssertionUtil;

 import org.seasar.teeda.core.context.Releaseable;

 import org.seasar.teeda.core.util.ApplicationUtil;

 /**

  * @author shot

  */

 public class ServletFacesContextImpl extends FacesContext {

     private ExternalContext externalContext;

     private Application application;

     private boolean released = false;

     private boolean renderResponse = false;

     private boolean responseComplete = false;

     private ResponseWriter responseWriter;

     private UIViewRoot root;

     private List messages;

     private List messageClientIds;

     private FacesMessage.Severity maxSeverity;

     private ResponseStream responseStream;

     public ServletFacesContextImpl(ExternalContext externalContext) {

         this.externalContext = externalContext;

         this.application = ApplicationUtil.getApplicationFromFactory();

         FacesContext.setCurrentInstance(this);

     }

     public Application getApplication() {

         assertNotReleased();

         return application;

     }

     public Iterator getClientIdsWithMessages() {

         assertNotReleased();

         if (messages == null) {

             return Collections.EMPTY_LIST.iterator();

         }

         return messageClientIds.iterator();

     }

     public ExternalContext getExternalContext() {

         assertNotReleased();

         return externalContext;

     }

     public Severity getMaximumSeverity() {

         assertNotReleased();

         return maxSeverity;

     }

     public Iterator getMessages() {

         assertNotReleased();

         return (messages != null) ? messages.iterator()

                 : Collections.EMPTY_LIST.iterator();

     }

     public Iterator getMessages(String clientId) {

         assertNotReleased();

         if (messages == null) {

             return Collections.EMPTY_LIST.iterator();

         }

         if (messages.size() != messageClientIds.size()) {

             throw new IllegalStateException();

         }

         List list = new ArrayList();

         for (int i = 0; i < messages.size(); i++) {

             String savedClientId = (String) messageClientIds.get(i);

             if (stringEquals(clientId, savedClientId)) {

                 list.add(messages.get(i));

             }

         }

         return list.iterator();

     }

     private boolean stringEquals(String a, String b) {

         if (a == null) {

             return b == null;

         }

         return a.equals(b);

     }

     public RenderKit getRenderKit() {

         assertNotReleased();

         UIViewRoot root = getViewRoot();

         if (root == null) {

             return null;

         }

         String renderKitId = root.getRenderKitId();

         if (renderKitId == null) {

             return null;

         }

         return FactoryFinderUtil.getRenderKitFactory().getRenderKit(this,

                 renderKitId);

     }

     public boolean getRenderResponse() {

         assertNotReleased();

         return renderResponse;

     }

     public boolean getResponseComplete() {

         assertNotReleased();

         return responseComplete;

     }

     public ResponseStream getResponseStream() {

         assertNotReleased();

         return responseStream;

     }

     public void setResponseStream(ResponseStream responseStream) {

         assertNotReleased();

         AssertionUtil.assertNotNull("responseStream", responseStream);

         this.responseStream = responseStream;

     }

     public ResponseWriter getResponseWriter() {

         assertNotReleased();

         return responseWriter;

     }

     public void setResponseWriter(ResponseWriter responseWriter) {

         assertNotReleased();

         AssertionUtil.assertNotNull("responseWriter", responseWriter);

         this.responseWriter = responseWriter;

     }

     public UIViewRoot getViewRoot() {

         assertNotReleased();

         return root;

     }

     public void setViewRoot(UIViewRoot root) {

         assertNotReleased();

         AssertionUtil.assertNotNull("root", root);

         this.root = root;

     }

     public void addMessage(String clientId, FacesMessage message) {

         assertNotReleased();

         AssertionUtil.assertNotNull("message", message);

         if (messages == null) {

             messages = new ArrayList();

             messageClientIds = new ArrayList();

         }

         messages.add(message);

         messageClientIds.add(clientId);

         FacesMessage.Severity severity = message.getSeverity();

         setSeverity(severity);

     }

     public void release() {

         released = true;

         application = null;

         if (externalContext instanceof Releaseable) {

             ((Releaseable) externalContext).release();

         }

         externalContext = null;

         FacesContext.setCurrentInstance(null);

     }

     public void renderResponse() {

         assertNotReleased();

         renderResponse = true;

     }

     public void responseComplete() {

         assertNotReleased();

         responseComplete = true;

     }

     private void setSeverity(FacesMessage.Severity severity) {

         if (severity != null) {

             if (maxSeverity == null || severity.compareTo(maxSeverity) > 0) {

                 maxSeverity = severity;

             }

         }

     }

     private void assertNotReleased() {

         if (released) {

             throw new IllegalStateException("already released");

         }

     }

 }