/**
    * Copyright 2005-2015 The Kuali Foundation
    *
    * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
    *
   * 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.kuali.rice.krad.uif.lifecycle;
  
  import java.util.ArrayList;
  import java.util.HashSet;
  import java.util.LinkedHashSet;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Queue;
  
  import org.apache.commons.lang.StringUtils;
  import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
  import org.kuali.rice.krad.uif.UifConstants;
  import org.kuali.rice.krad.uif.component.Component;
  import org.kuali.rice.krad.uif.lifecycle.ViewLifecycle.LifecycleEvent;
  import org.kuali.rice.krad.uif.util.CopyUtils;
  import org.kuali.rice.krad.uif.util.LifecycleElement;
  import org.kuali.rice.krad.uif.util.ObjectPropertyUtils;
  import org.kuali.rice.krad.uif.util.ProcessLogger;
  import org.kuali.rice.krad.uif.util.RecycleUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Base abstract implementation for a lifecycle phase.
   *
   * @author Kuali Rice Team (rice.collab@kuali.org)
   */
  public abstract class ViewLifecyclePhaseBase implements ViewLifecyclePhase {
      private final Logger LOG = LoggerFactory.getLogger(ViewLifecyclePhaseBase.class);
  
      private LifecycleElement element;
      private Component parent;
      private String viewPath;
      private String path;
      private int depth;
  
      private List<String> refreshPaths;
  
      private ViewLifecyclePhase predecessor;
      private ViewLifecyclePhase nextPhase;
  
      private boolean processed;
      private boolean completed;
  
      private HashSet<String> pendingSuccessors = new LinkedHashSet<String>();
  
      private ViewLifecycleTask<?> currentTask;
  
      private List<ViewLifecycleTask<?>> tasks;
      private List<ViewLifecycleTask<?>> skipLifecycleTasks;
  
      /**
       * Resets this phase for recycling.
       */
      public void recycle() {
          trace("recycle");
  
          element = null;
          path = null;
          viewPath = null;
          depth = 0;
          predecessor = null;
          nextPhase = null;
          processed = false;
          completed = false;
          refreshPaths = null;
          pendingSuccessors = new LinkedHashSet<String>();
      }
  
      /**
       * {@inheritDoc}
       */
      @Override
      public void prepare(LifecycleElement element, Component parent, String parentPath, List<String> refreshPaths) {
          this.path = parentPath;
  
          String parentViewPath = parent == null ? null : parent.getViewPath();
          if (StringUtils.isEmpty(parentViewPath)) {
              this.viewPath = path;
          } else {
              this.viewPath = parentViewPath + '.' + path;
          }
  
         this.element = CopyUtils.unwrap(element);
         this.parent = parent;
         this.refreshPaths = refreshPaths;
 
         trace("prepare");
     }
 
     /**
      * Executes the lifecycle phase.
      *
      * <p>Performs state validation and updates component view status.</p>
      *
      * @see java.lang.Runnable#run()
      */
     @Override
     public final void run() {
         try {
             ViewLifecycleProcessorBase processor = (ViewLifecycleProcessorBase) ViewLifecycle.getProcessor();
 
             validateBeforeProcessing();
 
             boolean skipLifecycle = shouldSkipLifecycle();
 
             String ntracePrefix = null;
             String ntraceSuffix = null;
             try {
                 if (ViewLifecycle.isTrace() && ProcessLogger.isTraceActive()) {
                     ntracePrefix = "lc-" + getStartViewStatus() + "-" + getEndViewStatus() + ":";
                     ntraceSuffix =
                             ":" + getElement().getClass().getSimpleName() + (getElement().isRender() ? ":render" :
                                     ":no-render");
 
                     ProcessLogger.ntrace(ntracePrefix, ntraceSuffix, 1000);
                     ProcessLogger.countBegin(ntracePrefix + ntraceSuffix);
                 }
 
                 String viewStatus = element.getViewStatus();
                 if (viewStatus != null && !viewStatus.equals(getStartViewStatus())) {
                     trace("dup " + getStartViewStatus() + " " + getEndViewStatus() + " " + viewStatus);
                 }
 
                 processor.setActivePhase(this);
 
                 trace("path-update " + element.getViewPath());
 
                 element.setViewPath(getViewPath());
                 element.getPhasePathMapping().put(getViewPhase(), getViewPath());
 
                 List<ViewLifecycleTask<?>> pendingTasks = skipLifecycle ? skipLifecycleTasks : tasks;
 
                 StringBuilder trace;
                 if (ViewLifecycle.isTrace() && LOG.isDebugEnabled()) {
                     trace = new StringBuilder("Tasks");
                 } else {
                     trace = null;
                 }
 
                 for (ViewLifecycleTask<?> task : pendingTasks) {
                     if (trace != null) {
                         trace.append("\n  ").append(task);
                     }
 
                     if (!task.getElementType().isInstance(element)) {
                         if (trace != null) {
                             trace.append(" skip");
                         }
                         continue;
                     }
 
                     if (trace != null) {
                         trace.append(" run");
                     }
                     currentTask = task;
                     task.run();
                     currentTask = null;
                 }
 
                 if (trace != null) {
                     LOG.debug(trace.toString());
                 }
 
                 element.setViewStatus(getEndViewStatus());
                 processed = true;
 
             } finally {
                 processor.setActivePhase(null);
 
                 if (ViewLifecycle.isTrace() && ProcessLogger.isTraceActive()) {
                     ProcessLogger.countEnd(ntracePrefix + ntraceSuffix,
                             getElement().getClass() + " " + getElement().getId());
                 }
             }
 
             if (skipLifecycle) {
                 notifyCompleted();
             } else {
                 assert pendingSuccessors.isEmpty() : pendingSuccessors;
 
                 Queue<ViewLifecyclePhase> successors = new LinkedList<ViewLifecyclePhase>();
 
                 initializeSuccessors(successors);
                 processSuccessors(successors);
             }
         } catch (Throwable t) {
             trace("error");
             LOG.warn("Error in lifecycle phase " + this, t);
 
             if (t instanceof RuntimeException) {
                 throw (RuntimeException) t;
             } else if (t instanceof Error) {
                 throw (Error) t;
             } else {
                 throw new IllegalStateException("Unexpected error in lifecycle phase " + this, t);
             }
         }
     }
 
     /**
      * Indicates whether the lifecycle should be skipped for the current component.
      *
      * <p>Elements are always processed in the pre process phase, or in the case of the element or one
      * of its childs being refreshed. If these conditions are false, the element method
      * {@link org.kuali.rice.krad.uif.util.LifecycleElement#skipLifecycle()} is invoked to determine if
      * the lifecycle can be skipped.</p>
      *
      * @return boolean true if the lifecycle should be skipped, false if not
      * @see org.kuali.rice.krad.uif.util.LifecycleElement#skipLifecycle()
      */
     protected boolean shouldSkipLifecycle() {
         if (StringUtils.isBlank(getViewPath())) {
             return false;
         }
 
         // we always want to run the preprocess phase so ids are assigned
         boolean isPreProcessPhase = getViewPhase().equals(UifConstants.ViewPhases.PRE_PROCESS);
 
         // if the component is being refreshed its lifecycle should not be skipped
         boolean isRefreshComponent = ViewLifecycle.isRefreshComponent(getViewPhase(), getViewPath());
 
         // if a child of this component is being refresh its lifecycle should not be skipped
         boolean includesRefreshComponent = false;
         if (StringUtils.isNotBlank(ViewLifecycle.getRefreshComponentPhasePath(getViewPhase()))) {
             includesRefreshComponent = ViewLifecycle.getRefreshComponentPhasePath(getViewPhase()).startsWith(
                     getViewPath());
         }
 
         boolean skipLifecycle = false;
         if (!(isPreProcessPhase || isRefreshComponent || includesRefreshComponent)) {
             // delegate to the component to determine whether skipping lifecycle is ok
             skipLifecycle = element.skipLifecycle();
         }
 
         return skipLifecycle;
     }
 
     /**
      * Validates this phase and thread state before processing and logs activity.
      *
      * @see #run()
      */
     protected void validateBeforeProcessing() {
         if (processed) {
             throw new IllegalStateException("Lifecycle phase has already been processed " + this);
         }
 
         if (predecessor != null && !predecessor.isProcessed()) {
             throw new IllegalStateException("Predecessor phase has not completely processed " + this);
         }
 
         if (!ViewLifecycle.isActive()) {
             throw new IllegalStateException("No view lifecyle is not active on the current thread");
         }
 
         if (LOG.isDebugEnabled()) {
             trace("ready " + getStartViewStatus() + " -> " + getEndViewStatus());
         }
     }
 
     /**
      * Adds phases added as successors to the processor, or if there are no pending successors invokes
      * the complete notification step.
      *
      * @param successors phases to process
      */
     protected void processSuccessors(Queue<ViewLifecyclePhase> successors) {
         for (ViewLifecyclePhase successor : successors) {
             if (!pendingSuccessors.add(successor.getParentPath())) {
                 ViewLifecycle.reportIllegalState("Already pending " + successor + "\n" + this);
             }
         }
 
         trace("processed " + pendingSuccessors);
 
         if (pendingSuccessors.isEmpty()) {
             notifyCompleted();
         } else {
             for (ViewLifecyclePhase successor : successors) {
                 assert successor.getPredecessor() == null : this + " " + successor;
                 successor.setPredecessor(this);
 
                 if (successor instanceof ViewLifecyclePhaseBase) {
                     ((ViewLifecyclePhaseBase) successor).trace("succ-pend");
                 }
 
                 ViewLifecycle.getProcessor().offerPendingPhase(successor);
             }
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void setNextPhase(ViewLifecyclePhase nextPhase) {
         if (this.nextPhase != null) {
             throw new IllegalStateException("Next phase is already set " + nextPhase + "\n" + this);
         }
 
         if (nextPhase == null || !getEndViewStatus().equals(nextPhase.getStartViewStatus())) {
             throw new IllegalStateException(
                     "Next phase is invalid for end phase " + getEndViewStatus() + " found " + nextPhase
                             .getStartViewStatus());
         }
 
         this.nextPhase = nextPhase;
         trace("next-phase");
     }
 
     /**
      * Sets the tasks to process at this phase.
      *
      * @param tasks list of tasks
      */
     public void setTasks(List<ViewLifecycleTask<?>> tasks) {
         for (ViewLifecycleTask<?> task : tasks) {
             assert task.getElementState() == null : task.getElementState() + "\n" + this;
             task.setElementState(this);
         }
 
         this.tasks = tasks;
     }
 
     /**
      * Sets the tasks to process at this phase when the lifecycle is skipped.
      *
      * @param skipLifecycleTasks list of tasks
      */
     public void setSkipLifecycleTasks(List<ViewLifecycleTask<?>> skipLifecycleTasks) {
         for (ViewLifecycleTask<?> task : skipLifecycleTasks) {
             assert task.getElementState() == null : task.getElementState() + "\n" + this;
             task.setElementState(this);
         }
 
         this.skipLifecycleTasks = skipLifecycleTasks;
     }
 
     /**
      * Initializes queue of successor phases.
      *
      * <p>This method will be called while processing this phase after all tasks have been performed,
      * to determine phases to queue for successor processing. This phase will not be considered
      * complete until all successors queued by this method, and all subsequent successor phases,
      * have completed processing.</p>
      *
      * @param successors The queue of successor phases
      */
     protected void initializeSuccessors(Queue<ViewLifecyclePhase> successors) {
         if (ViewLifecycle.isRefreshLifecycle() && (refreshPaths != null)) {
             String currentPath = getViewPath();
 
             boolean withinRefreshComponent = currentPath.startsWith(ViewLifecycle.getRefreshComponentPhasePath(
                     getViewPhase()));
             if (withinRefreshComponent) {
                 initializeAllLifecycleSuccessors(successors);
             } else if (refreshPaths.contains(currentPath) || StringUtils.isBlank(currentPath)) {
                 initializeRefreshPathSuccessors(successors);
             }
 
             return;
         }
 
         initializeAllLifecycleSuccessors(successors);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void setRefreshPaths(List<String> refreshPaths) {
         this.refreshPaths = refreshPaths;
     }
 
     @Override
     public List<String> getRefreshPaths() {
         return this.refreshPaths;
     }
 
     /**
      * Initializes only the lifecycle successors referenced by paths within {@link #getRefreshPaths()}.
      *
      * @param successors the successor queue
      */
     protected void initializeRefreshPathSuccessors(Queue<ViewLifecyclePhase> successors) {
         LifecycleElement element = getElement();
 
         String nestedPathPrefix;
         Component nestedParent;
         if (element instanceof Component) {
             nestedParent = (Component) element;
             nestedPathPrefix = "";
         } else {
             nestedParent = getParent();
             nestedPathPrefix = getParentPath() + ".";
         }
 
         List<String> nestedProperties = getNestedPropertiesForRefreshPath();
 
         for (String nestedProperty : nestedProperties) {
             String nestedPath = nestedPathPrefix + nestedProperty;
 
             LifecycleElement nestedElement = ObjectPropertyUtils.getPropertyValue(element, nestedProperty);
             if (nestedElement != null) {
                 ViewLifecyclePhase nestedPhase = initializeSuccessor(nestedElement, nestedPath, nestedParent);
                 successors.add(nestedPhase);
             }
         }
     }
 
     /**
      * Determines the list of child properties for the current phase component that are in the refresh
      * paths and should be processed next.
      *
      * @return list of property names relative to the component the phase is currently processing
      */
     protected List<String> getNestedPropertiesForRefreshPath() {
         List<String> nestedProperties = new ArrayList<String>();
 
         String currentPath = getViewPath();
         if (currentPath == null) {
             currentPath = "";
         }
 
         if (StringUtils.isNotBlank(currentPath)) {
             currentPath += ".";
         }
 
         // to get the list of children, the refresh path must start with the path of the component being
         // processed. If the child path is nested, we get the top most property first
         for (String refreshPath : refreshPaths) {
             if (!refreshPath.startsWith(currentPath)) {
                 continue;
             }
 
             String nestedProperty = StringUtils.substringAfter(refreshPath, currentPath);
 
             if (StringUtils.isBlank(nestedProperty)) {
                 continue;
             }
 
             if (StringUtils.contains(nestedProperty, ".")) {
                 nestedProperty = StringUtils.substringBefore(nestedProperty, ".");
             }
 
             if (!nestedProperties.contains(nestedProperty)) {
                 nestedProperties.add(nestedProperty);
             }
         }
 
         return nestedProperties;
     }
 
     /**
      * Initializes all lifecycle phase successors.
      *
      * @param successors The successor queue.
      */
     protected void initializeAllLifecycleSuccessors(Queue<ViewLifecyclePhase> successors) {
         LifecycleElement element = getElement();
 
         String nestedPathPrefix;
         Component nestedParent;
         if (element instanceof Component) {
             nestedParent = (Component) element;
             nestedPathPrefix = "";
         } else {
             nestedParent = getParent();
             nestedPathPrefix = getParentPath() + ".";
         }
 
         for (Map.Entry<String, LifecycleElement> nestedElementEntry : ViewLifecycleUtils.getElementsForLifecycle(
                 element, getViewPhase()).entrySet()) {
             String nestedPath = nestedPathPrefix + nestedElementEntry.getKey();
             LifecycleElement nestedElement = nestedElementEntry.getValue();
 
             if (nestedElement != null && !getEndViewStatus().equals(nestedElement.getViewStatus())) {
                 ViewLifecyclePhase nestedPhase = initializeSuccessor(nestedElement, nestedPath, nestedParent);
                 successors.offer(nestedPhase);
             }
         }
     }
 
     /**
      * May be overridden in order to check for illegal state based on more concrete assumptions than
      * can be made here.
      *
      * @throws IllegalStateException If the conditions for completing the lifecycle phase have not been met
      */
     protected void verifyCompleted() {
     }
 
     /**
      * Initializes a successor of this phase for a given nested element.
      *
      * @param nestedElement The lifecycle element
      * @param nestedPath The path, relative to the parent element
      * @param nestedParent The parent component of the nested element
      * refresh)
      * @return successor phase
      */
     protected ViewLifecyclePhase initializeSuccessor(LifecycleElement nestedElement, String nestedPath,
             Component nestedParent) {
         ViewLifecyclePhase successorPhase = KRADServiceLocatorWeb.getViewLifecyclePhaseBuilder().buildPhase(
                 getViewPhase(), nestedElement, nestedParent, nestedPath, this.refreshPaths);
 
         return successorPhase;
     }
 
     /**
      * Notifies predecessors that this task has completed.
      */
     @Override
     public final void notifyCompleted() {
         trace("complete");
 
         completed = true;
 
         LifecycleEvent event = getEventToNotify();
         if (event != null) {
             ViewLifecycle.getActiveLifecycle().invokeEventListeners(event, ViewLifecycle.getView(),
                     ViewLifecycle.getModel(), element);
         }
 
         element.notifyCompleted(this);
 
         if (nextPhase != null) {
             assert nextPhase.getPredecessor() == null : this + " " + nextPhase;
 
             // Assign a predecessor to the next phase, to defer notification until
             // after all phases in the chain have completed processing.
             if (predecessor != null) {
                 // Common case: "catch up" phase automatically spawned to bring
                 // a component up to the right status before phase processing.
                 // Swap the next phase in for this phase in the graph.
                 nextPhase.setPredecessor(predecessor);
             } else {
                 // Initial phase chain:  treat the next phase as a successor so that
                 // this phase (and therefore the controlling thread) will be notified
                 nextPhase.setPredecessor(this);
                 synchronized (pendingSuccessors) {
                     pendingSuccessors.add(nextPhase.getParentPath());
                 }
             }
 
             ViewLifecycle.getProcessor().pushPendingPhase(nextPhase);
             return;
         }
 
         synchronized (this) {
             if (predecessor != null) {
                 synchronized (predecessor) {
                     predecessor.removePendingSuccessor(getParentPath());
                     if (!predecessor.hasPendingSuccessors()) {
                         predecessor.notifyCompleted();
                     }
 
                     recycle();
                     RecycleUtils.recycle(getViewPhase(), this, ViewLifecyclePhase.class);
                 }
             } else {
                 trace("notify");
                 notifyAll();
             }
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public final LifecycleElement getElement() {
         return element;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public final Component getParent() {
         return this.parent;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public String getParentPath() {
         return this.path;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public String getViewPath() {
         return this.viewPath;
     }
 
     /**
      * @param viewPath the viewPath to set
      */
     public void setViewPath(String viewPath) {
         this.viewPath = viewPath;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public int getDepth() {
         return this.depth;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public final boolean isProcessed() {
         return processed;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public final boolean isComplete() {
         return completed;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public ViewLifecyclePhase getPredecessor() {
         return predecessor;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void setPredecessor(ViewLifecyclePhase phase) {
         if (this.predecessor != null) {
             throw new IllegalStateException("Predecessor phase is already defined");
         }
 
         this.predecessor = phase;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public ViewLifecycleTask<?> getCurrentTask() {
         return this.currentTask;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean hasPendingSuccessors() {
         return !pendingSuccessors.isEmpty();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void removePendingSuccessor(String parentPath) {
         if (!pendingSuccessors.remove(parentPath)) {
             throw new IllegalStateException("Not a pending successor: " + parentPath);
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
         Queue<ViewLifecyclePhase> toPrint = new LinkedList<ViewLifecyclePhase>();
         toPrint.offer(this);
         while (!toPrint.isEmpty()) {
             ViewLifecyclePhase tp = toPrint.poll();
 
             if (tp.getElement() == null) {
                 sb.append("\n      ");
                 sb.append(tp.getClass().getSimpleName());
                 sb.append(" (recycled)");
                 continue;
             }
 
             String indent;
             if (tp == this) {
                 sb.append("\nProcessed? ");
                 sb.append(processed);
                 indent = "\n";
             } else {
                 indent = "\n    ";
             }
             sb.append(indent);
 
             sb.append(tp.getClass().getSimpleName());
             sb.append(" ");
             sb.append(System.identityHashCode(tp));
             sb.append(" ");
             sb.append(tp.getViewPath());
             sb.append(" ");
             sb.append(tp.getElement().getClass().getSimpleName());
             sb.append(" ");
             sb.append(tp.getElement().getId());
             sb.append(" ");
             sb.append(pendingSuccessors);
 
             if (tp == this) {
                 sb.append("\nPredecessor Phases:");
             }
 
             ViewLifecyclePhase tpredecessor = tp.getPredecessor();
             if (tpredecessor != null) {
                 toPrint.add(tpredecessor);
             }
         }
         return sb.toString();
     }
 
     /**
      * Logs a trace message related to processing this lifecycle, when tracing is active and
      * debugging is enabled.
      *
      * @param step The step in processing the phase that has been reached.
      * @see ViewLifecycle#isTrace()
      */
     protected void trace(String step) {
         if (ViewLifecycle.isTrace() && LOG.isDebugEnabled()) {
             String msg = System.identityHashCode(this) + " " + getClass() + " " + step + " " + path + " " +
                     (element == null ? "(recycled)" : element.getClass() + " " + element.getId());
             LOG.debug(msg);
         }
     }
 
 }