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.kintai.payroll.dto.KdSubstituteHolidayDto;
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;

/**
 * 給与計算関連伝票の元となるクラス。<br><br>
 */
public abstract class PayrollSlip extends PayrollAction {
	
	/**
	 * 明細情報を取得する。
	 * @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 給与計算対象年月
	 * @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)
			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));
			} 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 対象年月日
	 * @return 計算値
	 * @throws MospException MosP例外処理が発生した場合
	 * @throws ClassNotFoundException  クラスが見つからなかった場合
	 * @throws NoSuchFieldException フィールドが見つからなかった場合
	 * @throws IllegalAccessException メソッドにアクセスできない場合
	 * @throws SQLException SQL例外が発生した場合
	 */
	protected double calcOverTimeLateNightWorkHoliday(Map<String, String> mapParams, String kCode, Date targetMonth)
			throws MospException, SQLException, IllegalAccessException, NoSuchFieldException, ClassNotFoundException {
		// 労使協定情報の取得
		AgreementBaseInfo agreement = part().laborAgreement().getUserLaborAgreement(kCode, targetMonth);
		// 残業代の計算 + 深夜代の計算+ 休出代の計算
		return overTime(mapParams, kCode, targetMonth, agreement) + lateNight(mapParams)
				+ workHoliday(mapParams, kCode, targetMonth, agreement);
	}
	
	/**
	 * 残業時間の計算
	 * @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)
			throws MospException, SQLException, IllegalAccessException, NoSuchFieldException, ClassNotFoundException {
		if (mapParams.size() != 0) {
			// 平日時間外
			double weekDayOvreTime = 0;
			// 所定休日時間外
			double weekHolidayOvreTime = 0;
			// 指定時間外
			double limitTerm = 0;
			// 月60時間超過平日時間外の計算
			double monthlyWeekOvreTime = 0;
			// 1年の限度時間外
			double limitYearOverTime = 0;
			// 代替休暇
			KdSubstituteHolidayDao kdSubstituteHolidayDao = new KdSubstituteHolidayDao();
			kdSubstituteHolidayDao.initDao(cfg, cmd, aspUser, user, conn);
			// 決済状況 = 確定のデータ取得
			KdSubstituteHolidayDto kdSubDaoFixed = new KdSubstituteHolidayDto();
			kdSubDaoFixed = kdSubstituteHolidayDao.findForCondition(kCode, MospUtility.getYear(targetDate), MospUtility
				.getMonth(targetDate), "fixed");
			// 決済状況 = 決済のデータ取得
			// 給与計算対象年月の2ヶ月前のデータを取得する
			KdSubstituteHolidayDto kdSubDaoPayment = new KdSubstituteHolidayDto();
			kdSubDaoPayment = 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;
		}
		return 0;
		
	}
	
	/**
	 * 深夜時間の計算
	 * @param mapParams パラメータ
	 * @return 残業時間の合計値
	 * @throws MospException MosP例外処理が発生した場合
	 */
	protected double lateNight(Map<String, String> mapParams) throws MospException {
		if (mapParams.size() > 0) {
			return checkParam(mapParams.get(PayrollConst.DTL_LATE_NIGHT_ALLOWANCE))
					* (checkParam(mapParams.get(PayrollConst.DTL_SNJIKAN)) / 60);
		}
		return 0;
	}
	
	/**
	 * 休出時間の計算
	 * @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 {
		if (mapParams.size() > 0) {
			return checkParam(mapParams.get(PayrollConst.DTL_WOKR_HOLIDAY_ALLOWANCE1))
					* (agreement.getOfficialHolidayRate() * 0.01)
					* (checkParam(mapParams.get(PayrollConst.DTL_KSJIKAN)) / 60);
		}
		return 0;
	}
	
	/**
	 * 日付操作（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;
		
	}
}
