/**

  * Copyright 2005-2011 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.core.web.cache;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.Comparator;

 import java.util.List;

 import javax.servlet.http.HttpServletRequest;

 import javax.servlet.http.HttpServletResponse;

 import org.kuali.rice.core.api.cache.CacheManagerRegistry;

 import org.kuali.rice.core.api.util.tree.Node;

 import org.kuali.rice.core.api.util.tree.Tree;

 import org.kuali.rice.core.impl.services.CoreImplServiceLocator;

 import org.kuali.rice.krad.util.GlobalVariables;

 import org.kuali.rice.krad.web.controller.UifControllerBase;

 import org.kuali.rice.krad.web.form.UifFormBase;

 import org.springframework.cache.CacheManager;

 import org.springframework.stereotype.Controller;

 import org.springframework.validation.BindingResult;

 import org.springframework.web.bind.annotation.ModelAttribute;

 import org.springframework.web.bind.annotation.RequestMapping;

 import org.springframework.web.bind.annotation.RequestMethod;

 import org.springframework.web.servlet.ModelAndView;

 @Controller

 @RequestMapping(value = "/core/admin/cache")

 public class CacheAdminController extends UifControllerBase {

     private CacheManagerRegistry registry;

     public synchronized CacheManagerRegistry getRegistry() {

         if (registry == null) {

             registry = CoreImplServiceLocator.getCacheManagerRegistry();

         }

         return registry;

     }

     /**

      * @see org.kuali.rice.krad.web.controller.UifControllerBase#createInitialForm(javax.servlet.http.HttpServletRequest)

      */

     @Override

     protected CacheAdminForm createInitialForm(HttpServletRequest request) {

         return new CacheAdminForm();

     }

     @Override

         @RequestMapping(params = "methodToCall=start")

         public ModelAndView start(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,

                         HttpServletRequest request, HttpServletResponse response) {

         final Tree<String, String> cacheTree = new Tree<String,String>();

         final Node<String,String> root = new Node<String,String>("Root", "Root");

         final List<CacheManager> cms = new ArrayList<CacheManager>(getRegistry().getCacheManagers());

         Collections.sort(cms, new ByName());

         for (final CacheManager cm : cms) {

             final String name = getRegistry().getCacheManagerName(cm);

             final Node<String, String> cmNode = new Node<String, String>(name, name);

             final List<String> names = new ArrayList<String>(cm.getCacheNames());

             Collections.sort(names, String.CASE_INSENSITIVE_ORDER);

             for (final String cn : names) {

                 final Node<String, String> cNode = new Node<String, String>(cn, cn);

                 //no way to get a keySet from the cache w/o calling the nativeCache

                 //method which is a bad idea b/c it will tie the rice codebase to

                 //a caching implementation

                 cmNode.addChild(cNode);

             }

             root.addChild(cmNode);

         }

         cacheTree.setRootElement(root);

         ((CacheAdminForm) form).setCacheTree(cacheTree);

         return super.start(form, result, request, response);

     }

         @RequestMapping(params = "methodToCall=flush", method = RequestMethod.POST)

         public ModelAndView flush(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,

                         HttpServletRequest request, HttpServletResponse response) {

         //FIXME: Could optimize this such that specific cache flushes don't execute if a complete CacheManager

         //flush was requested

         for (String name : ((CacheAdminForm) form).getFlush()) {

             //path == cacheManager index, cache index

             final List<Integer> path = path(removePrefix(name));

             final Tree<String, String> tree = ((CacheAdminForm) form).getCacheTree();

             final Integer cmIdx = path.get(0);

             final Node<String, String> cmNode = tree.getRootElement().getChildren().get(cmIdx);

             final String cmName = cmNode.getData();

             final CacheManager cm = getRegistry().getCacheManager(cmName);

             if (path.size() == 1) {

                 flushAllCaches(cm);

                 GlobalVariables.getMessageMap().putInfoForSectionId("mainGroup_div","flush.all.cachemanager", cmName);

             } else {

                 final Integer cIdx = path.get(1);

                 final Node<String, String> cNode = cmNode.getChildren().get(cIdx);

                 final String cName = cNode.getData();

                 flushSpecificCache(cm, cName);

                 GlobalVariables.getMessageMap().putInfoForSectionId("mainGroup_div",

                         "flush.single.cachemanager", cName, cmName);

             }

         }

         return super.start(form, result, request, response);

     }

     private static void flushSpecificCache(CacheManager cm, String cache) {

         for (String s : cm.getCacheNames()) {

             if (cache.equals(s)) {

                  cm.getCache(s).clear();

                  return;

             }

         }

     }

     private static void flushAllCaches(CacheManager cm) {

         for (String s : cm.getCacheNames()) {

             cm.getCache(s).clear();

         }

     }

     // given: 35_node_2_parent_node_0_parent_root will remove "35_"

     private static String removePrefix(String s) {

         final StringBuilder sbn = new StringBuilder(s);

         sbn.delete(0, sbn.indexOf("_") + 1);

         return sbn.toString();

     }

     // given: node_2_parent_node_0_parent_root will return {0, 2}

     private static List<Integer> path(String s) {

         final String[] path = s.split("_parent_");

         final List<Integer> pathIdx = new ArrayList<Integer>();

         //ignore length - 2 to ignore root

         for (int i = path.length - 2; i >= 0; i--) {

             pathIdx.add(Integer.valueOf(path[i].substring(5)));

         }

         return Collections.unmodifiableList(pathIdx);

     }

     private final class ByName implements Comparator<CacheManager> {

         @Override

         public int compare(CacheManager o1, CacheManager o2) {

             return String.CASE_INSENSITIVE_ORDER.compare(getRegistry().getCacheManagerName(o1),

                     getRegistry().getCacheManagerName(o2));

         }

     }

 }