ValidationUtils

/**
 * Copyright 2004-2013 The Kuali Foundation
 *
 * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
 *
 * 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.kuali.hr.time.util;

import org.apache.commons.lang.StringUtils;
import org.kuali.hr.lm.LMConstants;
import org.kuali.hr.lm.accrual.AccrualCategory;
import org.kuali.hr.lm.earncodesec.EarnCodeSecurity;
import org.kuali.hr.lm.leaveplan.LeavePlan;
import org.kuali.hr.location.Location;
import org.kuali.hr.paygrade.PayGrade;
import org.kuali.hr.time.authorization.DepartmentalRule;
import org.kuali.hr.time.calendar.Calendar;
import org.kuali.hr.time.department.Department;
import org.kuali.hr.time.earncode.EarnCode;
import org.kuali.hr.time.earncodegroup.EarnCodeGroup;
import org.kuali.hr.time.earncodegroup.EarnCodeGroupDefinition;
import org.kuali.hr.time.paytype.PayType;
import org.kuali.hr.time.principal.PrincipalHRAttributes;
import org.kuali.hr.time.salgroup.SalGroup;
import org.kuali.hr.time.service.base.TkServiceLocator;
import org.kuali.hr.time.task.Task;
import org.kuali.hr.time.workarea.WorkArea;
import org.kuali.kfs.coa.businessobject.Chart;
import org.kuali.rice.kim.api.identity.principal.Principal;
import org.kuali.rice.kim.api.services.KimApiServiceLocator;
import org.kuali.rice.krad.service.KRADServiceLocator;

import java.math.BigDecimal;
import java.sql.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * A few methods to assist with various validation tasks.
 */
public class ValidationUtils {

    /**
     * For DepartmentalRule objects, if a work area is defined, you can not
     * leave the department field with a wildcard. Permission for wildcarding
     * will be checked with other methods.
     *
     * @param dr The DepartmentalRule to examine.
     * @return true if valid, false otherwise.
     */
    public static boolean validateWorkAreaDeptWildcarding(DepartmentalRule dr) {
        boolean ret = true;

        if (StringUtils.equals(dr.getDept(), TkConstants.WILDCARD_CHARACTER)) {
            ret = dr.getWorkArea().equals(TkConstants.WILDCARD_LONG);
        }

        return ret;
    }

	/**
	 * Most basic validation: Only checks for presence in the database.
	 */
	public static boolean validateWorkArea(Long workArea) {
		return validateWorkArea(workArea, null);
	}

	/**
	 * Most basic validation: Only checks for presence in the database.
	 */
	public static boolean validateDepartment(String department) {
		return validateDepartment(department, null);
	}

	/**
	 * Most basic validation: Only checks for presence in the database.
	 */
	public static boolean validateAccrualCategory(String accrualCategory) {
		return validateAccrualCategory(accrualCategory, null);
	}


	public static boolean validateSalGroup(String salGroup, Date asOfDate) {
		boolean valid = false;

		if (StringUtils.equals(salGroup, TkConstants.WILDCARD_CHARACTER)) {
			valid = true;
		} else if (asOfDate != null) {
			SalGroup sg = TkServiceLocator.getSalGroupService().getSalGroup(salGroup, asOfDate);
			valid = (sg != null);
		} else {
			int count = TkServiceLocator.getSalGroupService().getSalGroupCount(salGroup);
			valid = (count > 0);
		}

		return valid;
	}

	public static boolean validateEarnCode(String earnCode, Date asOfDate) {
		boolean valid = false;

		if (asOfDate != null) {
			EarnCode ec = TkServiceLocator.getEarnCodeService().getEarnCode(earnCode, asOfDate);
			valid = (ec != null);
		} else {
			int count = TkServiceLocator.getEarnCodeService().getEarnCodeCount(earnCode);
			valid = (count > 0);
		}

		return valid;
	}

	public static boolean validateLeavePlan(String leavePlan, Date asOfDate) {
		boolean valid = false;

		if (asOfDate != null) {
			LeavePlan lp = TkServiceLocator.getLeavePlanService().getLeavePlan(leavePlan, asOfDate);
			valid = (lp != null);
		} else {
			// chen, moved the code that access db to service and dao
			valid = TkServiceLocator.getLeavePlanService().isValidLeavePlan(leavePlan);
		}

		return valid;
	}

	public static boolean validateEarnCodeOfAccrualCategory(String earnCode, String accrualCategory, Date asOfDate) {
		boolean valid = false;

		if (asOfDate != null) {
			AccrualCategory accrualCategoryObj = TkServiceLocator.getAccrualCategoryService().getAccrualCategory(accrualCategory, asOfDate);
			if (accrualCategoryObj != null) {
				if (StringUtils.equals(earnCode, accrualCategoryObj.getEarnCode())) {
					valid = true;
				}
			}
		} else {
			Map<String, String> fieldValues = new HashMap<String, String>();
			fieldValues.put("earnCode", earnCode);
			int matches = KRADServiceLocator.getBusinessObjectService().countMatching(EarnCode.class, fieldValues);

			valid = matches > 0;
		}

		return valid;
	}

	public static boolean validateAccCategory(String accrualCategory, Date asOfDate) {
		boolean valid = false;

		if (asOfDate != null) {
			AccrualCategory ac = TkServiceLocator.getAccrualCategoryService().getAccrualCategory(accrualCategory, asOfDate);
			valid = (ac != null);
		} else {
			Map<String, String> fieldValues = new HashMap<String, String>();
			fieldValues.put("accrualCategory", accrualCategory);
			int matches = KRADServiceLocator.getBusinessObjectService().countMatching(AccrualCategory.class, fieldValues);

			valid = matches > 0;
		}

		return valid;
	}

	public static boolean validateAccCategory(String accrualCategory, String principalId, Date asOfDate) {
		boolean valid = false;

		if (asOfDate != null) {
			AccrualCategory ac = TkServiceLocator.getAccrualCategoryService().getAccrualCategory(accrualCategory, asOfDate);
			if(ac != null && ac.getLeavePlan() != null) {
				// fetch leave plan users
				if(principalId != null) {
					PrincipalHRAttributes principalHRAttributes = TkServiceLocator.getPrincipalHRAttributeService().getPrincipalCalendar(principalId, asOfDate);
					if(principalHRAttributes != null && principalHRAttributes.getLeavePlan() != null) {
						valid = StringUtils.equals(ac.getLeavePlan().trim(), principalHRAttributes.getLeavePlan().trim());
					}
				} else {
					valid = true;
				}
			}
		} else {
			Map<String, String> fieldValues = new HashMap<String, String>();
			fieldValues.put("accrualCategory", accrualCategory);
			int matches = KRADServiceLocator.getBusinessObjectService().countMatching(AccrualCategory.class, fieldValues);

			valid = matches > 0;
		}
		return valid;
	}

	public static boolean validateLocation(String location, Date asOfDate) {
		boolean valid = false;

		if (asOfDate != null) {
			Location l = TkServiceLocator.getLocationService().getLocation(location, asOfDate);
			valid = (l != null);
		} else {
			int count = TkServiceLocator.getLocationService().getLocationCount(location);
			valid = (count > 0);
		}

		return valid;
	}

	public static boolean validatePayType(String payType, Date asOfDate) {
		boolean valid = false;

		if (asOfDate != null) {
			PayType pt = TkServiceLocator.getPayTypeService().getPayType(payType, asOfDate);
			valid = (pt != null);
		} else {
			int count = TkServiceLocator.getPayTypeService().getPayTypeCount(payType);
			valid = (count > 0);
		}

		return valid;
	}


	public static boolean validatePayGrade(String payGrade, String salGroup, Date asOfDate) {
		boolean valid = false;

		if (asOfDate != null) {
			PayGrade pg = TkServiceLocator.getPayGradeService().getPayGrade(payGrade, salGroup, asOfDate);
			valid = (pg != null);
		} else {
			int count = TkServiceLocator.getPayGradeService().getPayGradeCount(payGrade);
			valid = (count > 0);
		}

		return valid;
	}

    /**
     *
     * @param earnCode
     * @param otEarnCode If true, earn code is valid ONLY if it is an overtime earn code.
     * @param asOfDate
     * @return
     */
    public static boolean validateEarnCode(String earnCode, boolean otEarnCode, Date asOfDate) {
        boolean valid = false;

        if (asOfDate != null) {
            EarnCode ec = TkServiceLocator.getEarnCodeService().getEarnCode(earnCode, asOfDate);
            valid = (ec != null) && (otEarnCode ? ec.getOvtEarnCode().booleanValue() : true);
        }

        return valid;
    }

	/**
	 * Checks for row presence of a department, and optionally whether or not
	 * it is active as of the specified date.
	 */
	public static boolean validateDepartment(String department, Date asOfDate) {
		boolean valid = false;

        if (StringUtils.isEmpty(department)) {
          // do nothing, let false be returned.
        } else if (asOfDate != null) {
			Department d = TkServiceLocator.getDepartmentService().getDepartment(department, asOfDate);
		    valid = (d != null);
		} else {
			int count = TkServiceLocator.getDepartmentService().getDepartmentCount(department);
			valid = (count > 0);
		}

		return valid;
	}

    public static boolean validateChart(String chart) {
        boolean valid = false;

        if (!StringUtils.isEmpty(chart)) {
            Object o = KRADServiceLocator.getBusinessObjectService().findBySinglePrimaryKey(Chart.class, chart);
            valid = (o instanceof Chart);
        }

        return valid;
    }

	/**
	 * Checks for row presence of a work area, and optionally whether or not
	 * it is active as of the specified date.
	 */
    public static boolean validateWorkArea(Long workArea, Date asOfDate) {
        return ValidationUtils.validateWorkArea(workArea, null, asOfDate);
    }

	public static boolean validateWorkArea(Long workArea, String dept, Date asOfDate) {
		boolean valid = false;

		if (workArea == null) {
			valid = false;
		} else if (workArea.equals(TkConstants.WILDCARD_LONG)) {
			valid = true;
		} else if (asOfDate != null) {
			WorkArea wa = TkServiceLocator.getWorkAreaService().getWorkArea(workArea, asOfDate);
            if (wa != null && dept != null) {
                valid = StringUtils.equalsIgnoreCase(dept, wa.getDept());
            } else {
			    valid = (wa != null);
            }
		} else {
            // Not valid if no date is passed.
		}

		return valid;
	}
	/**
	 * Checks for row presence of a Accrual Category, and optionally whether or not
	 * it is active as of the specified date.
	 */
	public static boolean validateAccrualCategory(String accrualCategory, Date asOfDate) {
		boolean valid = false;

		if (StringUtils.equals(accrualCategory, TkConstants.WILDCARD_CHARACTER)) {
			valid = true;
		} else if (asOfDate != null) {
			AccrualCategory ac = TkServiceLocator.getAccrualCategoryService().getAccrualCategory(accrualCategory, asOfDate);
			valid = (ac != null);
		}

		return valid;
	}

	/**
	 * Checks for row presence of a principal Id, and optionally whether or not
	 * it is active as of the specified date.
	 */
	public static boolean validatePrincipalId(String principalId) {
		boolean valid = false;
		if (principalId != null) {
			Principal p = KimApiServiceLocator.getIdentityService().getPrincipal(principalId);
		    valid = (p != null);
		}
		return valid;
	}

    /**
     * No wildcarding is accounted for in this method.
     * @param task Task "Long Name"
     * @param asOfDate Can be null, if we just want to look for the general case.
     * @return True if the task is present / valid.
     */
    public static boolean validateTask(Long task, Date asOfDate) {
        boolean valid = false;

        if (task != null && asOfDate != null) {
            Task t = TkServiceLocator.getTaskService().getTask(task, asOfDate);
            valid = (t != null);
        } else if (task != null) {
        	int count = TkServiceLocator.getTaskService().getTaskCount(task);
            valid = (count > 0);
        }

        return valid;
    }

    /**
     * No wildcarding is accounted for in this method.
     * @param earnGroup EarnCodeGroup
     * @param asOfDate Can be null, if we just want to look for the general case.
     * @return True if the EarnCodeGroup is present / valid.
     */
    public static boolean validateEarnGroup(String earnGroup, Date asOfDate) {
        boolean valid = false;

        if (earnGroup != null && asOfDate != null) {
            EarnCodeGroup eg = TkServiceLocator.getEarnCodeGroupService().getEarnCodeGroup(earnGroup, asOfDate);
            valid = (eg != null);
        } else if (earnGroup != null) {
        	int count = TkServiceLocator.getEarnCodeGroupService().getEarnCodeGroupCount(earnGroup);
            valid = (count > 0);
        }

        return valid;
    }

    /**
     * @param earnGroup EarnCodeGroup
     * @param asOfDate
     * @return True if the EarnCodeGroup has overtime earn codes
     */
    public static boolean earnGroupHasOvertimeEarnCodes(String earnGroup, Date asOfDate) {
         if (earnGroup != null && asOfDate != null) {
             EarnCodeGroup eg = TkServiceLocator.getEarnCodeGroupService().getEarnCodeGroup(earnGroup, asOfDate);
             if(eg != null) {
            	for(EarnCodeGroupDefinition egd : eg.getEarnCodeGroups()) {
            		if(egd.getEarnCode() != null) {
            			EarnCode ec = TkServiceLocator.getEarnCodeService().getEarnCode(egd.getEarnCode(), asOfDate);
            			if(ec != null && ec.getOvtEarnCode()) {
            				return true;
            			}
            		}
            	}
             }
         }

        return false;
    }


	/**
	 * Checks for row presence of a pay calendar
	 */
	public static boolean validateCalendar(String calendarName) {
		Map<String, String> fieldValues = new HashMap<String, String>();
		fieldValues.put("calendarName", calendarName);
		int matches = KRADServiceLocator.getBusinessObjectService().countMatching(Calendar.class, fieldValues);

        return matches > 0;
	}

   public static boolean duplicateDeptEarnCodeExists(EarnCodeSecurity deptEarnCode) {
	   boolean valid = false;
	   int count = TkServiceLocator.getEarnCodeSecurityService().getEarnCodeSecurityCount
               (deptEarnCode.getDept(), deptEarnCode.getHrSalGroup(), deptEarnCode.getEarnCode(), deptEarnCode.isEmployee() ? "1" : "0",
                       deptEarnCode.isApprover() ? "1" : "0", deptEarnCode.getLocation(), deptEarnCode.isActive() ? "Y" : "N", deptEarnCode.getEffectiveDate(), null);
       if(count == 1) {
    	   valid = true;
    	   count = TkServiceLocator.getEarnCodeSecurityService().getEarnCodeSecurityCount
                   (deptEarnCode.getDept(), deptEarnCode.getHrSalGroup(), deptEarnCode.getEarnCode(), deptEarnCode.isEmployee() ? "1" : "0",
                           deptEarnCode.isApprover() ? "1" : "0", deptEarnCode.getLocation(), deptEarnCode.isActive() ? "Y" : "N", deptEarnCode.getEffectiveDate(), deptEarnCode.getHrEarnCodeSecurityId());
    	   if(count == 1) {
    		   valid = false;
    	   }
       } else if(count > 1) {
    	   valid = true;
       }

	   return valid;
   }

    /**
    * Checks for date not more than one year in the future from accrualDAte
    *
    */

   public static boolean validateOneYearFutureDateFromAccrualDate(Date date, Date accrualDate){
	   java.util.Calendar startDate = java.util.Calendar.getInstance();
	   startDate.setTime(accrualDate);
	   startDate.add(java.util.Calendar.DATE, -1);
	   startDate.set(java.util.Calendar.SECOND, 0);
	   startDate.set(java.util.Calendar.MINUTE, 0);
	   startDate.set(java.util.Calendar.HOUR_OF_DAY, 0);
	   java.util.Calendar endDate = java.util.Calendar.getInstance();
	   endDate.setTime(accrualDate);
	   endDate.add(java.util.Calendar.YEAR, 1); // One year after the current date
	   return date.compareTo(startDate.getTime()) * date.compareTo(endDate.getTime()) <= 0;
   }


   /**
    * Checks for date not more than one year in the future or current date
    *
    */

   public static boolean validateOneYearFutureDate(Date date){
	   java.util.Calendar startDate = java.util.Calendar.getInstance();
	   startDate.add(java.util.Calendar.DATE, -1);
	   startDate.set(java.util.Calendar.SECOND, 0);
	   startDate.set(java.util.Calendar.MINUTE, 0);
	   startDate.set(java.util.Calendar.HOUR_OF_DAY, 0);
	   java.util.Calendar endDate = java.util.Calendar.getInstance();
	   endDate.add(java.util.Calendar.YEAR, 1); // One year after the current date
	   return date.compareTo(startDate.getTime()) * date.compareTo(endDate.getTime()) <= 0;
   }

   /**
    * Checks for date not more than one year in the future and does not consider past date
    *
    */

   public static boolean validateOneYearFutureEffectiveDate(Date date){
	   java.util.Calendar startDate = java.util.Calendar.getInstance();
	   startDate.set(java.util.Calendar.MILLISECOND, 0);
	   startDate.set(java.util.Calendar.SECOND, 0);
	   startDate.set(java.util.Calendar.MINUTE, 0);
	   startDate.set(java.util.Calendar.HOUR_OF_DAY, 0);
	   startDate.add(java.util.Calendar.YEAR, 1); // One year after the current date
	   return date.compareTo(startDate.getTime()) <= 0;
   }

   /**
    * Checks for date in the future
    *
    */

   public static boolean validateFutureDate(Date date){
	   java.util.Calendar startDate = java.util.Calendar.getInstance();
	   startDate.add(java.util.Calendar.DATE, 0);
	   startDate.set(java.util.Calendar.SECOND, 0);
	   startDate.set(java.util.Calendar.MINUTE, 0);
	   startDate.set(java.util.Calendar.HOUR_OF_DAY, 0);
	   return date.compareTo(startDate.getTime()) > 0;
   }

	/**
	 * Checks for row presence of a pay calendar by calendar type
	 */
	public static boolean validateCalendarByType(String calendarName, String calendarType) {
		Map<String, String> fieldValues = new HashMap<String, String>();
		fieldValues.put("calendarName", calendarName);
		fieldValues.put("calendarTypes", calendarType);
		int matches = KRADServiceLocator.getBusinessObjectService().countMatching(Calendar.class, fieldValues);

		return matches > 0;
	}

	public static boolean validateRecordMethod(String recordMethod, String accrualCategory, Date asOfDate) {
		boolean valid = false;
		if (asOfDate != null) {
			AccrualCategory ac = TkServiceLocator.getAccrualCategoryService().getAccrualCategory(accrualCategory, asOfDate);
			if (ac != null
                    && ac.getUnitOfTime() != null) {
                if (LMConstants.RECORD_METHOD.HOUR.equals(ac.getUnitOfTime())
                        && (LMConstants.RECORD_METHOD.HOUR.equals(recordMethod))
                            || LMConstants.RECORD_METHOD.TIME.equals(recordMethod)) {
                    valid = true;
                } else {
                    valid = StringUtils.equalsIgnoreCase(ac.getUnitOfTime(), recordMethod);
                }

            }
		}
		return valid;
	}

	public static boolean validateEarnCodeFraction(String earnCode, BigDecimal amount, Date asOfDate) {
		boolean valid = true;
		 EarnCode ec = TkServiceLocator.getEarnCodeService().getEarnCode(earnCode, asOfDate);
		 if(ec != null && ec.getFractionalTimeAllowed() != null) {
			 BigDecimal fracAllowed = new BigDecimal(ec.getFractionalTimeAllowed());
			 if(amount.scale() > fracAllowed.scale()) {
				 valid = false;
			 }
		 }
		return valid;
	}
}