package jp.mosp.payroll.common.action;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.Comparator;
import java.util.List;

import jp.mosp.common.common.MospConst;
import jp.mosp.common.common.MospException;
import jp.mosp.common.common.MospUtility;
import jp.mosp.common.utils.DateUtil;
import jp.mosp.kintai.common.dto.MKihonDto;
import jp.mosp.legal.LegalConst;
import jp.mosp.payroll.base.AdjustmentAction;
import jp.mosp.payroll.base.PayrollConst;
import jp.mosp.payroll.common.vo.AdjustmentCalcVo;
import jp.mosp.payroll.dao.AdjustmentDao;
import jp.mosp.payroll.dao.PtCurrentDao;
import jp.mosp.payroll.dto.AdjustmentDto;
import jp.mosp.payroll.dto.CdAdjustmentDto;
import jp.mosp.payroll.dto.PtCurrentDto;

public class AdjustmentCalcAction extends AdjustmentAction {
	
	// コマンド
	private static final String	CMD_ADJUSTMENT_CALC_SHOW		= "P3001";	/* 参照     */
	private static final String	CMD_ADJUSTMENT_CALC_SEARCH		= "P3002";	/* 検索     */
	public static final String	CMD_ADJUSTMENT_CALC_RE_SEARCH	= "P3003";	/* 再検索   */
	private static final String	CMD_ADJUSTMENT_CALC_SORT		= "P3004";	/* ソート   */
	private static final String	CMD_ADJUSTMENT_CALC				= "P3005";	/* 計算開始 */
	private static final String	CMD_ADJUSTMENT_NEXT_YEAR		= "P3006";	/* 次年指定 */
	private static final String	CMD_ADJUSTMENT_BACK_YEAR		= "P3007";	/* 前年指定 */
	

	/**
	 * コンストラクタ
	 */
	public AdjustmentCalcAction() {
		super();
	}
	
	/**
	 * アクション
	 */
	public void action() throws Exception {
		// DBコネクション取得
		getConnection();
		// PAYROLL権限確認
		confirmPayrollAuth();
		// VOの取得
		AdjustmentCalcVo vo;
		Object obj = session.getAttribute(MospConst.ATT_FORMER_VO);
		if (obj instanceof AdjustmentCalcVo) {
			vo = (AdjustmentCalcVo)obj;
		} else {
			vo = new AdjustmentCalcVo();
		}
		vo.initVo(cfg, msg, cmd, aspUser, user);
		vo.clearMessage();
		vo.clearErrField();
		storeVo(PayrollConst.VO_ADJUSTMENT_CALC, vo);
		// VO及びフォワード先URLの設定
		setVo(vo);
		setUrl(vo.getRetUrl());
		// コマンド毎の処理
		if (cmd.equals(CMD_ADJUSTMENT_CALC_SHOW)) {
			// 表示
			show(vo);
		} else if (cmd.equals(CMD_ADJUSTMENT_CALC_SEARCH)) {
			// 検索
			vo.setParams(request);
			serachEmployeeList(vo);
			vo.setFormerKey(vo.KEY_K_CODE);
			vo.setIsAscending(true);
			vo.initListInfo();
		} else if (cmd.equals(CMD_ADJUSTMENT_CALC_RE_SEARCH)) {
			// 再検索
			session.removeAttribute(MospConst.ATT_DTO);
			if (vo.getList() != null && vo.getList().size() > 0) {
				serachEmployeeList(vo);
				vo.setPageButton();
				sortList(vo);
			} else {
				show(vo);
			}
		} else if (cmd.equals(CMD_ADJUSTMENT_CALC_SORT)) {
			// ソート
			sortList(key1, vo);
		} else if (cmd.equals(CMD_ADJUSTMENT_CALC)) {
			// 年末調整計算
			// パラメータ取得
			vo.setParams(request);
			// 年末調整計算
			adjust(vo);
		} else if (cmd.equals(CMD_ADJUSTMENT_NEXT_YEAR)) {
			// 年調年進め
			// パラメータ取得
			vo.setParams(request);
			// 年調年進め
			addAdjustYear(vo, 1);
			// 再表示
			vo.initFields();
			vo.setHidAdjustYear(getAdjustYear());
			// メッセージ設定
			vo.setMessage(MospUtility.getMessage(msg, PayrollConst.MSG_NEXT, PayrollConst.NAM_ADJUST_YEAR));
		} else if (cmd.equals(CMD_ADJUSTMENT_BACK_YEAR)) {
			// 年調年戻し
			// パラメータ取得
			vo.setParams(request);
			// 年調年戻し
			addAdjustYear(vo, -1);
			// 再表示
			vo.initFields();
			vo.setHidAdjustYear(getAdjustYear());
			// メッセージ設定
			vo.setMessage(MospUtility.getMessage(msg, PayrollConst.MSG_BACK, PayrollConst.NAM_ADJUST_YEAR));
		} else {
			throw new MospException(MospConst.EX_CMD_INVALID);
		}
	}
	
	/**
	 * 表示処理
	 * @param vo ConfirmAttListVoインスタンス
	 * @throws Exception
	 */
	private void show(AdjustmentCalcVo vo) throws Exception {
		// DBコネクションの取得
		if (conn == null) {
			getConnection();
		}
		if (vo.aryPltPosition == null) {
			// プルダウン取得
			vo.aryPltRetirement = getRetirementFlagArray();
			vo.aryPltPosition = getPositionArray();
			vo.aryPltAdjustmentType = LegalConst.ADJUSTMENT_ARRAY;
			vo.aryPltMidwayType = LegalConst.MIDWAY_ENTER_ARRAY;
			vo.aryPltAdjustStatus = PayrollConst.getAdjuStatusArray();
			vo.aryEra = getCodeArray(PayrollConst.TID_JAPANESE);
			// 和暦設定取得
			vo.listConf = getConfList(PayrollConst.CONF_ID_JP_IMP_CAL);
			// 初期設定
			vo.setPltRetirement(String.valueOf(PayrollConst.RETIREMENT_FLAG_OFF));
			vo.setPltAdjustmentType(LegalConst.ADJUSTMENT_NEEDED);
		}
		// 調整年取得
		vo.setHidAdjustYear(getAdjustYear());
	}
	
	/**
	 * 社員リスト検索
	 * @param vo AdjustmentCalcVoインスタンス
	 * @throws Exception
	 */
	private void serachEmployeeList(AdjustmentCalcVo vo) throws Exception {
		// DBコネクションの取得
		if (conn == null) {
			getConnection();
		}
		// 調整年取得
		int adjustYear = getAdjustYear();
		// 検索
		AdjustmentDao dao = new AdjustmentDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		List list = dao.findForCondition(adjustYear, getLastDateOfYear(adjustYear), vo.getTxtKCode(), vo.getTxtKName(),
				vo.getTxtKKana(), vo.getPltRetirement(), vo.getPltPosition(), vo.getPltAdjustmentType(), vo
					.getPltMidwayType(), vo.getPltAdjustStatus());
		// VOに設定
		vo.setFields(list);
		// 対象が無かった場合のメッセージ設定
		if (vo.getEscAryKCode().length == 0) {
			vo.addErrMessage(MospUtility.getMessage(msg, MospConst.MSG_NO_DATA, ""));
		}
	}
	
	/**
	 * 年末調整計算
	 * @param vo     対象VO
	 * @throws Exception 
	 */
	protected void adjust(AdjustmentCalcVo vo) throws Exception {
		// 計算確認準備
		boolean isCreateData = true;
		// コネクションの取得及びDAOの準備
		getConnection();
		// 年調年確認
		confirmAdjustYear(vo.getHidAdjustYear());
		// DAO準備
		prepareDao();
		// 既存対象外データ削除
		cdAdjustmentDao.deleteAdjustYear(adjustYear, startAdjDate, lastDate);
		// 年末調整データ作成対象者取得
//		List<MKihonDto> listMKihonDto = mKihonDao.findForAdjustData(startAdjDate, lastDate);
		// 日付調整
		List<MKihonDto> listMKihonDto = mKihonPayrollDao.findForSection(DateUtil.convDateToInteger(lastDate), DateUtil
			.convDateToInteger(startAdjDate));
		if (listMKihonDto.size() == 0) {
			vo.addErrMessage(MospUtility.getMessage(msg, MospConst.MSG_NO_DATA, ""));
			return;
		}
		// 対象年月
		setTargetData();
		for (int i = 0; i < listMKihonDto.size(); i++) {
			// 社員コード設定
			kCode = listMKihonDto.get(i).getKCode();
			// 人事情報設定
			setHumanInfo(vo);
			// 給与データ確認
			setTargetPaymentData();
			// 登録DTOの準備
			cdAdjustmentDto = cdAdjustmentDao.findForKey(kCode, adjustYear);
			if (cdAdjustmentDto == null) {
				cdAdjustmentDto = new CdAdjustmentDto();
				vo.setDtoFields(cdAdjustmentDto, kCode, adjustYear);
			}
			// 年末調整計算対象者確認
			if (!confirmAdjustType()) {
				isCreateData = false;
			}
			// 上記の確認でエラーがない社員は年調計算
			if (isCreateData) {
				// 対象データ所得税計算
				calcTargetIncomeTax(true);
				// 年末調整に必要な項目の計算
				calcNeedAdjust();
				// 年末調整計算
				adjustIncomeTax();
			} else {
				// 年末調整に必要な項目の計算(＊退職者の支払金額取得用)
				calcNeedAdjust();
				// 年調データは作成するが計算対象外の社員
				setAdjustOotStatus();
			}
			regist();
			// フラグ初期化
			isCreateData = true;
		}
		// 11月給与データ確認
		// 対象者で「年調する」で12/31時点で在職で、11月給与の無い者が存在するか。
		// 年末調整対象者取得
		// 賃金台帳は必要なため、年調データは作る。1/1〜12/31在職者が対象になる。
		// 12/31時点の最新データから入社日を取得し、対象者を検索する。
		// 「年調する」の場合は、11月給与が必須。
		// 確認
		// メッセージ設定
		vo.setMessage(MospUtility.getMessage(msg, PayrollConst.MSG_FINISH, PayrollConst.TTL_ADJUSTMENT_CALC));
	}
	
	/**
	 * 年末調整データ登録
	 * @param vo       登録対象VO
	 * @param storedVo セッション保存DTO
	 * @throws Exception 
	 */
	private void regist() throws Exception {
		CdAdjustmentDto currentDto = cdAdjustmentDao.findForKey(kCode, adjustYear);
		// 登録DTOの準備
		if (currentDto == null) {
			// 新規登録
			// データの挿入
			cdAdjustmentDao.insert(cdAdjustmentDto);
			// コミット
			commit();
		} else {
			// 更新登録
			// データの更新
			cdAdjustmentDao.update(cdAdjustmentDto);
			// コミット
			commit();
		}
	}
	
	/**
	 * 人事情報設定
	 * @param vo 設定対象VO
	 * @throws Exception 
	 * @throws ClassNotFoundException 
	 */
	private void setHumanInfo(AdjustmentCalcVo vo) throws Exception {
		// 人事基本情報取得
		mKihonDto = mKihonPayrollDao.findForKey(kCode);
		if (mKihonDto == null) {
			show(vo);
			String errMessage = MospUtility.getMessage(msg, PayrollConst.MSG_NO_HUMAN_DATA, "");
			addErrMessage(errMessage);
			throw new MospException(PayrollConst.EX_BEFORE_ENTRANCE, errMessage);
		}
		// 人事給与情報取得
		cmIncomeTaxDto = cmIncomeTaxDao.findForEmployeeDate(kCode, lastDate);
		cmMidwayEnterDto = cmMidwayEnterDao.findForKey(kCode);
	}
	
	/**
	 * 年調年更新
	 * @param vo     対象VO
	 * @param amount 更新年数
	 * @throws MospException 
	 * @throws NoSuchFieldException 
	 * @throws IllegalAccessException 
	 * @throws SQLException 
	 * @throws ClassNotFoundException 
	 */
	protected void addAdjustYear(AdjustmentCalcVo vo, int amount) throws SQLException, IllegalAccessException,
			NoSuchFieldException, MospException, ClassNotFoundException {
		PtCurrentDao dao;
		PtCurrentDto dto;
		// コネクションの取得及びDAOの準備
		getConnection();
		// 年調年確認
		confirmAdjustYear(vo.getHidAdjustYear());
		// 年調年データ取得
		dao = new PtCurrentDao(cfg, cmd, aspUser, user, conn);
		dto = dao.findForKey(PayrollConst.CURRENT_ADJUST, PayrollConst.CALC_ADJUST, addYear(lastDate, amount));
		if (dto == null) {
			dto = new PtCurrentDto();
			// データの設定
			dto.setOfficeCode(PayrollConst.CURRENT_ADJUST);
			dto.setCalcType(PayrollConst.CALC_ADJUST);
			dto.setCalcDate(addYear(lastDate, amount));
			dto.setCurrentStatus(PayrollConst.CURRENT_START);
			// データの更新
			dao.insert(dto);
		} else {
			// データの設定
			dto.setCurrentStatus(PayrollConst.CURRENT_START);
			// データの更新
			dao.update(dto);
		}
		// コミット
		//commit();
		dto = dao.findForKey(PayrollConst.CURRENT_ADJUST, PayrollConst.CALC_ADJUST, lastDate);
		if (dto != null) {
			// データの設定
			if (PayrollConst.CURRENT_END != dto.getCurrentStatus()) {
				dto.setCurrentStatus(PayrollConst.CURRENT_BREAK);
				// データの更新
				dao.update(dto);
				// コミット
				//commit();
			}
		}
		
		// コミット
		commit();
	}
	
	/**
	 * ソート
	 * @param key ソートキー
	 * @param vo ソート対象Listを含むVO
	 * @throws MospException 
	 */
	private void sortList(String key, AdjustmentCalcVo vo) throws MospException {
		vo.sortList(key, getComparator(key, vo));
		vo.setFields(vo.getList());
	}
	
	/**
	 * ソート(VO内のキー情報でソート)
	 * @param vo ソート対象Listを含むVO
	 * @throws MospException
	 */
	private void sortList(AdjustmentCalcVo vo) throws MospException {
		vo.sortList(getComparator(vo.getFormerKey(), vo));
		vo.setFields(vo.getList());
	}
	
	/**
	 * 比較クラス取得
	 * @param key ソートキー
	 * @param vo ソート対象Listを含むVO
	 * @throws MospException
	 */
	@SuppressWarnings("unchecked")
	private Comparator<Object> getComparator(String key, AdjustmentCalcVo vo) throws MospException {
		Comparator comp = null;
		if (key.equals(vo.KEY_ADJUST_STATUS)) {
			comp = new CompAdjustStatus();
		} else if (key.equals(vo.KEY_K_CODE)) {
			comp = new CompKCode();
		} else if (key.equals(vo.KEY_K_NAME)) {
			comp = new CompKName();
		} else if (key.equals(vo.KEY_ENTRANCE)) {
			comp = new CompEntranceDate();
		} else if (key.equals(vo.KEY_RETIREMENT)) {
			comp = new CompRetirementDate();
		} else if (key.equals(vo.KEY_ADJUSTMENT_TYPE)) {
			comp = new CompAdjustmentType();
		} else if (key.equals(vo.KEY_TAX_GAP)) {
			comp = new CompTaxGap();
		} else {
			throw new MospException(MospConst.EX_SORTKEY_INVALID);
		}
		return comp;
	}
	

	/**
	 * 年末調整計算状態による比較クラス
	 */
	protected static class CompAdjustStatus implements Comparator, Serializable {
		
		private static final long	serialVersionUID	= 69327727165636476L;
		

		public int compare(Object obj1, Object obj2) {
			AdjustmentDto dto1 = (AdjustmentDto)obj1;
			AdjustmentDto dto2 = (AdjustmentDto)obj2;
			if (dto1.getAdjustStatus() == null) {
				if (dto2.getAdjustStatus() == null) {
					return 0;
				}
				return -1;
			} else if (dto2.getAdjustStatus() == null) {
				if (dto1.getAdjustStatus() == null) {
					return 0;
				}
				return 1;
			} else {
				return dto1.getAdjustStatus().compareTo(dto2.getAdjustStatus());
			}
		}
	}
	
	/**
	 * 社員コードによる比較クラス
	 */
	protected static class CompKCode implements Comparator, Serializable {
		
		private static final long	serialVersionUID	= -6394722140439469749L;
		

		public int compare(Object obj1, Object obj2) {
			AdjustmentDto dto1 = (AdjustmentDto)obj1;
			AdjustmentDto dto2 = (AdjustmentDto)obj2;
			return dto1.getKCode().compareTo(dto2.getKCode());
		}
	}
	
	/**
	 * 社員名による比較クラス
	 */
	protected static class CompKName implements Comparator, Serializable {
		
		private static final long	serialVersionUID	= 4570032874139863533L;
		

		public int compare(Object obj1, Object obj2) {
			AdjustmentDto dto1 = (AdjustmentDto)obj1;
			AdjustmentDto dto2 = (AdjustmentDto)obj2;
			return dto1.getKName().compareTo(dto2.getKName());
		}
	}
	
	/**
	 * 入社日による比較クラス
	 */
	protected static class CompEntranceDate implements Comparator, Serializable {
		
		private static final long	serialVersionUID	= -6466289475103366012L;
		

		public int compare(Object obj1, Object obj2) {
			AdjustmentDto dto1 = (AdjustmentDto)obj1;
			AdjustmentDto dto2 = (AdjustmentDto)obj2;
			if (dto1.getEntranceDate() == 0) {
				if (dto2.getEntranceDate() == 0) {
					return 0;
				}
				return -1;
			} else if (dto2.getEntranceDate() == 0) {
				if (dto1.getEntranceDate() == 0) {
					return 0;
				}
				return 1;
			} else {
//				return dto1.getEntranceDate().compareTo(dto2.getEntranceDate());
				return dto1.getEntranceDate() == dto2.getEntranceDate() ? 0 : 1;
			}
		}
	}
	
	/**
	 * 退社日による比較クラス
	 */
	protected static class CompRetirementDate implements Comparator, Serializable {
		
		private static final long	serialVersionUID	= -592984256197903976L;
		

		public int compare(Object obj1, Object obj2) {
			AdjustmentDto dto1 = (AdjustmentDto)obj1;
			AdjustmentDto dto2 = (AdjustmentDto)obj2;
			if (dto1.getRetirementDate() == 0) {
				if (dto2.getRetirementDate() == 0) {
					return 0;
				}
				return -1;
			} else if (dto2.getRetirementDate() == 0) {
				if (dto1.getRetirementDate() == 0) {
					return 0;
				}
				return 1;
			} else {
//				return dto1.getRetirementDate().compareTo(dto2.getRetirementDate());
				return dto1.getRetirementDate() == dto2.getRetirementDate() ? 0 : 1;
			}
		}
	}
	
	/**
	 * 年末調整計算状態による比較クラス
	 */
	protected static class CompAdjustmentType implements Comparator, Serializable {
		
		private static final long	serialVersionUID	= -7043968925070629273L;
		

		public int compare(Object obj1, Object obj2) {
			AdjustmentDto dto1 = (AdjustmentDto)obj1;
			AdjustmentDto dto2 = (AdjustmentDto)obj2;
			if (dto1.getAdjustmentType() == null) {
				if (dto2.getAdjustmentType() == null) {
					return 0;
				}
				return -1;
			} else if (dto2.getAdjustmentType() == null) {
				if (dto1.getAdjustmentType() == null) {
					return 0;
				}
				return 1;
			} else {
				return dto1.getAdjustmentType().compareTo(dto2.getAdjustmentType());
			}
		}
	}
	
	/**
	 * 差引徴収税額による比較クラス
	 */
	protected static class CompTaxGap implements Comparator, Serializable {
		
		private static final long	serialVersionUID	= 5436156253746916682L;
		

		public int compare(Object obj1, Object obj2) {
			AdjustmentDto dto1 = (AdjustmentDto)obj1;
			AdjustmentDto dto2 = (AdjustmentDto)obj2;
			return dto2.getTaxGap() - dto1.getTaxGap();
		}
	}
	

	/**
	 * 在職/退職リスト取得
	 * @return 在職/退職リスト
	 */
	protected String[][] getRetirementFlagArray() {
		// 配列の作成
		String[][] aryRetirementFlag = new String[3][2];
		aryRetirementFlag[0][0] = "";
		aryRetirementFlag[0][1] = "";
		aryRetirementFlag[1][0] = String.valueOf(PayrollConst.RETIREMENT_FLAG_OFF);
		aryRetirementFlag[1][1] = PayrollConst.NAM_RETIREMENT_OFF;
		aryRetirementFlag[2][0] = String.valueOf(PayrollConst.RETIREMENT_FLAG_ON);
		aryRetirementFlag[2][1] = PayrollConst.NAM_RETIREMENT_ON;
		return aryRetirementFlag;
	}
	
}
