package com.aimluck.eip.genka;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.jar.Attributes;

import org.apache.cayenne.access.DataContext;
import org.apache.cayenne.exp.Expression;
import org.apache.cayenne.exp.ExpressionFactory;
import org.apache.cayenne.query.SelectQuery;
import org.apache.jetspeed.services.logging.JetspeedLogFactoryService;
import org.apache.jetspeed.services.logging.JetspeedLogger;
import org.apache.turbine.util.RunData;
import org.apache.velocity.context.Context;

import com.aimluck.commons.field.ALDateTimeField;
import com.aimluck.commons.field.ALNumberField;
import com.aimluck.commons.field.ALStringField;
import com.aimluck.eip.common.ALAbstractSelectData;
import com.aimluck.eip.common.ALDBErrorException;
import com.aimluck.eip.common.ALData;
import com.aimluck.eip.common.ALPageNotFoundException;
import com.aimluck.eip.cayenne.om.portlet.EipTTodoCategory;
import com.aimluck.eip.cayenne.om.portlet.ImwTJobOrder;
import com.aimluck.eip.modules.actions.common.ALAction;
import com.aimluck.eip.orm.DatabaseOrmService;
import com.aimluck.eip.services.accessctl.ALAccessControlConstants;
import com.aimluck.eip.util.ALCommonUtils;
import com.aimluck.eip.util.ALEipUtils;
import com.aimluck.eip.genka.util.GenkaUtils;

public class GenkaSelectData extends ALAbstractSelectData implements ALData {

  /** logger */
  private static final JetspeedLogger logger = JetspeedLogFactoryService
      .getLogger(GenkaSelectData.class.getName());

  /** <code>viewYear</code> 開始年度 */
  private ALDateTimeField viewYear;

  /** <code>prevYear</code> 開始年度の前の年 */
  private ALDateTimeField prevYear;

  /** <code>nextYear</code> 開始年度の次の年 */
  private ALDateTimeField nextYear;
  
  /** <code>currentYear</code> 今年度 */
  private ALDateTimeField currentYear;
  
  private ArrayList jobOrderList;
  
  /** カテゴリ一覧 */
  private ArrayList categoryList;

  public void init(ALAction action, RunData rundata, Context context)
      throws ALPageNotFoundException, ALDBErrorException {
    
    // 開始年度
    viewYear = new ALDateTimeField("yyyy");    
    // 開始年度の前の年
    prevYear = new ALDateTimeField("yyyy");
    // 開始年度の次の年
    nextYear = new ALDateTimeField("yyyy");
    // 今年度
    currentYear = new ALDateTimeField("yyyy");
    
    // 自ポートレットからのリクエストであれば、パラメータを展開しセッションに保存する。
    if (ALEipUtils.isMatch(rundata, context)) {
      // 開始年度
      if (rundata.getParameters().containsKey("view_year")) {
        ALEipUtils.setTemp(rundata, context, "view_year", rundata
            .getParameters().getString("view_year"));
      }
    }

    // 開始年度
    String tmpViewYear = ALEipUtils.getTemp(rundata, context, "view_year");
    if (tmpViewYear == null || tmpViewYear.equals("")) {
      Calendar cal = Calendar.getInstance();
      Calendar companyStart = GenkaUtils.getCompanyStart(rundata,context);
      if(cal.get(Calendar.MONTH) < companyStart.get(Calendar.MONTH)){
        cal.add(Calendar.YEAR, -1);
      }
      cal.set(Calendar.DATE, 1);
      cal.set(Calendar.HOUR_OF_DAY, 0);
      cal.set(Calendar.MINUTE, 0);
      viewYear.setValue(cal.getTime());
    } else {
      viewYear.setValue(tmpViewYear);
      if (!viewYear.validate(new ArrayList())) {
        ALEipUtils.removeTemp(rundata, context, "view_year");
        throw new ALPageNotFoundException();
      }
    }
    
    // 開始年度の次の年、前の年
    Calendar cal2 = Calendar.getInstance();
    cal2.setTime(viewYear.getValue());
    cal2.add(Calendar.YEAR, 1);
    nextYear.setValue(cal2.getTime());
    cal2.add(Calendar.YEAR, -2);
    prevYear.setValue(cal2.getTime());
        
  }
  
  @Override
  protected Attributes getColumnMap() {
    // TODO 自動生成されたメソッド・スタブ
    return null;
  }

  @Override
  protected Object getResultData(Object obj) throws ALPageNotFoundException,
      ALDBErrorException {
    // TODO 自動生成されたメソッド・スタブ
    return null;
  }

  @Override
  protected Object getResultDataDetail(Object obj)
      throws ALPageNotFoundException, ALDBErrorException {
    // TODO 自動生成されたメソッド・スタブ
    return null;
  }

  @Override
  protected Object selectDetail(RunData rundata, Context context)
      throws ALPageNotFoundException, ALDBErrorException {
    // TODO 自動生成されたメソッド・スタブ
    return null;
  }

  @Override
  protected List selectList(RunData rundata, Context context)
      throws ALPageNotFoundException, ALDBErrorException {
    // TODO 自動生成されたメソッド・スタブ
    return null;
  }
  
  /**
   * 開始年度を取得します。
   * 
   * @return
   */
  public ALDateTimeField getViewYear() {
    return viewYear;
  }
  
  /**
   * 開始年度の前の年を取得します。
   * 
   * @return
   */
  public ALDateTimeField getPrevYear() {
    return prevYear;
  }

  /**
   * 開始年度の次の年を取得します。
   * 
   * @return
   */
  public ALDateTimeField getNextYear() {
    return nextYear;
  }

  /**
   * 今年度を取得します。
   * 
   * @return
   */
  public ALDateTimeField getCurrentYear() {
    return currentYear;
  }
  
  /**
  *
  * @param rundata
  * @param context
  */
 public void loadCategoryList(RunData rundata, Context context) {
   try {
     // カテゴリ一覧
     categoryList = new ArrayList();

     DataContext dataContext = DatabaseOrmService.getInstance()
         .getDataContext();
     Expression exp = ExpressionFactory.matchExp(
         EipTTodoCategory.USER_ID_PROPERTY, Integer.valueOf(ALEipUtils
             .getUserId(rundata)));
     exp.orExp(ExpressionFactory.matchExp(EipTTodoCategory.USER_ID_PROPERTY,
         Integer.valueOf(0)));
     SelectQuery query = new SelectQuery(EipTTodoCategory.class, exp);

     List aList = dataContext.performQuery(query);

     int size = aList.size();
     for (int i = 0; i < size; i++) {
       EipTTodoCategory record = (EipTTodoCategory) aList.get(i);
       GenkaCategoryResultData rd = new GenkaCategoryResultData();
       rd.initField();
       rd.setCategoryId(record.getCategoryId().longValue());
       rd.setCategoryName(record.getCategoryName());
       categoryList.add(rd);
     }
   } catch (Exception ex) {
     logger.error("Exception", ex);
   }
 }

 /**
 *
 * @param rundata
 * @param context
 */
  public void loadJobOrderList(RunData rundata, Context context) {
    try {
      // カテゴリ一覧
      jobOrderList = new ArrayList();
  
      DataContext dataContext = DatabaseOrmService.getInstance()
          .getDataContext();
      SelectQuery query = new SelectQuery(ImwTJobOrder.class);
      
      Expression exp = ExpressionFactory.matchExp(
          ImwTJobOrder.COMPLETION_CLASS_PROPERTY, 0);
      query.setQualifier(exp);
      Expression exp2 = ExpressionFactory.matchExp(
          ImwTJobOrder.DISABLED_PROPERTY, "F");
      query.andQualifier(exp2);
  
      List aList = dataContext.performQuery(query);
  
      int size = aList.size();
      for (int i = 0; i < size; i++) {
        ImwTJobOrder record = (ImwTJobOrder) aList.get(i);
        GenkaResultData rd = new GenkaResultData();
        rd.initField();
        rd.setJobOrderId(record.getJobOrderId().longValue());
        rd.setJobOrderName(record.getJobOrderName());
        jobOrderList.add(rd);
      }
    } catch (Exception ex) {
      logger.error("Exception", ex);
    }
  }

  /**
  *
  * @return
  */
 public ArrayList getCategoryList() {
   return categoryList;
 }

 /**
 *
 * @return
 */
 public ArrayList getJobOrderList() {
   return jobOrderList;
 }
  /**
   * アクセス権限チェック用メソッド。<br />
   * アクセス権限の機能名を返します。
   *
   * @return
   */
  public String getAclPortletFeature() {
    return ALAccessControlConstants.POERTLET_GENKA;
  }

}
