using HRM.BO;
using Ease.Core.DataAccess;
using Ease.Core.Model;
using Ease.Core.Utility;
using System;
using System.Collections.Generic;
using static iTextSharp.text.pdf.AcroFields;

namespace HRM.DA
{
    #region OpiParameter Service

    public class OpiParameterService : ServiceTemplate, IOpiParameterService
    {
        #region Private functions and declaration

        public OpiParameterService()
        {
        }

        private void MapObject(OpiParameter oOpiParameter, DataReader oReader)
        {
            base.SetObjectID(oOpiParameter, oReader.GetInt32("OpiParameterID").Value);
            oOpiParameter.OpiType = (EnumOpiType)oReader.GetInt32("OpiType").Value;
            oOpiParameter.AmountToDistribute = oReader.GetDouble("AmountToDistribute").Value;
            oOpiParameter.AvgMonth = oReader.GetInt32("AvgMonth").Value;
            oOpiParameter.FlatAmount = oReader.GetDouble("FlatAmount").Value;
            oOpiParameter.ProvisionAmount = oReader.GetDouble("ProvisionAmount").Value;
            oOpiParameter.MinAmount =
                oReader.GetDouble("MinAmount") == null ? 0.0 : oReader.GetDouble("MinAmount").Value;
            oOpiParameter.MaxAmount =
                oReader.GetDouble("MaxAmount") == null ? 0.0 : oReader.GetDouble("MaxAmount").Value;
            oOpiParameter.FromDate = oReader.GetDateTime("FromDate") == null
                ? DateTime.MinValue
                : oReader.GetDateTime("FromDate").Value;
            oOpiParameter.ToDate = oReader.GetDateTime("ToDate") == null
                ? DateTime.MinValue
                : oReader.GetDateTime("ToDate").Value;
            oOpiParameter.Gender = (EnumGender)oReader.GetInt32("Gender");
            oOpiParameter.Status = (EnumStatus)oReader.GetInt32("Status");
            //oOpiParameter.Sequence = oReader.GetInt32("Sequence").Value;
            oOpiParameter.IsActive = oReader.GetBoolean("IsActive").Value;
            oOpiParameter.IsEarnedBasic = oReader.GetBoolean("IsEarnedBasic").Value;
            oOpiParameter.IsTaxable = oReader.GetBoolean("IsTaxable").Value;
            oOpiParameter.IsConfirmed = oReader.GetBoolean("IsConfirmed").Value;
            oOpiParameter.IsFractionate = oReader.GetBoolean("IsFractionate").Value;
            oOpiParameter.IsIAApplicable = oReader.GetBoolean("IsIAApplicable").Value;
            oOpiParameter.IsWithException = oReader.GetBoolean("IsWithException").Value;
            oOpiParameter.OpiItemID = oReader.GetString("OpiItemID") == null ? 0 : oReader.GetInt32("OpiItemID").Value;
            oOpiParameter.OpiPeriodicity = (EnumOpiPeriodicity)oReader.GetInt32("OpiPeriodicity");
            oOpiParameter.PercentOfBasic = oReader.GetDouble("PercentOfBasic").Value;
            oOpiParameter.PercentOfGross = oReader.GetDouble("PercentOfGross").Value;
            oOpiParameter.EntitleType = (EnumEntitleType)oReader.GetInt32("EntitleType").Value;
            oOpiParameter.OpiAvgPayType = (EnumOpiAvgPayType)oReader.GetInt32("OpiAvgPayType").Value;
            oOpiParameter.OpiAvgPayItemID = oReader.GetString("OpiAvgPayItemID") == null
                ? 0
                : oReader.GetInt32("OpiAvgPayItemID").Value;
            oOpiParameter.NoOfMonth = oReader.GetInt32("NoOfMonth").Value;
            oOpiParameter.CreatedBy = oReader.GetString("CreatedBy") == null ? 0 : oReader.GetInt32("CreatedBy").Value;
            oOpiParameter.CreatedDate = oReader.GetDateTime("CreationDate").Value;
            oOpiParameter.ModifiedBy =
                oReader.GetString("ModifiedBy") == null ? 0 : oReader.GetInt32("ModifiedBy").Value;
            oOpiParameter.ModifiedDate = oReader.GetDateTime("ModifiedDate");
            //oOpiParameter.GFFlatAmount = oReader.GetDouble("GFFlatAmount").Value;
            //oOpiParameter.GFPercentOfBasic = oReader.GetDouble("GFPercentOfBasic").Value;
            //oOpiParameter.GFPercentOfGross = oReader.GetDouble("GFPercentOfGross").Value;
            oOpiParameter.PayrollTypeID = oReader.GetString("PayrollTypeID") == null
                ? 0
                : oReader.GetInt32("PayrollTypeID").Value;
            this.SetObjectState(oOpiParameter, Ease.Core.ObjectState.Saved);
        }

        private void MapParameterGradeObject(OpiParameterGrade oGrade, DataReader oReader)
        {
            base.SetObjectID(oGrade, oReader.GetInt32("OPIPARAMETERGradeID").Value);
            oGrade.OpiParameterId = oReader.GetString("OpiParameterID") == null
                ? 0
                : oReader.GetInt32("OpiParameterID").Value;
            oGrade.GradeId = oReader.GetString("GradeID") == null ? 0 : oReader.GetInt32("GradeID").Value;
            oGrade.OpiItemId = oReader.GetString("OpiItemId") == null ? 0 : oReader.GetInt32("OpiItemId").Value;
            oGrade.PayrollTypeID =
                oReader.GetString("PayrollTypeID") == null ? 0 : oReader.GetInt32("PayrollTypeID").Value;
            this.SetObjectState(oGrade, Ease.Core.ObjectState.Saved);
        }

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

        protected OpiParameter CreateObject(DataReader oReader)
        {
            OpiParameter oOpiParameter = new OpiParameter();
            MapObject(oOpiParameter, oReader);
            return oOpiParameter;
        }

        protected List<OpiParameterGrade> CreateParameterGradeObject(DataReader oReader)
        {
            List<OpiParameterGrade> oGrades = new List<OpiParameterGrade>();
            while (oReader.Read())
            {
                OpiParameterGrade oGrade = new OpiParameterGrade();
                MapParameterGradeObject(oGrade, oReader);
                oGrades.Add(oGrade);
            }

            return oGrades;
        }

        #endregion

        #region Service implementation

        public OpiParameter Get(int id, int payrollTypeID)
        {
            OpiParameter oOpiParameter = null;

            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader oreader = new DataReader(OpiParameterDA.Get(tc, id, payrollTypeID));
                if (oreader.Read())
                {
                    oOpiParameter = this.CreateObject<OpiParameter>(oreader);
                }
                oreader.Close();
               
                if (oOpiParameter != null)
                {
                    DataReader dr = new DataReader(OpiParameterDA.GetGrades(tc, oOpiParameter.ID, payrollTypeID));
                    oOpiParameter.OpiParameterGrades = this.CreateParameterGradeObject(dr);
                    dr.Close();

                    oOpiParameter.OpiParameterIndividuals = new OpiParameterIndividualService().GetByParameterID(tc, oOpiParameter.ID);
                }
                tc.End();

            }
            catch (Exception e)
            {
                #region Handle Exception

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

                #endregion
            }

            return oOpiParameter;
        }

        public List<OpiParameter> Get(int payrollTypeID)
        {
            List<OpiParameter> oOpiParameters = new List<OpiParameter>();
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();
                DataReader oreader = new DataReader(OpiParameterDA.Get(tc, payrollTypeID));
                oOpiParameters = this.CreateObjects<OpiParameter>(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 oOpiParameters;
        }

        public List<OpiParameterGrade> GetGrades(int opiParameterID, int payrollTypeID)
        {
            List<OpiParameterGrade> oGrade = new List<OpiParameterGrade>();

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

                DataReader dr = new DataReader(OpiParameterDA.GetGrades(tc, opiParameterID, payrollTypeID));
                oGrade = this.CreateParameterGradeObject(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 oGrade;
        }


        public List<OpiParameterGrade> GetGrades(int payrollTypeID)
        {
            List<OpiParameterGrade> oGrades = null;
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin();

                DataReader dr = new DataReader(OpiParameterDA.GetGrades(tc, payrollTypeID));
                oGrades = this.CreateParameterGradeObject(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 oGrades;
        }


        public List<OpiParameter> Get(EnumStatus status, int payrollTypeID)
        {
            List<OpiParameter> opiParameters = new List<OpiParameter>();

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

                DataReader dr = new DataReader(OpiParameterDA.Get(tc, status, payrollTypeID));
                opiParameters = this.CreateObjects<OpiParameter>(dr);
                dr.Close();

                if(opiParameters.Count > 0)
                {
                    List<OpiParameterGrade> ogrades = this.GetGrades(payrollTypeID);
                    opiParameters.ForEach(x =>
                    {
                        x.OpiParameterGrades = ogrades.FindAll(y => y.OpiParameterId == x.ID);
                    });
                }

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

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

                throw new ServiceException(e.Message, e);

                #endregion
            }

            return opiParameters;
        }

        public List<OpiParameter> Get(EnumStatus status, EnumOpiType nType, int payrollTypeID)
        {
            List<OpiParameter> opiParameters = new List<OpiParameter>();

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

                DataReader dr = new DataReader(OpiParameterDA.Get(tc, status, nType, payrollTypeID));
                opiParameters = this.CreateObjects<OpiParameter>(dr);
                foreach (OpiParameter oparam in opiParameters)
                {
                    oparam.OpiParameterGrades = this.GetGrades(oparam.ID, payrollTypeID);
                }

                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 opiParameters;
        }

        public int Save(OpiParameter oOpiParameter)
        {
            TransactionContext tc = null;
            int id = 0;
            try
            {
                tc = TransactionContext.Begin(true);
                if (oOpiParameter.IsNew)
                {
                    id = tc.GenerateID("OpiParameter", "OpiParameterID");
                    base.SetObjectID(oOpiParameter, id);

                    OpiParameterDA.Insert(tc, oOpiParameter);
                }
                else
                {
                    OpiParameterDA.Update(tc, oOpiParameter);
                    OpiParameterDA.DeleteGrades(tc, oOpiParameter.ID);
                    OpiParameterIndividualDA.DeletebyOpiParamId(tc, oOpiParameter.ID);
                }

                id = tc.GenerateID("OpiParameterIndividual", "OpiParameterIndividualID");
                foreach (OpiParameterIndividual opiIndv in oOpiParameter.OpiParameterIndividuals)
                {
                    id = id + 1;
                    opiIndv.OpiParameterID = oOpiParameter.ID;
                    base.SetObjectID(opiIndv, id);

                    OpiParameterIndividualDA.Insert(tc, opiIndv);
                }

                id = tc.GenerateID("OPIPARAMETERGRADE", "OPIPARAMETERGRADEID");
                foreach (OpiParameterGrade oGrade in oOpiParameter.OpiParameterGrades)
                {
                    id = id + 1;
                    base.SetObjectID(oGrade, id);

                    oGrade.OpiParameterId = oOpiParameter.ID;
                    oGrade.OpiItemId = oOpiParameter.OpiItemID;
                    OpiParameterDA.InsertGrade(tc, oGrade);
                }

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

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

                #endregion
            }
        }

        public void Delete(int id)
        {
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin(true);
                OpiParameterDA.Delete(tc, id);
                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception

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

                #endregion
            }
        }

        #endregion

        #region IOpiParameterService Members

        public List<OpiParameter> Get(EnumStatus enumStatus, EnumOpiType enumOpiType, EnumEntitleType enumEntitleType,
            int payrollTypeID)
        {
            List<OpiParameter> opiParameters = null;

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

                DataReader dr =
                    new DataReader(OpiParameterDA.Get(tc, enumStatus, enumOpiType, enumEntitleType, payrollTypeID));
                opiParameters = this.CreateObjects<OpiParameter>(dr);
                foreach (OpiParameter oparam in opiParameters)
                {
                    oparam.OpiParameterGrades = this.GetGrades(oparam.ID, payrollTypeID);
                }

                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 opiParameters;
        }

        public List<OpiParameterGrade> GetUsedGrades(int alllowdeductid)
        {
            List<OpiParameterGrade> aDParameterGrade = new List<OpiParameterGrade>();

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

                DataReader dr = new DataReader(OpiParameterDA.GetUsedGrades(tc, alllowdeductid));
                aDParameterGrade = this.CreateParameterGradeObject(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 aDParameterGrade;
        }

        public void ChangeStatus(int id, EnumStatus enumStatus)
        {
            TransactionContext tc = null;
            try
            {
                tc = TransactionContext.Begin(true);
                OpiParameterDA.ChangeStatus(tc, id, enumStatus);
                tc.End();
            }
            catch (Exception e)
            {
                #region Handle Exception

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

                #endregion
            }
        }

        public List<OpiParameter> Get(EnumStatus enumStatus, EnumEntitleType enumEntitleType, int payrollTypeID)
        {
            List<OpiParameter> opiParameters = null;

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

                DataReader dr = new DataReader(OpiParameterDA.Get(tc, enumStatus, enumEntitleType, payrollTypeID));
                opiParameters = this.CreateObjects<OpiParameter>(dr);
                foreach (OpiParameter oparam in opiParameters)
                {
                    oparam.OpiParameterGrades = this.GetGrades(oparam.ID, payrollTypeID);
                }

                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 opiParameters;
        }

        #endregion

        public List<OpiParameter> GetApplicableParameters(Employee employee, int graId, List<OpiParameter> parameters)
        {
            List<OpiParameter> applicableParams = parameters.FindAll(delegate (OpiParameter param) { return IsApplicable(param, graId, employee); });

            return applicableParams;
        }

        public OpiParameter GetApplicableParameter(Employee employee, int graId, List<OpiParameter> parameters, int itemid)
        {
            foreach (OpiParameter item in parameters)
            {
                if (item.OpiItemID == itemid)
                {
                    if (IsApplicable(item, graId, employee) == true)
                        return item;
                }
            }
            return null;
        }

        private bool IsApplicable(OpiParameter param, int graid, Employee employee)
        {
            bool isApplicable = false;

            foreach (OpiParameterGrade adgrade in param.OpiParameterGrades)
            {
                if (adgrade.GradeId == graid)
                {
                    isApplicable = true;
                }
            }
            if (!isApplicable) return false;

            if (param.Gender != EnumGender.None
                && param.Gender != employee.Gender)
            {
                return false;
            }

            if (param.IsConfirmed && !employee.IsConfirmed)
            {
                return false;
            }

            return true;
        }
        public List<OpiParameter> ApplicableParameters(Employee emlpoyee, OPIProcessDetail detail, List<OpiParameter> allAdparameters
            ,List<EmployeeGradeSalary> gradesalaries)
        {
            List<OpiParameter> oparameters = new List<OpiParameter>();
            foreach (EmployeeGradeSalary gs in gradesalaries)
            {
                List<OpiParameter> lparameter = this.GetApplicableParameters(emlpoyee, gs.GradeID, allAdparameters);
                foreach (OpiParameter item in lparameter)
                {
                    if (oparameters.Contains(item) == false)
                        oparameters.Add(item);
                }
            }
            return oparameters;
            //foreach (EmployeeGradeSalary gs in salary.ArrearPaidGradeSalaries)
            //{
            //    List<ADParameter> aplparameter = this.GetApplicableParameters(emlpoyee, gs.GradeID, allAdparameters);
            //    gs.ADParameters = new List<ADParameter>();
            //    foreach (ADParameter item in aplparameter)
            //        gs.ADParameters.Add(item);
            //}


        }

        public double GetAmount(Employee oEmp, OpiParameter opiParam)
        {
            OpiParameterIndividual adEmp = null;
            double nAmount = 0.0;
            switch (opiParam.EntitleType)
            {
                case EnumEntitleType.Grade:
                    if (opiParam.PercentOfBasic > 0)
                        nAmount = oEmp.BasicSalary * opiParam.PercentOfBasic / 100.0 + opiParam.FlatAmount;
                    else if (opiParam.PercentOfGross > 0)
                        nAmount = oEmp.GrossSalary * opiParam.PercentOfBasic / 100.0 + opiParam.FlatAmount;
                    else
                        nAmount = opiParam.FlatAmount;
                    break;
                case EnumEntitleType.Individual:
                    adEmp = new OpiParameterIndividualService().Get(oEmp.ID, opiParam.OpiItemID, opiParam.ID);
                    if (adEmp != null)
                        nAmount = adEmp.Value;
                    else
                    {
                        if (opiParam.PercentOfBasic > 0)
                            nAmount = oEmp.BasicSalary * opiParam.PercentOfBasic / 100.0 + opiParam.FlatAmount;
                        else if (opiParam.PercentOfGross > 0)
                            nAmount = oEmp.GrossSalary * opiParam.PercentOfBasic / 100.0 + opiParam.FlatAmount;
                        else
                            nAmount = opiParam.FlatAmount;
                    }
                    break;
            }
            if (opiParam.MinAmount != 0 || opiParam.MaxAmount != 0)
            {
                if (nAmount < opiParam.MinAmount)
                {
                    nAmount = opiParam.MinAmount;
                }
                if (nAmount > opiParam.MaxAmount)
                {
                    nAmount = opiParam.MaxAmount;
                }
            }
            return nAmount;
        }

        public double GetIndividualAmount(Employee employee, DateTime fortheMonth,
                    OpiParameterIndividual ademployee, double basicSalary, double grossSalary, OpiParameter opiParam,  DateTime nextProcessDate)
        {
            double nAmount = 0.0;
            switch (opiParam.EntitleType)
            {
                case EnumEntitleType.Grade:
                    throw new ServiceException("You have choosed the wrong overloaded function to calculate"
                        + " Grade defined Allowance");
                case EnumEntitleType.Individual:

                    if (ademployee.ArrearType == EnumArrearType.NotPresent)
                    {
                        DateTime fromDate = GlobalFunctions.FirstDateOfMonth(nextProcessDate);
                        DateTime toDate = nextProcessDate;
                        if (ademployee.FromDate < GlobalFunctions.FirstDateOfMonth(fortheMonth))
                            fromDate = GlobalFunctions.FirstDateOfMonth(fortheMonth);
                        else fromDate = ademployee.FromDate;

                        if (ademployee.ToDate == null || ademployee.ToDate == DateTime.MinValue)
                            toDate = GlobalFunctions.LastDateOfMonth(fortheMonth);
                        else toDate = (DateTime)ademployee.ToDate;

                        if (toDate > GlobalFunctions.LastDateOfMonth(fortheMonth))
                            toDate = GlobalFunctions.LastDateOfMonth(fortheMonth);

                        if (ademployee.OpiPeriodicity != EnumOpiPeriodicity.OnceOff)
                            if (employee.EndOfContractDate != null || employee.EndOfContractDate != DateTime.MinValue)
                                if (employee.EndOfContractDate < toDate)
                                    toDate = (DateTime)employee.EndOfContractDate;
                        if (ademployee.ValueType == EnumValueType.Other)
                        {
                            //while percent of basic then not required to do fractionate of date basis
                            //if(this.PercentOfBasic >0)
                            //   nAmount = (basicSalary * ademployee.MonthlyAmount)/100 * PayrollPayrollGlobalFunctions.GetFraction(fromDate, toDate);
                            //else if (this.PercentOfGross>0)
                            //    nAmount = (grossSalary * ademployee.MonthlyAmount)/100 * PayrollPayrollGlobalFunctions.GetFraction(fromDate, toDate);
                            if (opiParam.PercentOfBasic > 0)
                                nAmount = (basicSalary * ademployee.Value) / 100 * GlobalFunctions.GetFraction(fromDate, toDate);
                            else if (opiParam.PercentOfGross > 0)
                                nAmount = (grossSalary * ademployee.Value) / 100 * GlobalFunctions.GetFraction(fromDate, toDate);

                        }
                        else nAmount = ademployee.Value * GlobalFunctions.GetFraction(fromDate, toDate);//PayrollPayrollGlobalFunctions.GetFraction(fromDate, toDate);
                    }
                    else if (ademployee.ArrearType == EnumArrearType.ToCalculate)
                    {
                        if (ademployee.ValueType == EnumValueType.Other)
                        {
                            if (opiParam.PercentOfBasic > 0)
                                nAmount = (basicSalary * ademployee.Value) / 100 * GlobalFunctions.GetFraction(ademployee.FromDate, (DateTime)ademployee.ToDate);
                            else if (opiParam.PercentOfGross > 0)
                                nAmount = (grossSalary * ademployee.Value) / 100 * GlobalFunctions.GetFraction(ademployee.FromDate, (DateTime)ademployee.ToDate);
                        }
                        else nAmount = ademployee.Value *
                           GlobalFunctions.GetFraction(ademployee.FromDate, (DateTime)ademployee.ToDate);
                    }

                    break;
            }
            return nAmount;
        }



        public double GetGradeDefinedAmount(Employee employee, List<EmployeeGradeSalary> gradeSalarires, OpiParameter param)
        {
            double nAmount = 0;
            foreach (EmployeeGradeSalary item in gradeSalarires)
            {
                nAmount = nAmount + this.GetGradeDefinedAmount(employee, item.BasicSalary, item.GrossSalary, item.FractionofFromTo, param);
            }
            return nAmount;
        }

        public double GetGradeDefinedAmount(Employee employee, EmployeeGradeSalary gradeSalary, OpiParameter param)
        {
            return this.GetGradeDefinedAmount(employee, gradeSalary.BasicSalary, gradeSalary.GrossSalary, gradeSalary.FractionofFromTo
                , param);
        }
        public double GetGradeDefinedAmount(Employee employee, double basicSalary,
            double grossSalary, double fractionate, OpiParameter opiParam)
        {
            OpiParameterIndividual opiIndividual = null;
            double nAmount = 0.0;
            switch (opiParam.EntitleType)
            {
                case EnumEntitleType.Grade:
                    if (opiParam.PercentOfBasic + opiParam.GFPercentOfBasic + opiParam.FlatAmount + opiParam.GFFlatAmount > 0)
                    {
                        //    if (this.PercentOfBasic > 0)
                        //    //nAmount = basicSalary * this.PercentOfBasic / 100.0 + this.FlatAmount;
                        //    if(this.IsFractionate)
                        //        nAmount = nAmount + this.FlatAmount * fractionate + (basicSalary * this.PercentOfBasic * fractionate) / 100.0;
                        //    else
                        //        nAmount = nAmount + ((basicSalary * this.PercentOfBasic / 100.0) * fractionate);
                        //else if (this.PercentOfGross > 0)
                        //    //nAmount = grossSalary * this.PercentOfGross / 100.0 + this.FlatAmount;
                        //    if (this.IsFractionate)
                        //        nAmount = nAmount + this.FlatAmount * fractionate + (basicSalary * this.PercentOfBasic * fractionate) / 100.0;
                        //    else
                        //        nAmount = nAmount + ((basicSalary * this.PercentOfBasic / 100.0) * fractionate);
                        //else
                        //    nAmount = this.FlatAmount * fractionate;

                        if (opiParam.IsFractionate)
                        {

                                nAmount = nAmount + opiParam.FlatAmount * fractionate + (basicSalary * opiParam.PercentOfBasic * fractionate) / 100.0;

                        }

                        else
                        {
 
                                nAmount = nAmount + opiParam.FlatAmount + ((basicSalary * opiParam.PercentOfBasic / 100.0) * fractionate);
  

                        }
                    }
                    else if (opiParam.PercentOfGross + opiParam.GFPercentOfGross > 0)
                        //nAmount = grossSalary * this.PercentOfGross / 100.0 + this.FlatAmount;
                        if (opiParam.IsFractionate)
                        {

                                nAmount = nAmount + opiParam.FlatAmount * fractionate + (basicSalary * opiParam.PercentOfBasic * fractionate) / 100.0;

                        }

                        else
                        {

                                nAmount = nAmount + ((basicSalary * opiParam.PercentOfBasic / 100.0) * fractionate);
                        }

                    else
                    {

       
                            nAmount = opiParam.FlatAmount * fractionate;
 
                    }


                    if (opiParam.NotApplicable.Exists(delegate (OpiParameterIndividual adEmployee) { return adEmployee.EmployeeId 
                        == employee.ID; }))
                    {
                        nAmount = 0;
                    }
                    else
                    {
                        OpiParameterIndividual adEmp = opiParam.Exception.Find(delegate (OpiParameterIndividual adEmployee)
                        { return adEmployee.EmployeeId == employee.ID; });
                        if (adEmp != null)
                        {
                            switch (adEmp.ValueType)
                            {
                                case EnumValueType.Amount:
                                    nAmount = adEmp.Value;
                                    break;
                                case EnumValueType.Other:
                                    if (opiParam.PercentOfBasic > 0)
                                        nAmount = basicSalary * adEmp.Value / 100.0 * fractionate; //+ this.FlatAmount;
                                                                                                   // nAmount = basicSalary * adEmp.Value  / 100.0 + this.FlatAmount;
                                    else if (opiParam.PercentOfGross > 0)
                                    {
                                        nAmount = grossSalary * adEmp.Value / 100.0 * fractionate; //+ this.FlatAmount;
                                        //nAmount = grossSalary * adEmp.Value / 100.0 + this.FlatAmount;
                                    }

                                    break;
                            }
                        }
                    }
                    //if (this.IsFlatAmount == true) nAmount = PayrollPayrollGlobalFunctions.Round(nAmount * fractionate);
                    //nAmount = PayrollPayrollGlobalFunctions.Round(nAmount * fractionate);
                    break;

                case EnumEntitleType.Individual:
                    throw new ServiceException("You have choosed the wrong overloaded function to calculate"
                        + " Individual Allowance");
            }
            if (opiParam.MinAmount != 0 || opiParam.MaxAmount != 0)
            {
                if (nAmount < opiParam.MinAmount)
                {
                    nAmount = opiParam.MinAmount;
                }
                if (nAmount > opiParam.MaxAmount)
                {
                    nAmount = opiParam.MaxAmount;
                }
            }
            return nAmount;
        }

    }

    #endregion
}