using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using _0_Framework.Application;
using _0_Framework.Application.Enums;
using Company.Domain.ClassificationSchemeAgg;
using CompanyManagment.App.Contracts.ClassificationScheme;
using CompanyManagment.App.Contracts.YearlySalary;
using Microsoft.EntityFrameworkCore;

namespace CompanyManagment.Application;

public class ClassificationSchemeApplication : IClassificationSchemeApplication
{
    private readonly IClassificationSchemeRepository _classificationSchemeRepository;
    private readonly IClassificationGroupRepository _classificationGroupRepository;
    private readonly IClassificationGroupSalariesRepository _classificationGroupSalariesRepository;
    private readonly IClassificationRialCoefficientRepository _classificationRialCoefficientRepository;
    private readonly IClassificationEmployeeRepository _classificationEmployeeRepository;

    public ClassificationSchemeApplication(IClassificationSchemeRepository classificationSchemeRepository, IClassificationGroupRepository classificationGroupRepository, IClassificationGroupSalariesRepository classificationGroupSalariesRepository, IClassificationRialCoefficientRepository classificationRialCoefficientRepository, IClassificationEmployeeRepository classificationEmployeeRepository)
    {
        _classificationSchemeRepository = classificationSchemeRepository;
        _classificationGroupRepository = classificationGroupRepository;
        _classificationGroupSalariesRepository = classificationGroupSalariesRepository;
        _classificationRialCoefficientRepository = classificationRialCoefficientRepository;
        _classificationEmployeeRepository = classificationEmployeeRepository;
    }

    public Task<ClassificationSchemeListDto> GetClassificationSchemeList(long workshopId)
    {
        return _classificationSchemeRepository.GetClassificationSchemeList(workshopId);
    }

    public async Task<OperationResult> CreateClassificationScheme(CreateClassificationSchemeDto command)
    {
        var op = new OperationResult();


        #region Validation

        if (!command.ExecutionDateFa.TryToGeorgianDateTime(out var executionDateGr))
        {
            return op.Failed("تاریخ اجرا صحیح نمی باشد");
        }
        if (!command.IncludingDateFa.TryToGeorgianDateTime(out var includingDateGr))
        {
            return op.Failed("تاریخ شمول صحیح نمی باشد");
        }



        #endregion
        //ایجاد طرح
        var create = new Company.Domain.ClassificationSchemeAgg.ClassificationScheme(includingDateGr, executionDateGr,
            command.DesignerFullName, command.DesignerPhone, command.WorkshopId, command.TypeOfCoefficient);
        _classificationSchemeRepository.Create(create);
        await _classificationSchemeRepository.SaveChangesAsync();
        //ایجاد گروه های طرح
        var groups = new List<ClassificationGroup>()
        {
            new ClassificationGroup("1",command.WorkshopId,create.id),
            new ClassificationGroup("2",command.WorkshopId,create.id),
            new ClassificationGroup("3",command.WorkshopId,create.id),
            new ClassificationGroup("4",command.WorkshopId,create.id),
            new ClassificationGroup("5",command.WorkshopId,create.id),
            new ClassificationGroup("6",command.WorkshopId,create.id),
            new ClassificationGroup("7",command.WorkshopId,create.id),
            new ClassificationGroup("8",command.WorkshopId,create.id),
            new ClassificationGroup("9",command.WorkshopId,create.id),
            new ClassificationGroup("10",command.WorkshopId,create.id),
            new ClassificationGroup("11",command.WorkshopId,create.id),
            new ClassificationGroup("12",command.WorkshopId,create.id),
            new ClassificationGroup("13",command.WorkshopId,create.id),
            new ClassificationGroup("14",command.WorkshopId,create.id),
            new ClassificationGroup("15",command.WorkshopId,create.id),
            new ClassificationGroup("16",command.WorkshopId,create.id),
            new ClassificationGroup("17",command.WorkshopId,create.id),
            new ClassificationGroup("18",command.WorkshopId,create.id),
            new ClassificationGroup("19",command.WorkshopId,create.id),
            new ClassificationGroup("20",command.WorkshopId,create.id),
        };

        await _classificationGroupRepository.CreateGroups(groups);



        return op.Succcedded();
    }

    public async Task<EditClassificationSchemeDto> GetClassificationScheme(long id)
    {
        return await _classificationSchemeRepository.GetClassificationScheme(id);
    }


    public Task<EditClassificationScheme> GetClassificationSchemeToCompute(long id)
    {
        return _classificationSchemeRepository.GetClassificationSchemeToCompute(id);
    }

    public async Task<OperationResult> EditClassificationScheme(EditClassificationSchemeDto command)
    {
        var op = new OperationResult();


        #region Validation

        if (!command.ExecutionDateFa.TryToGeorgianDateTime(out var executionDateGr))
        {
            return op.Failed("تاریخ اجرا صحیح نمی باشد");
        }
        if (!command.IncludingDateFa.TryToGeorgianDateTime(out var includingDateGr))
        {
            return op.Failed("تاریخ شمول صحیح نمی باشد");
        }
        var scheme = _classificationSchemeRepository.Get(command.Id);
        if (scheme == null)
            return op.Failed("رکورد مورد نظر وجود ندارد");
        #endregion


        scheme.Edit(includingDateGr, executionDateGr, command.DesignerFullName, command.DesignerPhone, command.TypeOfCoefficient);
        await _classificationSchemeRepository.SaveChangesAsync();
        return op.Succcedded();
    }

    public async Task<List<ClassificationGroupAndJobModel>> GetGroupAndJobs(long schemeId)
    {
        return await _classificationGroupRepository.GetGroupAndJobs(schemeId);
    }

    public async Task<List<GetGroupAndJobSchemeListDto>> GetGroupList(long schemeId)
    {
        return await _classificationGroupRepository.GetGroupList(schemeId);
    }

    public async Task<List<EditClassificationGroupJob>> GetGroupJobs(long groupId)
    {
        return await _classificationGroupRepository.GetGroupJobs(groupId);
    }



    public async Task<bool> CheckEmployeeHasThisJob(long id, long groupId)
    {
        return await _classificationGroupRepository.CheckEmployeeHasThisJob(id, groupId);
    }

    public async Task<bool> CreateGroupJobs(List<CreateClassificationGroupJob> createClassificationGroupJob, List<long> deleteJobList)
    {
        var newJoblist = new List<ClassificationGroupJob>();
        if (createClassificationGroupJob.Count > 0)
        {
            foreach (var item in createClassificationGroupJob)
            {
                var newJob = new ClassificationGroupJob(item.JobId, item.JobName, item.JobCode, item.ClassificationGroupId,
                    item.GroupNo);
                newJoblist.Add(newJob);
            }

        }



        return await _classificationGroupRepository.CreateJobs(newJoblist, deleteJobList);
    }

    public async Task<SalaryAndRialCoefficientTab> GetSalariesTabData(long schemeId)
    {
        return await _classificationGroupSalariesRepository.GetSalariesTabData(schemeId);
    }

    public async Task<SalaryAndRialCoefficientModel> GetGroupToCreateSalariesModal(long schemeId)
    {
        return await _classificationGroupRepository.GetGroupToCreateSalariesModal(schemeId);
    }



    public async Task<OperationResult> CreateGroupSalaryAndCoefficient(SalaryAndRialCoefficientModel command)
    {
        var op = new OperationResult();
        #region Validation

        if (string.IsNullOrWhiteSpace(command.StartDateFa) || string.IsNullOrWhiteSpace(command.StartDateFa))
            return op.Failed("تاریخ شروع و پایان نمی توانند خالی باشند");


        if (command.TypeOfCoefficient == TypeOfCoefficient.RialCoefficient && command.RialCoefficient == 0)
            return op.Failed("ضریب ریالی وارد نشده است");


        if (command.SalariesAndCoefficientList.Any(x => string.IsNullOrWhiteSpace(x.GroupSalaryStr) || x.GroupSalaryStr == "0"))
            return op.Failed("دستمزد تمامی گروه ها می بایست تعیین شود");


        if (!command.StartDateFa.TryToGeorgianDateTime(out var startDate))
        {
            return op.Failed("تاریخ شروع وارد شده صحیح نمی باشد");
        }
        if (!command.EndDateFa.TryToGeorgianDateTime(out var endDate))
        {
            return op.Failed("تاریخ پایان وارد شده صحیح نمی باشد");
        }

        if (_classificationGroupSalariesRepository.Exists(x => x.StartDate <= endDate && x.EndDate >= startDate && x.SchemeId == command.SchemeId))
        {
            return op.Failed("بازه تاریخ وارد شده با داده های ذخیره شده قبل تداخل دارد");

        }

        var year = Convert.ToInt32(command.StartDateFa.Substring(0, 4));

        var endDateYear = Convert.ToInt32(command.EndDateFa.Substring(0, 4));
        if (year != endDateYear)
            return op.Failed("سال تاریخ شروع از سال تاریخ پایان متفاوت است");
        #endregion



        var createSalaries = new List<ClassificationGroupSalary>();

        foreach (var item in command.SalariesAndCoefficientList)
        {
            item.GroupSalary = item.GroupSalaryStr.MoneyToDouble();
            var create = new ClassificationGroupSalary(item.ClassificationGroupId, item.GroupNo, item.GroupSalary, startDate, endDate, year, command.SchemeId);
            createSalaries.Add(create);
        }

        await _classificationGroupSalariesRepository.CreateSalaries(createSalaries);

        if (command.TypeOfCoefficient == TypeOfCoefficient.RialCoefficient)
        {
            try
            {
                command.RialCoefficient = command.RialCoefficient;

                await _classificationRialCoefficientRepository.CreateAsync(new ClassificationRialCoefficient(command.SchemeId,
                    command.RialCoefficient, startDate, endDate, year));
                await _classificationRialCoefficientRepository.SaveChangesAsync();
            }
            catch (Exception e)
            {
                return op.Failed("فرمت مبلغ ضریب ریالی اشتباه است");
            }
        }

        op.SendId = command.SchemeId;
        return op.Succcedded();
    }

    public async Task<SalaryAndRialCoefficientModel> GetEditSalariesData(long schemeId, string startDate, string endDate)
    {
        return await _classificationGroupSalariesRepository.GetEditSalariesData(schemeId, startDate, endDate);
    }

    public async Task<OperationResult> EditGroupSalaryAndCoefficient(SalaryAndRialCoefficientModel command)
    {
        var op = new OperationResult();
        #region Validation

        if (string.IsNullOrWhiteSpace(command.StartDateFa) || string.IsNullOrWhiteSpace(command.StartDateFa))
            return op.Failed("تاریخ شروع و پایان نمی توانند خالی باشند");


        if (command.TypeOfCoefficient == TypeOfCoefficient.RialCoefficient && command.RialCoefficient == 0)
            return op.Failed("ضریب ریالی وارد نشده است");


        if (command.SalariesAndCoefficientList.Any(x => string.IsNullOrWhiteSpace(x.GroupSalaryStr) || x.GroupSalaryStr == "0"))
            return op.Failed("دستمزد تمامی گروه ها می بایست تعیین شود");


        if (!command.StartDateFa.TryToGeorgianDateTime(out var startDate))
        {
            return op.Failed("تاریخ شروع وارد شده صحیح نمی باشد");
        }
        if (!command.EndDateFa.TryToGeorgianDateTime(out var endDate))
        {
            return op.Failed("تاریخ پایان وارد شده صحیح نمی باشد");
        }

        var salariesId = command.SalariesAndCoefficientList.Select(x => x.Id).ToList();
        if (_classificationGroupSalariesRepository.Exists(x => x.StartDate <= endDate && x.EndDate >= startDate && x.SchemeId == command.SchemeId && !salariesId.Contains(x.id)))
        {
            return op.Failed("بازه تاریخ وارد شده با داده های ذخیره شده قبل تداخل دارد");

        }

        var year = Convert.ToInt32(command.StartDateFa.Substring(0, 4));

        var endDateYear = Convert.ToInt32(command.EndDateFa.Substring(0, 4));
        if (year != endDateYear)
            return op.Failed("سال تاریخ شروع از سال تاریخ پایان متفاوت است");
        #endregion



        foreach (var item in command.SalariesAndCoefficientList)
        {
            var editSalary = _classificationGroupSalariesRepository.Get(item.Id);

            item.GroupSalary = item.GroupSalaryStr.MoneyToDouble();

            editSalary.Edit(item.GroupSalary, startDate, endDate, year);
            await _classificationGroupSalariesRepository.SaveChangesAsync();

        }

        if (command.TypeOfCoefficient == TypeOfCoefficient.RialCoefficient)
        {
            var editRialCoefficient = _classificationRialCoefficientRepository.Get(command.CoefficientId);
            editRialCoefficient.Edit(command.RialCoefficient, startDate, endDate, year);
            await _classificationRialCoefficientRepository.SaveChangesAsync();

        }

        return op.Succcedded();
    }



    public async Task<EmployeeInfoTab> GetEmployeeDataTab(EmployeeInfoTab command)
    {
        var employeeInfoTab = new EmployeeInfoTab();
        var employeeInfoList = _classificationEmployeeRepository.GetEmployeeListData(command.SchemeId).GetAwaiter().GetResult();
        if (employeeInfoList.Any())
        {
            if (!string.IsNullOrWhiteSpace(command.FullName))
                employeeInfoList = employeeInfoList.Where(x => x.FullName.Contains(command.FullName)).ToList();

            employeeInfoTab.EmployeeInfoList = employeeInfoList;
            employeeInfoTab.FullName = command.FullName;


        }


        return employeeInfoTab;
    }

    public async Task<List<ClassificationGroupList>> GetGroups(long schemeId)
    {
        return await _classificationGroupRepository.GetGroups(schemeId);
    }


    public async Task<OperationResult> AddEmployeeToGroup(AddEmployeeToGroup command)
    {
        var op = new OperationResult();
        #region Validation

        if (command.GroupId == 0)
            return op.Failed("لطفا گروه را انتخاب کنید");

        if (command.JobId == 0)
            return op.Failed("لطفا سمت را انتخاب کنید");

        #endregion


        var scheme = _classificationSchemeRepository.GetClassificationSchemeToCompute(command.SchemeId).GetAwaiter().GetResult();


        var create = new ClassificationEmployee(scheme.WorkshopId, command.EmployeeId, command.SchemeId,
            command.GroupId, command.JobId, scheme.ExecutionDateGr);
        await _classificationEmployeeRepository.CreateAsync(create);
        await _classificationEmployeeRepository.SaveChangesAsync();

        return op.Succcedded();
    }


    public async Task<OperationResult> EditGroupMember(AddEmployeeToGroup command)
    {
        var op = new OperationResult();
        #region Validation

        if (command.GroupId == 0)
            return op.Failed("لطفا گروه را انتخاب کنید");

        if (command.JobId == 0)
            return op.Failed("لطفا سمت را انتخاب کنید");

        #endregion


        var editGroup = _classificationEmployeeRepository.Get(command.Id);
        editGroup.Edit(command.GroupId, command.JobId);
        await _classificationEmployeeRepository.SaveChangesAsync();

        return op.Succcedded();
    }

    public async Task<OperationResult> TransferEmployeeToNewGroup(List<EditEmployeeGroupList> command)
    {
        var op = new OperationResult();
        if (command.Count < 1)
            return op.Failed("هیچ انتقالی ایجاد نشده است");
        var oldGroupsMemberize = await _classificationEmployeeRepository.GetEmployeeMemberizeData(command[0].EmployeeId);
        var scheme = await _classificationSchemeRepository.GetClassificationSchemeToCompute(oldGroupsMemberize[0].SchemeId);
        var newStartDateList = new List<DateTime>();
        foreach (var item in command)
        {
            #region Validation

            if (item.ClassificationGroupId == 0)
                return op.Failed("لطفا گروه را انتخاب کنید");

            if (item.ClassificationGroupJobId == 0)
                return op.Failed("لطفا سمت را انتخاب کنید");

            if (!item.StartGroupDateFa.TryToGeorgianDateTime(out var startDate))
            {
                string startDateFaild = "تاریخ شروع" + " " + item.StartGroupDateFa + " " + "صحیح نمیباشد";
                return op.Failed(startDateFaild);
            }

            if (item.StartGroupDateFa.Substring(8, 2) != "01")
                return op.Failed("تاریخ شروع فقط می تواند یکم هر ماه باشد");

            if (newStartDateList.Any(x => x == startDate))
                return op.Failed($"تاریخ انتقال {item.StartGroupDateFa} با تاریخ های قبل تداخل دارد");
            newStartDateList.Add(startDate);

            if (oldGroupsMemberize.Any(x => x.StartGroupDate == startDate))
                return op.Failed($"تاریخ انتقال {item.StartGroupDateFa} با تاریخ های قبل تداخل دارد");
            if (startDate < scheme.ExecutionDateGr)
                return op.Failed($"تاریخ انتقال  {item.StartGroupDateFa}  کوچکتر از تاریخ شروع طرح : {scheme.ExecutionDateFa}  است");

            #endregion
        }

        var lastRecord = oldGroupsMemberize.FirstOrDefault(x => x.EndGroupDate == null);

        if (lastRecord != null)
        {
            var edit = _classificationEmployeeRepository.Get(lastRecord.Id);
            var firstNewRcord = newStartDateList.MinBy(x => x);

            edit.EditMultipleGroupMember(lastRecord.ClassificationGroupId, lastRecord.ClassificationGroupJobId, lastRecord.StartGroupDate.Value);

        }



        newStartDateList = newStartDateList.OrderByDescending(x => x).ToList();
        var lastNewRecord = newStartDateList.MaxBy(x => x);


        var c = command.FirstOrDefault(x => x.StartGroupDateFa == lastNewRecord.ToFarsi());
        var create = new ClassificationEmployee(scheme.WorkshopId, c.EmployeeId, c.SchemeId,
            c.ClassificationGroupId, c.ClassificationGroupJobId, lastNewRecord.Date);
        await _classificationEmployeeRepository.CreateAsync(create);
        newStartDateList.Remove(lastNewRecord);
        var createList = new List<ClassificationEmployee>();
        foreach (var item in newStartDateList)
        {
            var commandEdit = command.FirstOrDefault(x => x.StartGroupDateFa == item.ToFarsi());
            var createCommand = new ClassificationEmployee(scheme.WorkshopId, commandEdit.EmployeeId, commandEdit.SchemeId,
                commandEdit.ClassificationGroupId, commandEdit.ClassificationGroupJobId, item);
            createList.Add(createCommand);
            lastNewRecord = item;
        }


        if (createList.Any())
        {
            createList = createList.OrderBy(x => x.StartGroupDate).ToList();
            await _classificationEmployeeRepository.CreateTransferRange(createList);
        }


        await _classificationEmployeeRepository.SaveChangesAsync();

        return op.Succcedded();



    }
    public async Task<OperationResult> EditMultipleGroupMember(List<EditEmployeeGroupList> command)
    {
        var op = new OperationResult();
        var zeroItem = command.First(x => x.Id == 0);
        var oldGroupsMemberize = await _classificationEmployeeRepository.GetEmployeeMemberizeData(zeroItem.EmployeeId);
        var scheme = await _classificationSchemeRepository.GetClassificationSchemeToCompute(zeroItem.SchemeId);
        command = command.Where(x => x.Id != 0).ToList();
        var newStartDateList = new List<DateTime>();
        foreach (var item in command)
        {
            #region Validation

            if (item.ClassificationGroupId == 0)
                return op.Failed("لطفا گروه را انتخاب کنید");

            if (item.ClassificationGroupJobId == 0)
                return op.Failed("لطفا سمت را انتخاب کنید");

            if (!item.StartGroupDateFa.TryToGeorgianDateTime(out var startDate))
            {
                string startDateFaild = "تاریخ شروع" + " " + item.StartGroupDateFa + " " + "صحیح نمیباشد";
                return op.Failed(startDateFaild);
            }
            if (item.StartGroupDateFa.Substring(8, 2) != "01")
                return op.Failed("تاریخ شروع فقط می تواند یکم هر ماه باشد");

            if (oldGroupsMemberize.Any(x => x.StartGroupDate == startDate && x.Id != item.Id))
                return op.Failed($"تاریخ {item.StartGroupDateFa} با تاریخ های قبل یا بعد از خود تداخل دارد");

            if (startDate < scheme.ExecutionDateGr)
                return op.Failed($"تاریخ انتقال  {item.StartGroupDateFa}  کوچکتر از تاریخ شروع طرح : {scheme.ExecutionDateFa}  است");
            newStartDateList.Add(startDate);
            #endregion
        }

        foreach (var item in command)
        {
            var edit = _classificationEmployeeRepository.Get(item.Id);


            edit.EditMultipleGroupMember(item.ClassificationGroupId, item.ClassificationGroupJobId, item.StartGroupDateFa.ToGeorgianDateTime());




        }

        var removeItemIdList = command.Select(x => x.Id).ToList();
        var toBeRemove = removeItemIdList.Any() ? oldGroupsMemberize.Where(x => !removeItemIdList.Contains(x.Id)).Select(x => x.Id).ToList() : oldGroupsMemberize.Select(x => x.Id).ToList();
        if (toBeRemove.Any())
        {
            var getRemoveList = await _classificationEmployeeRepository.GetListByIdList(toBeRemove);

            await _classificationEmployeeRepository.RemoveRangeByEdit(getRemoveList);
        }

        await _classificationEmployeeRepository.SaveChangesAsync();
        return op.Succcedded();
    }


    /// <summary>
    ///  دریافت اطلاعات عضویتی پرسنل در گروه
    /// </summary>
    /// <param name="employeeId"></param>
    /// <returns></returns>
    public async Task<EditEmployeeGroup> GetEmployeeMemberizeData(long employeeId)
    {
        var result = new EditEmployeeGroup();
        var res = await _classificationEmployeeRepository.GetEmployeeMemberizeData(employeeId);

        if (res.Any())
        {
            result.HasMultipleGroup = res.Count > 1;
            result.EditEmployeeGroupLists = res;
        }

        return result;


    }

    public async Task<BaseYearDataViewModel> BaseYearComputeOneGroup(DateTime schemeStart, DateTime? schemeEnd, DateTime contractStart, DateTime contractEnd,
        string groupNo, long employeeId, long workshopId)
    {
        return await _classificationSchemeRepository.BaseYearComputeOneGroup(schemeStart, schemeEnd, contractStart,
            contractEnd, groupNo, employeeId, workshopId);
    }

    public async Task<OperationResult<CheckStatusToDeleteScheme>> CheckToDeleteScheme(long id)
    {
        var op = new OperationResult<CheckStatusToDeleteScheme>();
        var scheme = _classificationSchemeRepository.Get(id);
        if (scheme != null)
        {
            var employeeInfoList = await _classificationEmployeeRepository.GetEmployeeListData(id);
            var anyHasGroup = employeeInfoList.Any(x => x.HasGroup);
            if (employeeInfoList.Any() && anyHasGroup)
            {


                string message = "برای این طرح پرسنل افزوده شده است، آیا از حذف طرح اطمینان دارید";


                return op.Succcedded(new CheckStatusToDeleteScheme()
                { DeleteSchemeStatus = DeleteSchemeStatus.ConfirmationNeeded, Message = message });

            }
            else
            {

                var message = "مجاز برای حذف";
                return op.Succcedded(new CheckStatusToDeleteScheme()
                { DeleteSchemeStatus = DeleteSchemeStatus.Valid, Message = message });
            }

        }

        return op.Failed("یافت نشد", new CheckStatusToDeleteScheme() { DeleteSchemeStatus = DeleteSchemeStatus.NotValid });


    }

    public async Task<OperationResult> DeleteScheme(long id)
    {
        var op = new OperationResult();
        var scheme = _classificationSchemeRepository.Get(id);

        if (scheme != null)
        {
            await _classificationSchemeRepository.DeleteClassificationScheme(id);
            return op.Succcedded();
        }

        return op.Failed("یافت نشد");
    }


    public async Task<AddOrEditJobInGroupDto> GetCreateOrEditJobsData(long groupId)
    {
        return await _classificationGroupRepository.GetCreateOrEditJobsData(groupId);
    }

    public async Task<OperationResult> CheckIfEmployeeHasThisJob(long jobId, long groupId)
    {
        var op = new OperationResult();
        var checkExistAny = await _classificationGroupRepository.CheckIfEmployeeHasThisJob(jobId, groupId);
        if (checkExistAny)
            return op.Failed("این شغل قبلا به پرسنلی از این گروه داده شده و نمیتوانید آن را حذف کنید");

        return op.Succcedded(-1, "حذف با موفقیت انجام شد");
    }

    public async Task<OperationResult> SaveJobsToGroup(AddOrEditJobInGroupDto command)
    {
        var op = new OperationResult();
        var res= await _classificationGroupRepository.SaveJobsToGroup(command);
        if (!res)
            return op.Failed("خطا در انجام عملیات");

        return op.Succcedded();
    }
}