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

namespace CompanyManagment.EFCore.Repository;

public class ClassificationGroupRepository : RepositoryBase<long, ClassificationGroup>, IClassificationGroupRepository
{
    private readonly CompanyContext _context;
    public ClassificationGroupRepository(CompanyContext context) : base(context)
    {
        _context = context;
    }

    /// <summary>
    /// دریافت گروه های طرح
    /// </summary>
    /// <param name="schemeId"></param>
    /// <returns></returns>
    public async Task<List<ClassificationGroupList>> GetGroups(long schemeId)
    {
        return await _context.ClassificationGroups
            .Where(x => x.ClassificationSchemeId == schemeId)
            .Select(x=> new ClassificationGroupList
            {

                GroupId = x.id,
                GroupNo = x.GroupNo,
                GroupNoInt = Convert.ToInt32(x.GroupNo)
                
             }).OrderBy(x=>x.GroupNoInt).ToListAsync();
    }

    /// <summary>
    /// دریافت گروه ها و مشاغلشان برای تب تعیین مشاغل
    /// </summary>
    /// <param name="schemeId"></param>
    /// <returns></returns>
    public async Task<List<ClassificationGroupAndJobModel>> GetGroupAndJobs(long schemeId)
    {
        return await _context.ClassificationGroups.Where(x => x.ClassificationSchemeId == schemeId)
            .Include(x => x.ClassificationGroupJobs).Select(x => new ClassificationGroupAndJobModel
            {
                GroupId = x.id,
                GroupNo = x.GroupNo,
                GroupNoInt = Convert.ToInt32(x.GroupNo),
                WorkshopId = x.WorkshopId,
                ClassificationSchemeId = x.ClassificationSchemeId,
                EditClassificationGroupJob = x.ClassificationGroupJobs.Select(jobs => new EditClassificationGroupJob()
                {
                    Id = jobs.id,
                    JobId = jobs.JobId,
                    JobName = jobs.JobName,
                    JobCode = jobs.JobCode,
                    ClassificationGroupId = jobs.ClassificationGroupId,
                    GroupNo = jobs.GroupNo,

                }).ToList(),

            }).OrderBy(x=>x.GroupNoInt).ToListAsync();
    }



    /// <summary>
    /// دریافت مشاغل گروه توسط آی دی گروه
    /// </summary>
    /// <param name="groupId"></param>
    /// <returns></returns>
    public async Task<List<EditClassificationGroupJob>> GetGroupJobs(long groupId)
    {

        return await _context.ClassificationGroupJobs
            .Where(x => x.ClassificationGroupId == groupId).Select(jobs => new EditClassificationGroupJob()
            {
                Id = jobs.id,
                JobId = jobs.JobId,
                JobName = jobs.JobName,
                JobCode = jobs.JobCode,
                ClassificationGroupId = jobs.ClassificationGroupId,
                GroupNo = jobs.GroupNo,

            }).ToListAsync();

       
    }

    /// <summary>
    /// چک میکند که آی پرسنلی وجود دارد که این شغل به او نسبت داده شده
    /// </summary>
    /// <param name="id"></param>
    /// <param name="groupId"></param>
    /// <returns></returns>
    public async Task<bool> CheckEmployeeHasThisJob(long id, long groupId)
    {
        return await _context.ClassificationEmployees.AnyAsync(x =>
            x.ClassificationGroupJobId == id && x.ClassificationGroupId == groupId);
    }

    /// <summary>
    /// ایجاد مشاغل
    /// </summary>
    /// <param name="createClassificationGroupJob"></param>
    /// <param name="deleteJobList"></param>
    /// <returns></returns>
    public async Task<bool> CreateJobs(List<ClassificationGroupJob> createClassificationGroupJob, List<long> deleteJobList)
    {
        if (createClassificationGroupJob.Count > 0)
        {
            await _context.ClassificationGroupJobs.AddRangeAsync(createClassificationGroupJob);
            await _context.SaveChangesAsync();
        }

        if (deleteJobList.Count > 0)
        {
            var deleteItems = _context.ClassificationGroupJobs.Where(x => deleteJobList.Contains(x.id));
            _context.ClassificationGroupJobs.RemoveRange(deleteItems);
            await _context.SaveChangesAsync();
        }

        

        return true;
    }

    /// <summary>
    /// در یافت اطلاعات گروه برای لود مودال ایجاد دستمزد های
    /// </summary>
    /// <returns></returns>
    public async Task<SalaryAndRialCoefficientModel> GetGroupToCreateSalariesModal(long schemeId)
    {
        var result = new SalaryAndRialCoefficientModel();
        var scheme =await _context.ClassificationSchemes.FirstOrDefaultAsync(x => x.id == schemeId);
        var groups =await _context.ClassificationGroups.Where(x => x.ClassificationSchemeId == schemeId).ToListAsync();

        if (scheme != null)
        {
            result.TypeOfCoefficient = scheme.TypeOfCoefficient;
            result.SchemeId = schemeId;

            result.SalariesAndCoefficientList = groups.Select(x => new EditClassificationGroupSalaryAndRialCoefficient
            {
                ClassificationGroupId = x.id,
                GroupNo = x.GroupNo,

            }).ToList();
        }

        return result;
    }

   

    /// <summary>
    /// ایجاد گروه های بیست گانه
    /// </summary>
    /// <param name="groupList"></param>
    /// <returns></returns>
    public async Task CreateGroups(List<ClassificationGroup> groupList)
    {
       await _context.AddRangeAsync(groupList);
       await _context.SaveChangesAsync();
    }



    #region ForApi



    public async Task<List<GetGroupAndJobSchemeListDto>> GetGroupList(long schemeId)
    {
        return await _context.ClassificationGroups.Where(x => x.ClassificationSchemeId == schemeId)
            .Include(x => x.ClassificationGroupJobs).Select(x => new GetGroupAndJobSchemeListDto
            {
                GroupId = x.id,
                GroupNoInt = Convert.ToInt32(x.GroupNo),
                HasAnyJob = x.ClassificationGroupJobs.Any()

            }).OrderBy(x => x.GroupNoInt).ToListAsync();
    }


    public async Task<AddOrEditJobInGroupDto> GetCreateOrEditJobsData(long groupId)
    {
        var result = await _context.ClassificationGroups.Where(x => x.id == groupId)
            .Include(x => x.ClassificationGroupJobs).FirstOrDefaultAsync();
        if (result == null)
            return new AddOrEditJobInGroupDto();

        return new AddOrEditJobInGroupDto()
        {
            GroupId = result.id,
            GroupNoInt = Convert.ToInt32(result.GroupNo),
            AddJobListDto = result.ClassificationGroupJobs.Select(job => new AddJobListDto
            {
                JobId = job.JobId,
                JobName = $"{job.JobName} - {job.JobCode}"
            }).ToList(),
        };
    }


    /// <summary>
    /// چک میکند که آی پرسنلی وجود دارد که این شغل به او نسبت داده شده
    /// </summary>
    /// <param name="jobId"></param>
    /// <param name="groupId"></param>
    /// <returns></returns>
    public async Task<bool> CheckIfEmployeeHasThisJob(long jobId, long groupId)
    {
        var result = await _context.ClassificationGroups.Where(x => x.id == groupId)
            .Include(x => x.ClassificationGroupJobs).FirstOrDefaultAsync();
        var job = result.ClassificationGroupJobs.FirstOrDefault(x => x.JobId == jobId);
        if (job == null)
            return false;

        var id = job.id;
        return await _context.ClassificationEmployees.AnyAsync(x =>
            x.ClassificationGroupJobId == id && x.ClassificationGroupId == groupId);
    }


    public async Task<bool> SaveJobsToGroup(AddOrEditJobInGroupDto command)
    {
        var newJoblist = new List<ClassificationGroupJob>();
        var alreadyExitjobs = new List<ClassificationGroupJob>();
        var alreadyAdded = await _context.ClassificationGroups.Where(x => x.id == command.GroupId)
            .Include(x => x.ClassificationGroupJobs).FirstOrDefaultAsync();
        if (command.AddJobListDto.Count > 0)
        {
            var addedJobsIds = command.AddJobListDto.Where(x => x.JobId > 0).Select(x => x.JobId).ToList();
            var getJobs = _context.Jobs.Where(x => addedJobsIds.Contains(x.id));

            foreach (var item in getJobs)
            {

                var newJob = new ClassificationGroupJob(item.id, item.JobName, item.JobCode, command.GroupId,
                    $"{command.GroupNoInt}");

                if (alreadyAdded.ClassificationGroupJobs.Any(x => x.JobId == item.id))
                {
                    alreadyExitjobs.Add(newJob);
                }
                else
                {
                    newJoblist.Add(newJob);
                }
               
            }
        }
      
       
        if (alreadyAdded.ClassificationGroupJobs.Count == 0)
        {
       
            if (command.AddJobListDto.Count > 0)
            {

                await _context.ClassificationGroupJobs.AddRangeAsync(newJoblist);
                await _context.SaveChangesAsync();
            }
        }
        else
        {

      
            
            var alreadyExitJobsIds = alreadyExitjobs.Select(x => x.JobId).ToList();
           
                var toBeRemove = alreadyAdded.ClassificationGroupJobs.Where(x => !alreadyExitJobsIds.Contains(x.JobId))
                    .ToList();
                if (toBeRemove.Count > 0)
                {
                    _context.ClassificationGroupJobs.RemoveRange(toBeRemove);
                    await _context.SaveChangesAsync();
                }
           

            if (newJoblist.Count > 0)
            {
                await _context.ClassificationGroupJobs.AddRangeAsync(newJoblist);
                await _context.SaveChangesAsync();
            }

        }

        return true;
    }
    #endregion
}