/**
 * Copyright 2005-2016 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.Queue;
import java.util.Set;

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.LifecycleElement;
import org.kuali.rice.krad.uif.util.RecycleUtils;

/**
 * Lifecycle phase processing task for rendering a component.
 *
 * @author Kuali Rice Team (rice.collab@kuali.org)
 * @see ViewLifecycle#isRenderInLifecycle()
 */
public class RenderComponentPhase extends ViewLifecyclePhaseBase {

    private RenderComponentPhase renderParent;
    private Set<String> pendingChildren;

    /**
     * {@inheritDoc}
     */
    @Override
    public void recycle() {
        super.recycle();
        renderParent = null;
        pendingChildren = null;
    }

    /**
     * Create a new lifecycle phase processing task for finalizing a component.
     *
     * @param renderParent rendering phase to queue as a successor when all children have processed
     * @param pendingChildren set of paths to child rendering phases to expect to be queued for
     * processing before this phase
     */
    void prepareRenderPhase(RenderComponentPhase renderParent, Set<String> pendingChildren) {
        this.renderParent = renderParent;
        this.pendingChildren = pendingChildren;
    }

    /**
     * {@inheritDoc}
     *
     * @return UifConstants.ViewPhases.RENDER
     */
    @Override
    public String getViewPhase() {
        return UifConstants.ViewPhases.RENDER;
    }

    /**
     * {@inheritDoc}
     *
     * @return UifConstants.ViewStatus.FINAL
     */
    @Override
    public String getStartViewStatus() {
        return UifConstants.ViewStatus.FINAL;
    }

    /**
     * {@inheritDoc}
     *
     * @return UifConstants.ViewStatus.RENDERED
     */
    @Override
    public String getEndViewStatus() {
        return UifConstants.ViewStatus.RENDERED;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public LifecycleEvent getEventToNotify() {
        return null;
    }

    /**
     * Verify that the all pending children have completed.
     */
    @Override
    protected void verifyCompleted() {
        if (pendingChildren != null) {
            ViewLifecycle.reportIllegalState("Render phase is not complete, children are still pending "
                    + pendingChildren + "\n" + this);
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    protected void initializeSuccessors(Queue<ViewLifecyclePhase> successors) {
        if (renderParent == null || renderParent.pendingChildren == null) {
            trace(renderParent == null ? "no-parent" : "no-children");
            return;
        }

        synchronized (renderParent) {
            // InitializeSuccessors is invoked right after processing.
            // Once the last sibling is processed, then queue the parent phase as a successor.
            if (!renderParent.pendingChildren.remove(getParentPath())) {
                ViewLifecycle.reportIllegalState("Render phase isn't a pending child\n"
                        + this + "\nRender Parent: " + renderParent);
            }

            trace("remove-child " + renderParent.getElement().getId() + " " +
                    renderParent.getViewPath() + " " + getParentPath() + " "
                    + renderParent.pendingChildren);

            if (renderParent.pendingChildren.isEmpty()) {
                successors.add(renderParent);
                renderParent.trace("pend-rend");
                
                Set<String> toRecycle = renderParent.pendingChildren;
                renderParent.pendingChildren = null;
                RecycleUtils.recycle(toRecycle);
            }
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    protected ViewLifecyclePhase initializeSuccessor(LifecycleElement nestedElement, String nestedPath,
            Component parent) {
        return null;
    }

}
