/**
    * 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.surf.render.bean;
  
  import java.io.IOException;
  import java.io.PrintWriter;
  
  import org.springframework.extensions.surf.RequestContext;
  import org.springframework.extensions.surf.WebFrameworkConstants;
  import org.springframework.extensions.surf.render.Processor;
  import org.springframework.extensions.surf.render.ProcessorContext;
  import org.springframework.extensions.surf.render.RenderContext;
  import org.springframework.extensions.surf.render.RenderMode;
  import org.springframework.extensions.surf.render.Renderable;
  import org.springframework.extensions.surf.render.ProcessorContext.ProcessorDescriptor;
  import org.springframework.extensions.surf.render.bean.ComponentRenderer;
  import org.springframework.extensions.surf.studio.WebStudioService;
  import org.springframework.extensions.surf.types.Component;
  import org.springframework.extensions.surf.types.ComponentType;
  import org.springframework.extensions.webscripts.DeclarativeRegistry;
  import org.springframework.extensions.webscripts.WebScript;
  
  /**
   * Modifies the way that components are rendered when Surf is running in preview mode.
   * This allows Web Studio to pull "pulled in" to any Surf Preview application.
   * 
   * Primarily, this enables components to output additional Web Studio
   * specific JavaScript to bind client-side DOM elements together.
   * 
   * @author muzquiano
   */
  public class WebStudioComponentRenderer extends ComponentRenderer
  {
      private WebStudioService webStudioService = null;
      private DeclarativeRegistry registry = null;
      
      /**
       * Sets the web studio service.
       * 
       * @param webStudioService the new web studio service
       */
      public void setWebStudioService(WebStudioService webStudioService)
      {
          this.webStudioService = webStudioService;
      }
      
      /**
       * Sets the registry.
       * 
       * @param registry the new registry
       */
      public void setRegistry(DeclarativeRegistry registry)
      {
          this.registry = registry;
      }
      
      /**
       * Gets the web studio service.
       * 
       * @return the web studio service
       */
      protected WebStudioService getWebStudioService()
      {
          return this.webStudioService;
      }
      
      /*
       * (non-Javadoc)
       * 
       * @see org.alfresco.web.framework.render.bean.RegionRenderer#postProcess(org.alfresco.web.framework.render.RenderContext)
       */
      public void postProcess(RenderContext context) throws IOException
      {
          // TODO: check whether web studio is enabled
          boolean webStudioEnabled = true;
          if (webStudioEnabled)
          {
              // if we are not in passive mode
              if (!context.isPassiveMode())
              {
                  // html binding id
                  String htmlId = (String) context
                          .getValue(WebFrameworkConstants.RENDER_DATA_HTMLID);
     
                 // component and component type properties
                 String componentId = (String) context
                         .getValue(WebFrameworkConstants.RENDER_DATA_COMPONENT_ID);
                 String componentTypeId = (String) context
                         .getValue(WebFrameworkConstants.RENDER_DATA_COMPONENT_TYPE_ID);
     
                 // commit to output
                 PrintWriter writer = context.getResponse().getWriter();
                 writer.println("<script type='text/javascript'>");
     
                 // if there is a component, bind that in too
                 if (componentId != null && componentTypeId != null)
                 {
                     String componentTitle = "";
                     String componentTypeTitle = "";
                     
                     Component c = (Component) context.getModel().getComponent(componentId);
                     if (c != null)
                     {
                         componentTitle = getComponentTitle(context, c);
                         componentTypeTitle = getComponentTypeTitle(context, c);
                     }
                     
                     writer.println("if(typeof WebStudio != \"undefined\"){");
                     writer.println("WebStudio.configureComponent('" + htmlId
                             + "', '" + componentId + "', '" + componentTypeId
                             + "', '" + componentTitle + "', '" + componentTypeTitle + "');");
                     
                     // if the component has an "edit" mode, then mark it as editable
                     boolean hasEditMode = false;
                     ComponentType ct = (ComponentType) c.getComponentType(context);
                     if (ct instanceof Renderable)
                     {
                         Renderable renderable = (Renderable) ct;
                         
                         // get the processor
                         Processor processor = this.getRenderService().getProcessor((Renderable)ct, RenderMode.EDIT);
                         if (processor != null)
                         {
                             // build a mock render context
                             RenderContext renderContext = getRenderService().provideRenderContext(context, context.getRequest(), context.getResponse(), RenderMode.EDIT);
                             
                             // build a processor context
                             ProcessorContext processorContext = new ProcessorContext(renderContext);
                             
                             // load from renderable data
                             processorContext.load((Renderable)ct);
                             
                             // TODO: we have to manually set up view mode for possible substitutions in other modes
                             if (c.getURL() != null)
                             {
                                 ProcessorDescriptor viewDescriptor = processorContext.getDescriptor(RenderMode.VIEW);
                                 viewDescriptor.put("uri", c.getURL());
                             }
                             
                             hasEditMode = processor.exists(processorContext);
                         }
                     }
                     
                     if (hasEditMode)
                     {
                         writer.println("WebStudio.configureComponentEditable('" + htmlId + "');");
                     }
                     
                     
                     writer.println("}");
                 }
     
                 writer.println("</script>");
                 writer.flush();
             }
         }
     }
 
     public String getComponentTitle(RequestContext context, Component c)
     {
         String title = c.getTitle();
         if (title == null)
         {
             title = c.getId();
         }
 
         return title;
     }
 
     public String getComponentTypeTitle(RequestContext context,
             Component c)
     {
         String title = null;
 
         ComponentType ct = c.getComponentType(context);
         if (ct != null)
         {
             title = ct.getTitle();
             if (title == null)
             {
                 title = ct.getId();
             }
 
             if ("webscript".equals(ct.getId()))
             {
                 String url = c.getURL();
 
                 WebScript webScript = this.registry.getWebScript(url);
                 if (webScript != null)
                 {
                     title = webScript.getDescription().getShortName();
                 }
             }
         }
         else
         {
             // assume the component type field is a web script id
             String url = c.getComponentTypeId();
 
             for (WebScript webscript : this.registry.getWebScripts())
             {
                 String[] uris = webscript.getDescription().getURIs();
                 for (int z = 0; z < uris.length; z++)
                 {
                     String uri = uris[z];
                     if (uri.equals(url))
                     {
                         title = webscript.getDescription().getShortName();
                     }
                 }
             }
         }
 
         return title;
     }
 }