/*
 * MosP - Mind Open Source Project    http://www.mosp.jp/
 * Copyright (C) MIND Co., Ltd.       http://www.e-mind.co.jp/
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
package jp.mosp.payroll.base;

import java.sql.SQLException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import jp.mosp.common.common.MospException;
import jp.mosp.common.common.MospUtility;
import jp.mosp.common.part.MosPCodePart;
import jp.mosp.express.ExpressUtility;
import jp.mosp.mospcommon.system.AgreementBaseInfo;
import jp.mosp.payroll.dao.KdSubstituteHolidayDao;
import jp.mosp.payroll.dto.DetailDto;
import jp.mosp.payroll.dto.DetailMoneyDto;
import jp.mosp.payroll.dto.DetailTimeDto;
import jp.mosp.payroll.dto.KdSubstituteHolidayDto;

/**
 * 給与計算関連伝票の元となるクラス。<br><br>
 */
public abstract class PayrollSlip {
	
	/**
	 * 明細情報を取得する。
	 * @param list
	 * @param detailCode 明細コード
	 * @return 明細値
	 */
	protected DetailDto getDetailDto(List<?> list, String detailCode) {
		for (Object name : list) {
			DetailDto dto = (DetailDto)name;
			if (dto.getDetailCode().equals(detailCode)) {
				return dto;
			}
		}
		return null;
	}
	
	/**
	 * 明細リストを設定する。
	 * @param listDetail
	 * @param aryDetail 設定対象明細配列
	 */
	protected void setDetails(List<?> listDetail, String[][] aryDetail) {
		for (Object name : listDetail) {
			DetailDto dto = (DetailDto)name;
			for (String[] element : aryDetail) {
				if (dto.getDetailCode().equals(element[0])) {
					setDetailAmount(dto, Float.parseFloat(element[2]));
					break;
				}
			}
		}
	}
	
	/**
	 * 明細値を取得する。
	 * @param list 取得対象リスト
	 * @param detailCode 取得対象明細コード
	 * @return 明細値
	 */
	protected float getDetailAmount(List<?> list, String detailCode) {
		for (Object name : list) {
			DetailDto dto = (DetailDto)name;
			if (dto.getDetailCode().equals(detailCode)) {
				if (dto instanceof DetailTimeDto) {
					DetailTimeDto detailTimeDto = (DetailTimeDto)dto;
					return detailTimeDto.getAmount();
				}
				if (dto instanceof DetailMoneyDto) {
					DetailMoneyDto detailMoneyDto = (DetailMoneyDto)dto;
					return detailMoneyDto.getAmount();
				}
			}
		}
		return 0;
	}
	
	/**
	 * 明細配列を取得する。
	 * @param list 取得対象リスト
	 * @param checkDisplayType 0印字区分確認要否
	 * @return 明細配列
	 */
	protected String[][] getAryDetail(List<?> list, boolean checkDisplayType) {
		String[][] aryDetail = new String[list.size()][3];
		for (int i = 0; i < list.size(); i++) {
			DetailDto dto = (DetailDto)list.get(i);
			aryDetail[i][0] = dto.getDetailCode();
			aryDetail[i][1] = dto.getDetailAbbr();
			aryDetail[i][2] = "0";
			if (dto instanceof DetailTimeDto) {
				aryDetail[i][2] = String.valueOf(((DetailTimeDto)dto).getAmount());
			}
			if (dto instanceof DetailMoneyDto) {
				aryDetail[i][2] = String.valueOf(((DetailMoneyDto)dto).getAmount());
			}
			if (checkDisplayType && dto.getDisplayType() == PayrollConst.DETAIL_DISP_NONE) {
				if (String.valueOf(aryDetail[i][2]).equals("0")) {
					aryDetail[i][1] = "";
					aryDetail[i][2] = "";
				}
			}
		}
		return aryDetail;
	}
	
	/**
	 * 明細値を設定する。
	 * @param list 明細情報
	 * @param listAmount 明細値リスト
	 */
	protected void setDetailsAmount(List<?> list, List<?> listAmount) {
		for (Object name : list) {
			DetailDto dto = (DetailDto)name;
			for (Object name2 : listAmount) {
				DetailDto dtoAmount = (DetailDto)name2;
				if (dto.getDetailCode().equals(dtoAmount.getDetailCode())) {
					if (dtoAmount instanceof DetailTimeDto) {
						setDetailAmount(dto, ((DetailTimeDto)dtoAmount).getAmount());
						break;
					}
					if (dtoAmount instanceof DetailMoneyDto) {
						setDetailAmount(dto, ((DetailMoneyDto)dtoAmount).getAmount());
						break;
					}
				}
			}
		}
	}
	
	/**
	 * 明細値を計算する。
	 * @param listDetail 明細リスト
	 * @param mapParams  パラメータMap
	 * @param kCode 社員コード
	 * @param targetDate 給与計算対象年月
	 * @param agreement 
	 * @param kdSubstituteHolidayDao 
	 * @throws MospException MosP例外処理が発生した場合
	 * @throws ClassNotFoundException クラスが見つからなかった場合
	 * @throws NoSuchFieldException フィールドが見つからなかった場合
	 * @throws IllegalAccessException メソッドにアクセスできない場合
	 * @throws SQLException SQL例外が発生した場合
	 */
	protected void calcDetails(List<?> listDetail, Map<String, String> mapParams, String kCode, Date targetDate,
			AgreementBaseInfo agreement, KdSubstituteHolidayDao kdSubstituteHolidayDao) throws MospException,
			SQLException, IllegalAccessException, NoSuchFieldException, ClassNotFoundException {
		for (Object name : listDetail) {
			DetailDto dto = (DetailDto)name;
			// 残深休手当で平成22年4月1日以降の場合
			if (dto.getDetailCode().equals(PayrollConst.DTL_EACH_ALLOWANCE)
					&& MosPCodePart.afterLegalReformDate(targetDate)) {
				setDetailAmount(dto, (float)calcOverTimeLateNightWorkHoliday(mapParams, kCode, targetDate, agreement,
						kdSubstituteHolidayDao));
			} else {
				setDetailAmount(dto, calcExpr(dto.getExpression(), mapParams));
			}
		}
	}
	
	/**
	 * 明細値を設定する。
	 * @param detailDto 設定対象明細DTO
	 * @param amount    設定値
	 */
	protected void setDetailAmount(DetailDto detailDto, float amount) {
		if (detailDto instanceof DetailTimeDto) {
			DetailTimeDto dto = (DetailTimeDto)detailDto;
			dto.setAmount(amount);
			return;
		}
		if (detailDto instanceof DetailMoneyDto) {
			DetailMoneyDto dto = (DetailMoneyDto)detailDto;
			dto.setAmount((int)amount);
			return;
		}
	}
	
	/**
	 * 明細を初期化する。
	 * @param list     初期化対象明細リスト
	 * @param kCode    付加社員コード
	 * @param calcDate 付加計算年月
	 */
	protected void initDetails(List<?> list, String kCode, Date calcDate) {
		for (Object name : list) {
			initDetail((DetailDto)name, kCode, calcDate);
		}
	}
	
	/**
	 * 明細を初期化する。
	 * @param dto 設定対象明細DTO
	 * @param kCode    付加社員コード
	 * @param calcDate 付加計算年月
	 */
	private void initDetail(DetailDto dto, String kCode, Date calcDate) {
		dto.setKCode(kCode);
		dto.setCalcDate(calcDate);
		if (dto instanceof DetailTimeDto) {
			((DetailTimeDto)dto).setAmount(0F);
			return;
		}
		if (dto instanceof DetailMoneyDto) {
			((DetailMoneyDto)dto).setAmount(0);
			return;
		}
	}
	
	/**
	 * 計算式を計算する。<br>
	 * @param expression 計算式
	 * @param mapParams  パラメータ
	 * @return 計算値
	 * @throws MospException MosP例外処理が発生した場合
	 */
	protected float calcExpr(String expression, Map<String, String> mapParams) throws MospException {
		return ExpressUtility.calculate(expression, mapParams, new HashMap<String, String[][]>());
	}
	
	/**
	 * 残深休手当の計算する。<br>
	 * @param mapParams  パラメータ
	 * @param kCode 社員コード
	 * @param targetMonth 対象年月日
	 * @param agreement 
	 * @param kdSubstituteHolidayDao 
	 * @return 計算値
	 * @throws MospException MosP例外処理が発生した場合
	 * @throws ClassNotFoundException  クラスが見つからなかった場合
	 * @throws NoSuchFieldException フィールドが見つからなかった場合
	 * @throws IllegalAccessException メソッドにアクセスできない場合
	 * @throws SQLException SQL例外が発生した場合
	 */
	protected double calcOverTimeLateNightWorkHoliday(Map<String, String> mapParams, String kCode, Date targetMonth,
			AgreementBaseInfo agreement, KdSubstituteHolidayDao kdSubstituteHolidayDao) throws MospException,
			SQLException, IllegalAccessException, NoSuchFieldException, ClassNotFoundException {
		try {
			if (agreement != null) {
				if (mapParams.size() != 0) {
					// 残業代の計算 + 深夜代の計算+ 休出代の計算
					return overTime(mapParams, kCode, targetMonth, agreement, kdSubstituteHolidayDao)
							+ lateNight(mapParams) + workHoliday(mapParams, kCode, targetMonth, agreement);
				}
			} else {
				return 0.0;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return 0;
	}
	
	/**
	 * 残業時間の計算
	 * @param mapParams パラメータ
	 * @param kCode 社員コード
	 * @param targetDate 給与計算対象年月
	 * @param agreement 労使協定情報
	 * @return 残業時間の合計値 又は0.0
	 * @throws MospException MosP例外処理が発生した場合
	 * @throws ClassNotFoundException クラスが見つからなかった場合
	 * @throws NoSuchFieldException フィールドが見つからなかった場合
	 * @throws IllegalAccessException メソッドにアクセスできない場合
	 * @throws SQLException SQL例外が発生した場合
	 */
	protected double overTime(Map<String, String> mapParams, String kCode, Date targetDate,
			AgreementBaseInfo agreement, KdSubstituteHolidayDao kdSubstituteHolidayDao) throws MospException,
			SQLException, IllegalAccessException, NoSuchFieldException, ClassNotFoundException {
		// 平日時間外
		double weekDayOvreTime = 0;
		// 所定休日時間外
		double weekHolidayOvreTime = 0;
		// 指定時間外
		double limitTerm = 0;
		// 月60時間超過平日時間外の計算
		double monthlyWeekOvreTime = 0;
		// 1年の限度時間外
		double limitYearOverTime = 0;
		// 代替休暇
		// 決済状況 = 確定のデータ取得
		KdSubstituteHolidayDto kdSubDaoFixed = new KdSubstituteHolidayDto();
		kdSubDaoFixed = (KdSubstituteHolidayDto)kdSubstituteHolidayDao.findForCondition(kCode, MospUtility
			.getYear(targetDate), MospUtility.getMonth(targetDate), "fixed");
		// 決済状況 = 決済のデータ取得
		// 給与計算対象年月の2ヶ月前のデータを取得する
		KdSubstituteHolidayDto kdSubDaoPayment = new KdSubstituteHolidayDto();
		kdSubDaoPayment = (KdSubstituteHolidayDto)kdSubstituteHolidayDao.findForCondition(kCode, MospUtility
			.getYear(targetDate), MospUtility.getMonth(targetDate) - 2, "payment");
		// 平日時間外の計算
		weekDayOvreTime = calcOverTime(agreement, checkParam(mapParams.get(PayrollConst.DTL_WEEK_DAY_OVRE_TIME)),
				checkParam(mapParams.get(PayrollConst.DTL_OVER_TIME_ALLOWANCE)));
		// 所定休日時間外の計算
		weekHolidayOvreTime = calcOverTime(agreement,
				checkParam(mapParams.get(PayrollConst.DTL_WEEK_HOLIDAY_OVRE_TIME)), checkParam(mapParams
					.get(PayrollConst.DTL_OVER_TIME_ALLOWANCE)));
		// 月60時間超過時間外の計算 決済状況（確定）
		monthlyWeekOvreTime = calcMon60HoursFixed(agreement, mapParams, kdSubDaoFixed);
		// 月60時間超過時間外の計算 決済状況（決済）
		monthlyWeekOvreTime += calcMon60HoursPayment(agreement, mapParams, kdSubDaoPayment);
		/* 計算結果 */
		// 全ての合計を返す
		return weekDayOvreTime + weekHolidayOvreTime + limitTerm + monthlyWeekOvreTime + limitYearOverTime;
	}
	
	/**
	 * 深夜時間の計算
	 * @param mapParams パラメータ
	 * @return 残業時間の合計値
	 * @throws MospException MosP例外処理が発生した場合
	 */
	protected double lateNight(Map<String, String> mapParams) throws MospException {
		return checkParam(mapParams.get(PayrollConst.DTL_LATE_NIGHT_ALLOWANCE))
				* (checkParam(mapParams.get(PayrollConst.DTL_SNJIKAN)) / 60);
	}
	
	/**
	 * 休出時間の計算
	 * @param mapParams パラメータ
	 * @param kCode 社員コード
	 * @param targetDate 給与計算対象年月
	 * @param agreement 労使協定情報
	 * @return 休出代時間の合計値
	 * @throws MospException MosP例外処理が発生した場合
	 * @throws ClassNotFoundException クラスが見つからなかった場合
	 * @throws NoSuchFieldException フィールドが見つからなかった場合
	 * @throws IllegalAccessException メソッドにアクセスできない場合
	 * @throws SQLException SQL例外が発生した場合
	 */
	protected double workHoliday(Map<String, String> mapParams, String kCode, Date targetDate,
			AgreementBaseInfo agreement) throws MospException, SQLException, IllegalAccessException,
			NoSuchFieldException, ClassNotFoundException {
		return checkParam(mapParams.get(PayrollConst.DTL_WOKR_HOLIDAY_ALLOWANCE1))
				* (agreement.getOfficialHolidayRate() * 0.01)
				* (checkParam(mapParams.get(PayrollConst.DTL_KSJIKAN)) / 60);
	}
	
	/**
	 * 日付操作（YYYY/MM/01型）
	 * @param yyyy 年
	 * @param mm 月
	 * @return YYYY/MM/01
	 * @throws MospException MosP例外処理が発生した場合
	 */
	protected Date aworkHoliday(String yyyy, String mm) throws MospException {
		return MospUtility.getDate(yyyy + "/" + mm + "/" + "01");
	}
	
	/**
	 * パラメータの中身をチェックする
	 * @param payrollConst パラメータ
	 * @return パラメータに関連する値、又は0.0 
	 */
	protected Double checkParam(String payrollConst) {
		if (payrollConst == null) {
			return 0.0;
		} else {
			return Double.valueOf(payrollConst);
		}
	}
	
	/**
	 * 残業時間
	 * @param overtime 残業時間（分単位）
	 * @param price 残業単価
	 * @param agreement 労使協定情報
	 * @return 残業の代金
	 */
	protected Double calcOverTime(AgreementBaseInfo agreement, Double overtime, Double price) {
		return price * (agreement.getOverTimeRate() * 0.01) * (overtime / 60);
	}
	
	/**
	 * 月60時間超過時間外の計算 決済状況（確定）
	 * @param agreement 労使協定情報
	 * @param mapParams パラメータ
	 * @param kdSubDaoFixed 決済状況（確定）
	 * @return 月60時間超過時間外の代金
	 */
	protected Double calcMon60HoursFixed(AgreementBaseInfo agreement, Map<String, String> mapParams,
			KdSubstituteHolidayDto kdSubDaoFixed) {
		//  決済状況（確定）が存在しない
		if (kdSubDaoFixed != null) {
			// 代替休暇(平日)
			double alteVacaWeek = kdSubDaoFixed.getPaymentAcquireTime() / substituteHolidayPremOverTime(agreement);
			// 代替休暇(所定休日)
			double alteVacaGiven = kdSubDaoFixed.getPaymentAcquireHoliday() / substituteHolidayPremWeek(agreement);
			// 代替休暇時間(平日)
			double alteVacaTimeWeek = checkParam(mapParams.get(PayrollConst.DTL_MONTHLY_OVRE_TIME)) - alteVacaWeek;
			// 代替休暇時間(所定休日)
			double alteVacaTimeGiven = checkParam(mapParams.get(PayrollConst.DTL_MONTHLY_WEEK_HOLIDAY)) - alteVacaGiven;
			// 計算 
			return ((alteVacaTimeWeek + alteVacaTimeGiven) / 60) * (agreement.getSubQuitRate() * 0.01)
					* checkParam(mapParams.get(PayrollConst.DTL_OVER_TIME_ALLOWANCE));
		} else {
			return 0.0;
		}
	}
	
	/**
	 * 月60時間超過時間外の計算 決済状況（決済）
	 * @param agreement 労使協定情報
	 * @param mapParams パラメータ
	 * @param kdSubDaoPayment 決済状況（決済）
	 * @return 月60時間超過時間外の代金
	 */
	protected Double calcMon60HoursPayment(AgreementBaseInfo agreement, Map<String, String> mapParams,
			KdSubstituteHolidayDto kdSubDaoPayment) {
		//  決済状況（決済）が存在しない
		if (kdSubDaoPayment != null) {
			// 代替休暇(平日)
			double substituteHolidayOverTime = kdSubDaoPayment.getLiquidationOverTime()
					/ substituteHolidayPremOverTime(agreement);
			// 代替休暇(所定休日)
			double substituteHolidayOverTimeWeek = kdSubDaoPayment.getLiquidationWeekHoliday()
					/ substituteHolidayPremWeek(agreement);
			// 計算 
			return checkParam(mapParams.get(PayrollConst.DTL_OVER_TIME_ALLOWANCE))
					* (agreement.getSubQuitRate() * 0.01)
					* ((substituteHolidayOverTime + substituteHolidayOverTimeWeek) / 60);
		} else {
			return 0.0;
		}
	}
	
	/**
	 * 代替休暇割増(平日)
	 * @param agreement 労使協定情報
	 * @return 代替休暇割増(平日) 
	 */
	protected Double substituteHolidayPremOverTime(AgreementBaseInfo agreement) {
		return (agreement.getSubQuitRate() - agreement.getSubAcquireRate()) * 0.01;
		
	}
	
	/**
	 * 代替休暇割増(所定休日)
	 * @param agreement 労使協定情報
	 * @return 代替休暇割増(所定休日)
	 */
	protected Double substituteHolidayPremWeek(AgreementBaseInfo agreement) {
		return (agreement.getSubQuitRate() - agreement.getSubAcquireHolidayRate()) * 0.01;
		
	}
}
