/**
    * Copyright (C) 2005-2009 Alfresco Software Limited.
    *
    * This file is part of the Spring Surf Extension project.
    *
    * 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.springframework.extensions.webscripts;
  
  import java.io.IOException;
  import java.net.URL;
  import java.util.Properties;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.springframework.extensions.webscripts.Description.RequiredAuthentication;
  
  
  /**
   * Presentation (web tier) Web Script Container
   * 
   * @author davidc
   */
  public class PresentationContainer extends AbstractRuntimeContainer
  {
      private static final Log logger = LogFactory.getLog(PresentationContainer.class);
      
  	/* (non-Javadoc)
  	 * @see org.alfresco.web.scripts.RuntimeContainer#executeScript(org.alfresco.web.scripts.WebScriptRequest,
       *      org.alfresco.web.scripts.WebScriptResponse, org.alfresco.web.scripts.Authenticator)
  	 */
      public void executeScript(WebScriptRequest scriptReq, WebScriptResponse scriptRes, Authenticator auth)
          throws IOException
      {
          // Handle authentication of scripts on a case-by-case basis.
          // Currently we assume that if a webscript servlet has any authenticator
          // applied then it must be for some kind of remote user auth as supplied.
          WebScript script = scriptReq.getServiceMatch().getWebScript();
          Description desc = script.getDescription();
          RequiredAuthentication required = desc.getRequiredAuthentication();
          if (auth == null || RequiredAuthentication.none == required || auth.authenticate(required, false))
          {
              script.execute(scriptReq, scriptRes);
          }
      }
  
      /* (non-Javadoc)
       * @see org.alfresco.web.scripts.Container#getDescription()
       */
      public ServerModel getDescription()
      {
          Properties props = null;
          URL url = this.getClass().getClassLoader().getResource("version.properties");
          if (url != null)
          {
              try
              {
                  props = new Properties();
                  props.load(url.openStream());
              }
              catch (IOException err)
              {
                  logger.warn("Failed to load version properties: " + err.getMessage(), err);
              }
          }
          return new PresentationServerModel(props);
      }
      
      /**
       * Presentation Tier Model
       *
       * @author davidc
       */
      private class PresentationServerModel implements ServerModel
      {
          private Properties props = null;
          private String version = null;
          
          public PresentationServerModel(Properties props)
          {
              this.props = props;
          }
          
          public String getContainerName()
          {
              return getName();
          }
  
         public String getId()
         {
             return UNKNOWN;
         }
 
         public String getName()
         {
             return UNKNOWN;
         }
 
         public String getEdition()
         {
             return (props != null ? props.getProperty("version.edition") : UNKNOWN);
         }
 
         public int getSchema()
         {
             return (props != null ? Integer.parseInt(props.getProperty("version.schema")) : -1);
         }
 
         public String getVersion()
         {
             if (this.version == null)
             {
                 if (props != null)
                 {
                     StringBuilder version = new StringBuilder(getVersionMajor());
                     version.append(".");
                     version.append(getVersionMinor());
                     version.append(".");
                     version.append(getVersionRevision());
                     
                     String label = getVersionLabel();
                     String build = getVersionBuild();
                     
                     boolean hasLabel = (label != null && label.length() > 0);
                     boolean hasBuild = (build != null && build.length() > 0);
                     
                     // add opening bracket if either a label or build number is present
                     if (hasLabel || hasBuild)
                     {
                        version.append(" (");
                     }
                     
                     // add label if present
                     if (hasLabel)
                     {
                        version.append(label);
                     }
                     
                     // add build number is present
                     if (hasBuild)
                     {
                        // if there is also a label we need a separating space
                        if (hasLabel)
                        {
                           version.append(" ");
                        }
                        
                        version.append(build);
                     }
                     
                     // add closing bracket if either a label or build number is present
                     if (hasLabel || hasBuild)
                     {
                        version.append(")");
                     }
                     
                     this.version = version.toString();
                 }
                 else
                 {
                     this.version = UNKNOWN;
                 }
             }
             return this.version;
         }
 
         public String getVersionBuild()
         {
             return (props != null ? props.getProperty("version.build") : UNKNOWN);
         }
 
         public String getVersionLabel()
         {
             return (props != null ? props.getProperty("version.label") : UNKNOWN);
         }
 
         public String getVersionMajor()
         {
             return (props != null ? props.getProperty("version.major") : UNKNOWN);
         }
 
         public String getVersionMinor()
         {
             return (props != null ? props.getProperty("version.minor") : UNKNOWN);
         }
 
         public String getVersionRevision()
         {
             return (props != null ? props.getProperty("version.revision") : UNKNOWN);
         }
         
         private final static String UNKNOWN = "<unknown>"; 
     }
 }