using Ease.Core.DataAccess;
using Ease.Core.Model;
using Ease.Core.Utility;
using System;
using System.Collections.Generic;
using HRM.BO;
using System.Linq;
namespace HRM.DA
{
    #region LeaveParameter Service

    public class LeaveParameterService : ServiceTemplate, ILeaveParameterService
    {
        #region Leave Process

        #region Private functions and declaration

        public LeaveParameterService()
        {
        }

        private void MapObject(LeaveParameter oLeaveParameter, DataReader oReader)
        {
            LeaveParameterDetail oDetail;
            oDetail = new LeaveParameterDetail();
            base.SetObjectID(oLeaveParameter, oReader.GetInt32("LeaveParamId").Value);
            oLeaveParameter.LeaveId = oReader.GetInt32("LeaveId").Value;
            oLeaveParameter.MaxAccumulatedDays = oReader.GetDouble("AccumulatedLeave").Value;
            oLeaveParameter.IsActive = oReader.GetBoolean("IsActive").Value;
            oLeaveParameter.ApplicableFor = (LeaveApplicableType)oReader.GetInt32("ApplicableFor").Value;
            oLeaveParameter.ForfitedMonth = oReader.GetInt32("FortifiedMonth").Value;
            oLeaveParameter.AllowAdvance = oReader.GetBoolean("AllowAdvance").Value;
            oLeaveParameter.IgnoreHoliday = oReader.GetBoolean("IgnoreHolidays").Value;
            oLeaveParameter.CalculationType = (EnumLeaveCalculationType)oReader.GetInt32("MonthlyBalance").Value;
            oLeaveParameter.IsForfited = oReader.GetBoolean("IsForfited").Value;
            oLeaveParameter.CreatedBy =
                oReader.GetString("CreatedBy") == null ? 0 : oReader.GetInt32("CreatedBy").Value;
            oLeaveParameter.CreatedDate = oReader.GetDateTime("CreationDate").GetValueOrDefault();
            oLeaveParameter.ModifiedBy =
                oReader.GetString("ModifiedBy") == null ? 0 : oReader.GetInt32("ModifiedBy").Value;
            oLeaveParameter.ModifiedDate = oReader.GetDateTime("ModifiedDate").GetValueOrDefault();
            oLeaveParameter.PayrollTypeID = oReader.GetInt32("PayrollTypeID").Value;
            //this.SetObjectState(oLeaveParameter, ObjectState.Saved);
            this.SetObjectState(oLeaveParameter, Ease.Core.ObjectState.Saved);
        }

        protected override T CreateObject<T>(DataReader oReader)
        {
            LeaveParameter oLeaveParameter = new LeaveParameter();
            MapObject(oLeaveParameter, oReader);
            return oLeaveParameter as T;
        }

        private LeaveParameter CreateObject(DataReader oReader)
        {
            LeaveParameter oLeaveParameter = new LeaveParameter();
            MapObject(oLeaveParameter, oReader);
            return oLeaveParameter;
        }

        private void MapDetailObject(LeaveParameterDetail oLeaveParameterDetail, DataReader oReader)
        {
            base.SetObjectID(oLeaveParameterDetail, oReader.GetInt32("ID").Value);
            oLeaveParameterDetail.LeaveParamId = oReader.GetInt32("LeaveParamId").Value;
            oLeaveParameterDetail.MaxDays = oReader.GetDouble("MaxDays").Value;
            //oLeaveParameterDetail.MaxGrndDays = oReader.GetDouble("MaxGrndDays").Value;
            oLeaveParameterDetail.MaxGrndDays = oReader.GetDouble("MaxGrndDays", true, 0.00);
            oLeaveParameterDetail.MaxCF = oReader.GetDouble("MaxCF").Value;
            oLeaveParameterDetail.MaxEncash = oReader.GetDouble("MaxEncash").Value;
            oLeaveParameterDetail.Year = oReader.GetInt32("Year").Value;
            this.SetObjectState(oLeaveParameterDetail, Ease.Core.ObjectState.Saved);
        }

        private void MapItemObject(LeaveParameter.paramItem oLeaveParameterDetail, DataReader oReader)
        {
            oLeaveParameterDetail.paramid = oReader.GetInt32("LeaveParamId").Value;
            oLeaveParameterDetail.id = oReader.GetInt32("LeaveParamItemId").Value;
            oLeaveParameterDetail.itemID = oReader.GetInt32("itemID").Value;
            oLeaveParameterDetail.ParamOnType = (EnumLeaveparamOn)oReader.GetInt32("ItemType").Value;
        }

        protected List<LeaveParameterDetail> CreateDetailObjects(DataReader oReader)
        {
            //LeaveParameterDetail oLeaveParameterDetail = new LeaveParameterDetail();
            //MapDetailObject(oLeaveParameterDetail, oReader);
            //return oLeaveParameterDetail as T;
            List<LeaveParameterDetail> oLeaveParameterDetails = new List<LeaveParameterDetail>();
            while (oReader.Read())
            {
                LeaveParameterDetail oLeaveParameterDetail = new LeaveParameterDetail();
                MapDetailObject(oLeaveParameterDetail, oReader);
                oLeaveParameterDetails.Add(oLeaveParameterDetail);
            }

            return oLeaveParameterDetails;
        }

        protected List<LeaveParameter.paramItem> CreateParamItems(DataReader oReader)
        {
            //LeaveParameterDetail oLeaveParameterDetail = new LeaveParameterDetail();
            //MapDetailObject(oLeaveParameterDetail, oReader);
            //return oLeaveParameterDetail as T;
            List<LeaveParameter.paramItem> oLeaveParameterDetails = new List<LeaveParameter.paramItem>();
            while (oReader.Read())
            {
                LeaveParameter.paramItem oLeaveParameterDetail = new LeaveParameter.paramItem();
                MapItemObject(oLeaveParameterDetail, oReader);
                oLeaveParameterDetails.Add(oLeaveParameterDetail);
            }

            return oLeaveParameterDetails;
        }

        private LeaveParameterDetail CreateDetailObject(DataReader oReader)
        {
            LeaveParameterDetail oLeaveParameterDetail = new LeaveParameterDetail();
            MapDetailObject(oLeaveParameterDetail, oReader);
            return oLeaveParameterDetail;
        }

        #endregion


        public List<LeaveParameter.paramItem> GetUsedParam(int leaveparamid, int payrolltypeid)
        {
            List<LeaveParameter.paramItem> usedGrades = new List<LeaveParameter.paramItem>();

            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();

                DataReader dr = new DataReader(LeaveParameterDA.GetUsedParamItem(tc, leaveparamid, payrolltypeid));
                usedGrades = this.CreateParamItems(dr);
                dr.Close();

                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception

                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);

                throw new ServiceException(e.Message, e);

                #endregion
            }

            return usedGrades;
        }

        #region Service implementation
        public LeaveParameterDetail GetApplicableForEmployee(Employee oEmp, DateTime operationDate, List<LeaveParameterDetail> oAllDetails, int nParamID)
        {
            //#### change by Current date function
            TimeSpan ts = operationDate - oEmp.JoiningDate;
            double y = Math.Round((double)ts.Days / 365, 2);
            //int year = operationDate.Year - oEmp.JoiningDate.Year+1;
            //int number=(int)y;
            //double number1 =(double)(y-number);
            //float f =(float)y;
            int year = 0;
            //if (y > (int)y)
            //    year = (int)y + 1;
            //else
            year = (int)y;
            int maxYear = -1;
            LeaveParameterDetail dtl = null;
            List<LeaveParameterDetail> oDetails = oAllDetails.FindAll(delegate(LeaveParameterDetail lpd) { return lpd.LeaveParamId == Convert.ToInt32(nParamID.ToString()); });
            foreach (LeaveParameterDetail detail in oDetails)
            {
                if (detail.Year <= year && detail.Year >= maxYear)
                {
                    maxYear = detail.Year;
                    dtl = detail;
                }
            }
            return dtl;
        }

        public List<LeaveParameter> Get()
        {
            
            List<LeaveParameter> oLeaveParameters = new List<LeaveParameter>();
            
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader oreader = new DataReader(LeaveParameterDA.GetLeaveParam(tc));
                oLeaveParameters = this.CreateObjects<LeaveParameter>(oreader);
                oreader.Close();
                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception
                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException(e.Message, e);
                #endregion
            }
            
            return oLeaveParameters;
        }

        public LeaveParameter Get(int id)
        {
            LeaveParameter oLeaveParameter = new LeaveParameter();

            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader dr = new DataReader(LeaveParameterDA.GetLeaveParam(tc, id));
                if (dr.Read())
                {
                    oLeaveParameter = CreateObject(dr);
                }

                dr.Close();

                if (oLeaveParameter != null)
                {
                    dr = new DataReader(LeaveParameterDA.GetDetails(tc, oLeaveParameter.ID));
                    oLeaveParameter.Details = CreateDetailObjects(dr);
                    dr.Close();
                    //tc.End();

                    dr = new DataReader(LeaveParameterDA.GetParamItems(tc, oLeaveParameter.ID));
                    oLeaveParameter.ParamItems = CreateParamItems(dr);
                    dr.Close();
                    tc.End();
                }
            }
            catch (Exception e)
            {
                #region Handle Exception

                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException("Failed to Get Leave Parameter :" + e.Message, e);

                #endregion
            }

            return oLeaveParameter;
        }

        public List<LeaveParameter> GetAllByPayrollTypeID(int PayrollTypeID)
        {
            List<LeaveParameter> leaveParams = new List<LeaveParameter>();

            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader dr = new DataReader(LeaveParameterDA.GetAllByPayrollTypeID(tc, PayrollTypeID));
                leaveParams = this.CreateObjects<LeaveParameter>(dr);
                dr.Close();
                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception

                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException("Failed to Get Leave Parameter :" + e.Message, e);

                #endregion
            }

            return leaveParams;
        }
        public List<LeaveParameterDetail> GetDetails()
        {
            #region Cache Header

            List<LeaveParameterDetail> oDetails = new List<LeaveParameterDetail>();

            #endregion
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader oreader = new DataReader(LeaveParameterDA.GetDetails(tc));
                oDetails = this.CreateDetailObjects(oreader);
                oreader.Close();
            }
            catch (Exception ex)
            {
                #region Handle Exception
                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(ex);
                throw new ServiceException("Failed to Get Leave Details: " + ex.Message, ex);
                #endregion
            }
            return oDetails;

        }
        private List<LeaveParameter> GetAppParams(int itemID, EnumLeaveparamOn paramType, int? leaveID)
        {
            List<LeaveParameter> leaveParams = new List<LeaveParameter>();

            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader dr = new DataReader(LeaveParameterDA.GetApplicableParams(tc, itemID, paramType, leaveID));
                leaveParams = this.CreateObjects<LeaveParameter>(dr);
                dr.Close();
                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception

                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException("Failed to Get Leave Parameter :" + e.Message, e);

                #endregion
            }

            if (leaveID != null && leaveParams.Count > 1)
            {
                throw new Exception("Multiple parameter found for a leave");
            }

            return leaveParams;
        }

        public List<LeaveParameter> GetApplicableParams(int itemID, EnumLeaveparamOn paramType)
        {
            return this.GetAppParams(itemID, paramType, null);
        }


        public LeaveParameter GetApplicableParam(int itemID, EnumLeaveparamOn paramType, int LeaveID)
        {
            List<LeaveParameter> lparams = null;

            lparams = this.GetAppParams(itemID, paramType,LeaveID);
            if (lparams.Count > 1)
            {
                throw new Exception("Multiple parameter found for a leave");
            }

            if (lparams.Count == 0) return null;
            return lparams[0];
        }


        public List<LeaveParameter> GetApplicableParam(List<LeaveParameter> Leaveparams, List<Leave> oleaves, int gradeOrLocationID,
            EnumLeaveparamOn paramType, Employee emp)
        {
            List<LeaveParameter> lparams = new List<LeaveParameter>();

            foreach (LeaveParameter param in Leaveparams)
            {
                if (param.ApplicableFor != LeaveApplicableType.Regardless)
                {
                    if (param.ApplicableFor == LeaveApplicableType.Confirmed && emp.IsConfirmed == false) continue;
                    if (param.ApplicableFor == LeaveApplicableType.Probetionary && emp.IsConfirmed == true) continue;
                }
                //param.Leave = oleaves.Find(x => x.ID == param.LeaveId);
                if (param.Leave == null)
                {
                    //param.Leave = new LeaveService().Get(param.LeaveId);
                    param.Leave = oleaves.Find(item => item.ID == param.LeaveId);
                }
                
                if (param.Leave.ApplicableFor != EnumGender.None)
                {
                    if (param.Leave.ApplicableFor != emp.Gender) continue;
                }

                //var item = param.ParamItems.Find(y => y.itemID == gradeOrLocationID && paramType == y.ParamOnType);
                //if (item != null)
                //{
                //    lparams.Add(param);
                //}
                lparams.Add(param);
            }
            return lparams;
        }


        public List<LeaveParameter> GetByParamId(int paramId)
        {
            List<LeaveParameter> oLeaveParameters = new List<LeaveParameter>();
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader oreader = new DataReader(LeaveParameterDA.GetByParamId(tc, paramId));
                oLeaveParameters = this.CreateObjects<LeaveParameter>(oreader);
                oreader.Close();
                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception

                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException("Failed to Get Leave Parameter : " + e.Message, e);

                #endregion
            }

            return oLeaveParameters;
        }

        public List<LeaveParameter> Get(EnumStatus status, int payrollTypeID, int? leaveID, bool? withDetail = false)
        {
            List<LeaveParameter> oLeaveParameters = new List<LeaveParameter>();
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader oreader = new DataReader(LeaveParameterDA.Get(tc, status, payrollTypeID, leaveID));
                oLeaveParameters = this.CreateObjects<LeaveParameter>(oreader);
                oreader.Close();
                if (oLeaveParameters.Count > 0 && withDetail == true)
                {
                    oreader = new DataReader(LeaveParameterDA.GetDetails(tc));
                    List<LeaveParameterDetail> details = this.CreateDetailObjects(oreader);
                    foreach (LeaveParameter item in oLeaveParameters)
                    {
                        item.Details = details.FindAll(x => x.LeaveParamId == item.ID);
                    }

                    oreader.Close();
                    oreader = new DataReader(LeaveParameterDA.GetAllParamItems(tc));
                    List<LeaveParameter.paramItem> pItems = this.CreateParamItems(oreader);
                    foreach (LeaveParameter item in oLeaveParameters)
                    {
                        item.ParamItems = pItems.FindAll(x => x.paramid == item.ID);
                    }

                    oreader.Close();
                }

                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception

                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException(e.Message, e);

                #endregion
            }

            return oLeaveParameters;
        }

        public List<LeaveParameterDetail> GetDetails(int leaveParamId)
        {
            List<LeaveParameterDetail> oDetails = new List<LeaveParameterDetail>();
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader oreader = new DataReader(LeaveParameterDA.GetDetails(tc, leaveParamId));
                oDetails = this.CreateDetailObjects(oreader);
                oreader.Close();
            }
            catch (Exception ex)
            {
                #region Handle Exception

                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(ex);
                throw new ServiceException("Failed to Get Leave Details: " + ex.Message, ex);

                #endregion
            }

            return oDetails;
        }

        public LeaveParameterDetail GetDetail(int paramID)
        {
            LeaveParameterDetail oLeaveDetail = new LeaveParameterDetail();

            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader dr = new DataReader(LeaveParameterDA.GetDetails(tc, paramID));
                if (dr.Read())
                {
                    oLeaveDetail = CreateDetailObject(dr);
                }

                dr.Close();
                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception

                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException("Failed to Get Leave Parameter: " + e.Message, e);

                #endregion
            }

            return oLeaveDetail;
        }

        public int Save(LeaveParameter oLeaveParameter)
        {
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin(true);
                if (oLeaveParameter.IsNew)
                {
                    int id = tc.GenerateID("LeaveParameter", "LEAVEPARAMID");
                    base.SetObjectID(oLeaveParameter, id);
                    LeaveParameterDA.Insert(tc, oLeaveParameter);
                }
                else
                {
                    LeaveParameterDA.Update(tc, oLeaveParameter);
                }

                LeaveParameterDA.DeleteDetails(tc, oLeaveParameter.ID);
                foreach (LeaveParameterDetail oDetail in oLeaveParameter.Details)
                {
                    oDetail.LeaveParamId = oLeaveParameter.ID;
                    this.SetObjectID(oDetail, LeaveParameterDA.GetNewDetailID(tc));
                    LeaveParameterDA.InsertChildren(tc, oDetail);
                }

                LeaveParameterDA.DeleteParamItems(tc, oLeaveParameter.ID);
                foreach (LeaveParameter.paramItem item in oLeaveParameter.ParamItems)
                {
                    item.paramid = oLeaveParameter.ID;
                    item.ParamOnType = oLeaveParameter.ParamOnType;
                    LeaveParameterDA.InsertParamItem(tc, item);
                }

                //      SetupDetailService sdetailService = new SetupDetailService();
                //sdetailService.Insert(tc, EnumParameterSetup.Leave, oLeaveParameter.SetupDetails, oLeaveParameter.ID);


                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception

                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException("Failed to Insert Leave Parameter :" + e.Message, e);

                #endregion
            }

            return oLeaveParameter.ID;
        }

        public void Delete(int id)
        {
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin(true);
                SetupDetailService sd = new SetupDetailService();
                sd.Delete(tc, EnumParameterSetup.Leave, id);

                LeaveParameterDA.DeleteDetails(tc, id);
                //LeaveParameterDA.DeleteLeaveGrades(tc, id);
                //LeaveParameterDA.DeleteLeavePayItems(tc, id);
                //LeaveParameterDA.DeleteLeaveSBU(tc, id);
                //LeaveParameterDA.DeleteLeaveLocation(tc, id);
                //LeaveParameterDA.DeleteLeaveFunction(tc, id);

                //tc.End();
                //tc = TransactionContext.Begin(true, UtilityDA.Contex);
                LeaveParameterDA.Delete(tc, id);
                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception

                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException("Failed to Delete Leave Parameter: " + e.Message, e);

                #endregion
            }
        }


        public static List<LeaveParameter> ApplicableParams(Employee oEmp, List<EnmSetupManagerTranType> setupTypes, List<SetupDetail> details, List<LeaveParameter> leaveParamss)
        {
            List<int> leaveParamIds = ApplicableParametersForReport(oEmp, setupTypes, details);
            List<LeaveParameter> leaveParams = new List<LeaveParameter>();
            foreach (LeaveParameter lparam in leaveParamss)
            {
                lparam.Leave = new LeaveService().Get(lparam.LeaveId);
                if (lparam.Leave.ApplicableFor != (EnumGender)oEmp.Gender && lparam.Leave.ApplicableFor != EnumGender.Other && lparam.Leave.ApplicableFor != EnumGender.None)
                {
                    continue;
                }

                bool found = false;
                foreach (int id in leaveParamIds)
                {
                    if (id == lparam.ID)
                    {
                        found = true;
                        break;
                    }
                }
                if (found)
                {
                    leaveParams.Add(lparam);
                    //if (lparam.IsProbationaryApplicable)
                    //{
                    //    if (!oEmp.IsConfirmed)
                    //    {
                    //        leaveParams.Add(lparam);
                    //    }
                    //}
                    //if (lparam.IsConfirmedApplicable)
                    //{
                    //    if (oEmp.IsConfirmed)
                    //    {
                    //        leaveParams.Add(lparam);
                    //    }
                    //}
                    //if (lparam.IsRegardlessApplicable)
                    //{
                    //    if (leaveParams.Find(x => x.ID == lparam.ID) == null)
                    //        leaveParams.Add(lparam);
                    //}




                    //switch (lparam.ApplicableFor)
                    //{
                    //    case LeaveApplicableType.Probetionary:
                    //        if (!oEmp.IsConfirmed)
                    //        {
                    //            leaveParams.Add(lparam);
                    //        }
                    //        break;
                    //    case LeaveApplicableType.Confirmed:
                    //        if (oEmp.IsConfirmed)
                    //        {
                    //            leaveParams.Add(lparam);
                    //        }
                    //        break;
                    //    case LeaveApplicableType.Regardless:
                    //        leaveParams.Add(lparam);
                    //        break;
                    //    default:
                    //        break;
                    //}

                }
            }
            return leaveParams;
        }
        public static List<int> ApplicableParametersForReport(Employee oEmp, List<EnmSetupManagerTranType> setupTypes, List<SetupDetail> details)
        {
            List<int> parametersID = new List<int>();


            //List<EnmSetupManagerTranType> setupTypes = SetupDetail.GetTypes(setup);
            if (setupTypes == null) return parametersID;

            //ObjectsTemplate<SetupDetail> details = SetupDetail.GetParameters(setup);

            foreach (EnmSetupManagerTranType type in setupTypes)
            {
                int nTranID = SetupDetailService.GetTranID(oEmp, type);
                if (nTranID == 0) continue;

                var setupIds = (from detail in details
                                where detail.TranType == type
                                && detail.TranID == nTranID
                                select detail.SetupID).Distinct();
                foreach (var id in setupIds)
                    parametersID.Add(id);
            }
            return parametersID;
        }
        public List<LeaveParameter> Get(bool isActive, int payrollTypeID)
        {
            TransactionContext tc = null;
            List<LeaveParameter> oLeaveParameters = new List<LeaveParameter>();
            try
            {
                tc = TransactionContext.Begin();
                DataReader oreader = new DataReader(LeaveParameterDA.Get(tc, isActive, payrollTypeID));
                oLeaveParameters = this.CreateObjects<LeaveParameter>(oreader);
                oreader.Close();
                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception
                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException(e.Message, e);
                #endregion
            }
            return oLeaveParameters;
        }
        public LeaveParameter ApplicableParam(Employee oEmp, int leaveID)
        {
            LeaveParameter oLeaveParameter = new LeaveParameter();
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader dr = new DataReader(LeaveParameterDA.Get(tc, oEmp, leaveID));
                if (dr.Read())
                {
                    oLeaveParameter = CreateObject(dr);
                }
                dr.Close();
                tc.End();

            }
            catch (Exception e)
            {
                #region Handle Exception
                if (tc != null)
                    tc.HandleError();
                ExceptionLog.Write(e);
                throw new ServiceException("Failed to Get Leave Parameter :" + e.Message, e);
                #endregion
            }
            return oLeaveParameter;
        }
       
        public List<LeaveParameter> ApplicableParamsForReport(Employee oEmp, List<EnmSetupManagerTranType> setupTypes, List<SetupDetail> details, List<LeaveParameter> leaveParamss)
        {
            List<int> leaveParamIds = ApplicableParametersForReport(oEmp, setupTypes, details);
            //ObjectsTemplate<LeaveParameter> leaveParamss = LeaveParameter.Get();
            List<LeaveParameter> leaveParams = new List<LeaveParameter>();
            foreach (LeaveParameter lparam in leaveParamss)
            {
                lparam.Leave = new LeaveService().Get(lparam.LeaveId);
                if (lparam.Leave.ApplicableFor != (EnumGender)oEmp.Gender && lparam.Leave.ApplicableFor != EnumGender.Other && lparam.Leave.ApplicableFor != EnumGender.None)
                {
                    continue;
                }

                bool found = false;
                foreach (int id in leaveParamIds)
                {
                    if (id == lparam.ID)
                    {
                        found = true;
                        break;
                    }
                }
                if (found)
                {
                    switch (lparam.ApplicableFor)
                    {
                        case LeaveApplicableType.Probetionary:
                            if (!oEmp.IsConfirmed)
                            {
                                leaveParams.Add(lparam);
                            }
                            break;
                        case LeaveApplicableType.Confirmed:
                            if (oEmp.IsConfirmed)
                            {
                                leaveParams.Add(lparam);
                            }
                            break;
                        case LeaveApplicableType.Regardless:
                            leaveParams.Add(lparam);
                            break;
                        default:
                            break;
                    }

                }
            }
            return leaveParams;
        }

        #endregion
        public LeaveParameterDetail GetApplicableForEmployee2(Employee oEmp, DateTime operationDate, List<LeaveParameterDetail> oAllDetails, int nParamID)
        {
            //#### change by Current date function
            TimeSpan ts = operationDate - oEmp.JoiningDate;
            double y = Math.Round((double)ts.Days / 365, 2);
            //int year = operationDate.Year - oEmp.JoiningDate.Year+1;
            //int number=(int)y;
            //double number1 =(double)(y-number);
            //float f =(float)y;
            int year = 0;
            double n = y - (int)y;
            //if (y > (int)y)
            //    year = (int)y + 1;
            //else
            if (n > 0)
                year = (int)y + 1;
            else
                year = (int)y;
            int maxYear = -1;
            LeaveParameterDetail dtl = null;
            List<LeaveParameterDetail> oDetails = oAllDetails.FindAll(delegate (LeaveParameterDetail lpd) { return lpd.LeaveParamId == Convert.ToInt32(nParamID.ToString()); });
            foreach (LeaveParameterDetail detail in oDetails)
            {
                if (detail.Year <= year && detail.Year >= maxYear)
                {
                    maxYear = detail.Year;
                    dtl = detail;
                }
            }
            return dtl;

        }
        #endregion
    }

    #endregion
}