/*
    * Copyright 2004-2006 the Seasar Foundation and the Others.
    *
    * 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.seasar.tuigwaa.plugin.database;
  
  import java.util.Calendar;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.seasar.framework.log.Logger;
  import org.seasar.tuigwaa.cms.core.CmsRequest;
  import org.seasar.tuigwaa.cms.core.CmsResponse;
  import org.seasar.tuigwaa.database.DataRow;
  import org.seasar.tuigwaa.database.DataTable;
  import org.seasar.tuigwaa.database.function.DaoMethod;
  import org.seasar.tuigwaa.database.function.criteria.CriteriaFunction;
  import org.seasar.tuigwaa.database.function.criteria.CriteriaListFunction;
  import org.seasar.tuigwaa.database.function.criteria.EqCriteriaFunction;
  import org.seasar.tuigwaa.model.DAOService;
  import org.seasar.tuigwaa.model.common.EntityDAO;
  import org.seasar.tuigwaa.model.core.TgwEntity;
  import org.seasar.tuigwaa.plugin.AbstractTgwPlugin;
  import org.seasar.tuigwaa.plugin.PluginException;
  import org.seasar.tuigwaa.plugin.PluginRequest;
  import org.seasar.tuigwaa.system.TgwRuntimeException;
  import org.seasar.tuigwaa.util.TgwContext;
  
  import com.isenshi.util.HtmlBuffer;
  
  /***
   * Counter Plugin
   * 
   * @author nishioka
   */
  public class CounterPlugin extends AbstractTgwPlugin {
  
  	private final static Logger log = Logger.getLogger(CounterPlugin.class);
  
  	private Map accessCache = new HashMap();
  
  	private static final String OPTION_TOTAL = "total";
  
  	private static final String OPTION_TODAY = "today";
  
  	private static final String OPTION_YESTERDAY = "yesterday";
  
  	protected void initialize(CmsRequest request, CmsResponse response,
  			PluginRequest prequest) throws PluginException {
  		String siteName = request.getSiteName();
  		requireEntity(siteName, Counter.class);
  	}
  
  	public String doHTMLView(CmsRequest request, CmsResponse response,
  			PluginRequest prequest) throws PluginException {
  		// requireLogic();
  
  		String siteName = request.getSiteName();
  		TgwEntity entity = requireEntity(siteName, Counter.class);
  
  		CounterDAO dao = new CounterDAO(entity);
  
  		String pagePath = request.getMainPagePath();
  		if (pagePath == null) {
  			throw new TgwRuntimeException("ITGW3001");
  		}
  
  		increment(dao, siteName, pagePath);
  
  		String option = null;
  		if (prequest.getArgs() != null && prequest.getArgs().length > 0) {
  			option = prequest.getArgs()[0];
  		}
  
  		return view(dao, pagePath, option);
  	}
  
  	private String toInt(Counter counter) {
  		if (counter == null) {
  			return "0";
  		}
  		return "" + counter.getAccessCount();
  	}
 
 	private String view(CounterDAO dao, String pagePath, String option) {
 
 		if (option == null) {
 			Counter total = dao.getTotalCounter(pagePath);
 			Counter today = dao.getTodayCounter(pagePath);
 			Counter yesterday = dao.getYesterdayCounter(pagePath);
 
 			HtmlBuffer buf = new HtmlBuffer();
 			buf.appendStartTag("h2");
 			buf.appendBody(getMessage("counter.header"));
 			buf.endTag();
 
 			buf.appendStartTag("ul");
 
 			buf.appendStartTag("li");
 			buf.appendBody(getMessage("counter.total"));
 			buf.appendBody(toInt(total));
 			buf.endTag();
 
 			buf.appendStartTag("li");
 			buf.appendBody(getMessage("counter.today"));
 			buf.appendBody(toInt(today));
 			buf.endTag();
 
 			buf.appendStartTag("li");
 			buf.appendBody(getMessage("counter.yesterday"));
 			buf.appendBody(toInt(yesterday));
 			buf.endTag();
 
 			buf.endAllTags();
 			return buf.toString();
 		} else {
 			Counter counter = null;
 			if (OPTION_TOTAL.equals(option)) {
 				counter = dao.getTotalCounter(pagePath);
 			} else if (OPTION_YESTERDAY.equals(option)) {
 				counter = dao.getYesterdayCounter(pagePath);
 			} else if (OPTION_TODAY.equals(option)) {
 				counter = dao.getTodayCounter(pagePath);
 			}
 			return toInt(counter);
 		}
 	}
 
 	private void increment(CounterDAO dao, String siteName, String pagePath)
 			throws PluginException {
 		String sessionId = TgwContext.getSessionId();
 		siteName = TgwContext.getSiteName();
 
 		Set set = (Set) accessCache.get(sessionId);
 		if (set != null && set.contains(siteName + "/" + pagePath)) {
 			return;
 		} else if (set == null) {
 			set = new HashSet();
 			accessCache.put(sessionId, set);
 		}
 		set.add(siteName + "/" + pagePath);
 
 		dao.increment(pagePath);
 		log.info(pagePath);
 	}
 
 	class CounterDAO {
 
 		static final String ACCESS_DATE = "accessDate";
 
 		static final String PAGE_NAME = "pageName";
 
 		DAOService daoService = (DAOService) getService(DAOService.class);
 
 		EntityDAO dao;
 
 		TgwEntity entity;
 
 		public CounterDAO(TgwEntity entity) {
 			this.dao = daoService.getDAO(entity);
 			this.entity = entity;
 		}
 
 		// FIXME: want to use SumProjectionFunction
 		public Counter getTotalCounter(String pagePath) {
 			EqCriteriaFunction criteria = new EqCriteriaFunction(PAGE_NAME,
 					pagePath);
 			DataTable dataTable = getCounterDataTable(criteria);
 
 			Counter counter = (Counter) entity.newInstance();
 			int total = 0;
 			while (dataTable.hasNext()) {
 				DataRow row = (DataRow) dataTable.next();
 				Counter rowCounter = (Counter) row.getDataObject();
 				int count = rowCounter.getAccessCount().intValue();
 				total += count;
 			}
 			counter.setPageName(pagePath);
 			counter.setAccessCount(new Integer(total));
 			// counter.setAccessDate(new Date());
 			return counter;
 		}
 
 		public Counter getCounter(String pagePath) {
 			EqCriteriaFunction func = new EqCriteriaFunction(PAGE_NAME,
 					pagePath);
 			return getCounter(func);
 		}
 
 		public Counter getTodayCounter(String pagePath) {
 			CriteriaListFunction criteria = new CriteriaListFunction();
 			EqCriteriaFunction page = new EqCriteriaFunction(PAGE_NAME,
 					pagePath);
 			EqCriteriaFunction today = new EqCriteriaFunction(ACCESS_DATE,
 					new Date());
 
 			criteria.addFunction(page);
 			criteria.addFunction(today);
 
 			return getCounter(criteria);
 		}
 
 		public Counter getYesterdayCounter(String pagePath) {
 			CriteriaListFunction criteria = new CriteriaListFunction();
 			EqCriteriaFunction func = new EqCriteriaFunction(PAGE_NAME,
 					pagePath);
 			Calendar yesterday = Calendar.getInstance();
 			yesterday.roll(Calendar.DATE, -1);
 			EqCriteriaFunction eqYesterday = new EqCriteriaFunction(
 					ACCESS_DATE, yesterday.getTime());
 
 			criteria.addFunction(func);
 			criteria.addFunction(eqYesterday);
 
 			return getCounter(criteria);
 		}
 
 		public Counter getCounter(CriteriaFunction criteria) {
 			DataTable dataTable = getCounterDataTable(criteria);
 			if (dataTable.hasNext()) {
 				DataRow dataRow = (DataRow) dataTable.next();
 				return (Counter) dataRow.getDataObject();
 			}
 			return null;
 		}
 
 		private DataTable getCounterDataTable(CriteriaFunction criteria) {
 			DaoMethod method = dao.getMethod(EntityDAO.INJECT_CRITERIA);
 			return (DataTable) method.evaluate(criteria);
 		}
 
 		public void increment(String pagePath) {
 			synchronized (dao) {
 				Counter counter = getTodayCounter(pagePath);
 				if (counter == null) {
 					counter = (Counter) entity.newInstance();
 					counter.setPageName(pagePath);
 				}
 				counter.setAccessDate(new Date());
 				counter.increment();
 				dao.saveOrUpdate(counter);
 			}
 		}
 	}
 }