using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using _0_Framework.Application;
using _0_Framework.InfraStructure;
using Company.Domain.RollCallEmployeeAgg;
using Company.Domain.RollCallEmployeeStatusAgg;
using Company.Domain.RollCallServiceAgg;
using CompanyManagment.App.Contracts.LeftWorkTemp;
using CompanyManagment.App.Contracts.RollCallEmployee;
using CompanyManagment.App.Contracts.RollCallEmployeeStatus;
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory.Database;

namespace CompanyManagment.EFCore.Repository;

public class RollCallEmployeeRepository : RepositoryBase<long, RollCallEmployee>, IRollCallEmployeeRepository
{
    private readonly CompanyContext _context;
    private readonly IPasswordHasher _passwordHasher;
    private readonly IWebHostEnvironment _webHostEnvironment;

    private IRollCallServiceRepository _rollCallServiceRepository;

    private IRollCallEmployeeStatusRepository _employeeRollCallStatusRepository;
    // private IRollCallEmployeeRepository _rollCallEmployeeRepositoryImplementation;

    public RollCallEmployeeRepository(CompanyContext context, IPasswordHasher passwordHasher,
        IWebHostEnvironment webHostEnvironment, IRollCallServiceRepository rollCallServiceRepository, IRollCallEmployeeStatusRepository employeeRollCallStatusRepository) : base(context)
    {
        _context = context;
        _passwordHasher = passwordHasher;
        _webHostEnvironment = webHostEnvironment;
        _rollCallServiceRepository = rollCallServiceRepository;
        _employeeRollCallStatusRepository = employeeRollCallStatusRepository;
    }


    public bool HasRollCallRecord(long employeeId, long workshopId, DateTime contractStart, DateTime contractEnd)
    {
        //موقت
        // دادمهرگستر 11 *
        //585 کاشی گالری سرامیس (بابک ابراهیمی ) 
        //آموزشگاه ملل 604  *
        //کاریابی ملل 605 *
        //368 پیتزا امیر آماده سازی
        //367 پیتزا امیر رستوران
        //286 مرکز توان بخشی رسالت *
        //610 بیمارستان پارس - رازقی طعام
        DateTime start1404 = new DateTime(2025, 03, 21);
        bool skipRollCallByWorkshopId = false;
        if (contractStart < start1404)
        {
            skipRollCallByWorkshopId = workshopId is 11 or 585 or 604 or 605 or 368 or 367 or 286;
        }
        else
        {
            skipRollCallByWorkshopId = workshopId is 368 or 610;
        }




        //#if DEBUG
        //            skipRollCallByWorkshopId = workshopId is 11 or 585 or 604 or 605 or 368 or 367;
        //#endif
        if (skipRollCallByWorkshopId)
            return false;


        // 42550 مصطفی مقدس نژاد فومنی
        bool skipRollCallByEmployeeId = employeeId is 42550;
        if (skipRollCallByEmployeeId)
            return false;

        //9211 محسا تازه
        if (employeeId == 9211 && contractStart >= start1404)
            return false;

        var service = _rollCallServiceRepository.GetAllServiceByWorkshopId(workshopId);

        //اگر سرویس حضور غیاب نداشت
        if (!service.Any(x => x.StartService.Date <= contractStart.Date && x.EndService.Date >= contractEnd.Date))
            return false;
        //var rollCallEmployee = GetByEmployeeIdAndWorkshopId(employeeId, workshopId);

        //if (rollCallEmployee == null)
        //    return false;
        var rollCallEmployee = _context.RollCallEmployees.Include(xs => xs.EmployeesStatus)
            .FirstOrDefault(x => x.EmployeeId == employeeId && x.WorkshopId == workshopId);
        //اگر تنظیمات حضور غیاب نداشت  
        if (rollCallEmployee == null)
            return false;
        
        //اگر استاتوس نداشت
        if (!rollCallEmployee.EmployeesStatus.Any())
            return false;

        var leftWork =
            _context.LeftWorkList.FirstOrDefault(x =>
                x.StartWorkDate <= contractEnd.Date && x.LeftWorkDate > contractStart);
        if (leftWork == null)
            return false;

        var status = rollCallEmployee.EmployeesStatus.FirstOrDefault(s => 
            (s.StartDate <= contractStart.Date && s.EndDate.Date >= contractEnd.Date));
        //اگر استاتوس کامل پوشش داد
        if (status != null)
            return true;


        status = rollCallEmployee.EmployeesStatus.FirstOrDefault(s =>
            (s.StartDate.Date <= contractStart.Date && s.EndDate.Date > contractStart.Date &&
             s.EndDate.Date < contractEnd.Date));
        //اگر قبل از پایان فیس استاتوس قطع شده ولی ترک کار داره
        if (status != null && leftWork.HasLeft)
            return true;


        return false;
    }
    public List<RollCallEmployeeViewModel> GetByWorkshopId(long workshopId)
    {
        var query = _context.RollCallEmployees.Select(x => new RollCallEmployeeViewModel()
        {
            Id = x.id,
            EmployeeId = x.EmployeeId,
            WorkshopId = x.WorkshopId,
            EmployeeFullName = x.EmployeeFullName,
            IsActiveString = x.IsActiveString,
            HasUploadedImage = x.HasUploadedImage
        }).Where(x => x.WorkshopId == workshopId);

        return query.ToList();
    }



    public EditRollCallEmployee GetDetails(long id)
    {
        return _context.RollCallEmployees.Select(x => new EditRollCallEmployee()
        {
            Id = x.id,
            WorkshopId = x.WorkshopId,
            EmployeeId = x.EmployeeId,
            EmployeeFullName = x.EmployeeFullName,
            IsActiveString = x.IsActiveString,
            HasUploadedImage = x.HasUploadedImage
        }).FirstOrDefault(x => x.Id == id);
    }

    public RollCallEmployeeViewModel GetByEmployeeIdAndWorkshopId(long employeeId, long workshopId)
    {
        return _context.RollCallEmployees.Where(x => x.EmployeeId == employeeId && x.WorkshopId == workshopId).Select(
            x => new RollCallEmployeeViewModel()
            {
                Id = x.id,
                EmployeeId = x.EmployeeId,
                WorkshopId = x.WorkshopId,
                EmployeeFName = x.FName,
                EmployeeLName = x.LName,
                EmployeeFullName = x.EmployeeFullName,
                IsActiveString = x.IsActiveString,
                HasUploadedImage = x.HasUploadedImage,
                Statuses = x.EmployeesStatus.Select(x => new RollCallEmployeeStatusViewModel()
                {
                    StartDateGr = x.StartDate,
                    EndDateGr = x.EndDate
                })
            }).FirstOrDefault();
    }

    public List<RollCallEmployeeViewModel> GetPersonnelRollCallListPaginate(RollCallEmployeeSearchModel command)
    {
        var dateNow = DateTime.Now;
        var employeeQuery = _context.Employees.IgnoreQueryFilters().AsQueryable();

        //if (!string.IsNullOrWhiteSpace(command.Name))
        //{
        //    var rollCallNames = _context.RollCallEmployees.Where(x => command.WorkshopId == x.WorkshopId &&
        //                                                              x.EmployeeFullName.Contains(command.Name)).Select(
        //        x => new
        //        {
        //            x.EmployeeId,
        //            x.EmployeeFullName
        //        });

        //    employeeQuery = employeeQuery.Where(x => rollCallNames.Any(y => y.EmployeeId == x.id));
        //}

        var rawQuery = employeeQuery.Include(x => x.LeftWorks).Include(x => x.LeftWorkInsurances)
            .GroupJoin(_context.LeftWorkTemps.Where(x => x.WorkshopId == command.WorkshopId),
                employee => employee.id,
                leftWorkTemp => leftWorkTemp.EmployeeId,
                ((employee, temp) => new { employee, temp }))
            .SelectMany(x => x.temp.DefaultIfEmpty(),
                (x, temp) => new { x.employee, temp })
            .Where(x => x.employee.LeftWorks.Any(y =>
                            y.WorkshopId == command.WorkshopId && y.StartWorkDate <= dateNow &&
                            y.LeftWorkDate > dateNow || (y.WorkshopId == command.WorkshopId && y.StartWorkDate > dateNow)) ||
                        x.temp != null).OrderByDescending(x => x.employee.id)
            .Select(x => new
            {
                Id = x.employee.id,
                FullName = x.employee.FName + " " + x.employee.LName,
                x.employee.NationalCode,
                workshopTemp = x.temp

            }).AsSplitQuery();



        var rollCallEmployees = _context.RollCallEmployees.Where(x => x.WorkshopId == command.WorkshopId);

        var employeeClient = _context.EmployeeClientTemps.Where(x => x.WorkshopId == command.WorkshopId);


        var joinedQuery = from employee in rawQuery
                          join rollCallEmployee in rollCallEmployees
                              on employee.Id equals rollCallEmployee.EmployeeId into grp
                          from joinedRollCall in grp.DefaultIfEmpty()
                          join employeeClientT in employeeClient on employee.Id equals employeeClientT.EmployeeId into employeeCT
                          from clientTemp in employeeCT.DefaultIfEmpty()
                          select new RollCallEmployeeViewModel()
                          {
                              WorkshopId = command.WorkshopId,
                              EmployeeId = employee.Id,
                              Id = joinedRollCall == null ? 0 : joinedRollCall.id,
                              EmployeeFullName = employee.FullName,
                              NationalCode = employee.NationalCode,
                              IsActiveString =
                                  joinedRollCall.EmployeesStatus.Any(y =>
                                      y.StartDate.Date <= dateNow.Date && y.EndDate.Date > dateNow.Date)
                                      ? "true"
                                      : "false",
                              HasUploadedImage = joinedRollCall == null ? "false" : joinedRollCall.HasUploadedImage,
                              CreatedByClient = clientTemp != null || (employee.workshopTemp != null && employee.workshopTemp.LeftWorkType == LeftWorkTempType.StartWork),
                              RollCallEmployeeName = joinedRollCall == null ? null : joinedRollCall.EmployeeFullName,
                              HasChangedName = joinedRollCall != null && joinedRollCall.HasChangedName
                          };








        if (!string.IsNullOrWhiteSpace(command.Name))
        {
            joinedQuery = joinedQuery.Where(x => x.EmployeeFullName.Contains(command.Name));
        }
        var firstlist = joinedQuery.AsSplitQuery();



        var list = firstlist.OrderByDescending(x => x.CreatedByClient).ThenByDescending(x => x.IsActiveString == "true" ? 0 : 1)
            .ThenByDescending(x => x.HasUploadedImage == "true" ? 1 : 0)
            .Skip(command.PageIndex).Take(30).ToList();
        var watch = new Stopwatch();
        watch.Start();
        list.ForEach(x =>
        {

            x.EmployeeSlug = _passwordHasher.SlugHasher(x.EmployeeId);
            if (x.HasUploadedImage == "true")
            {
                try
                {
                    var path = Path.Combine(_webHostEnvironment.ContentRootPath, "Faces", command.WorkshopId.ToString(),
                        x.EmployeeId.ToString());
                    var thumbnailPath = Path.Combine(path, "Thumbnail.jpg");
                    if (System.IO.File.Exists(thumbnailPath))
                    {
                        var bytes = System.IO.File.ReadAllBytes(thumbnailPath);
                        var image = Convert.ToBase64String(bytes);
                        x.ImagePath = image;

                    }
                    else if (System.IO.File.Exists(Path.Combine(path, "1.jpg")))
                    {

                        var thumbnail = Tools.ResizeImage(Path.Combine(path, "1.jpg"), 150, 150);
                        System.IO.File.WriteAllBytes(thumbnailPath, Convert.FromBase64String(thumbnail));
                        x.ImagePath = thumbnail;
                    }
                }
                catch
                {
                    // ignored
                }
            }
        });


        Console.WriteLine(watch.Elapsed);
        return list;
    }

    public RollCallEmployee GetWithRollCallStatus(long id)
    {
        return _context.RollCallEmployees.Include(x => x.EmployeesStatus)
            .FirstOrDefault(x => x.id == id);
    }

    public int activedPerson(long workshopId)
    {
        return _context.RollCallEmployees.Count(x =>
            x.WorkshopId == workshopId && x.IsActiveString == "true" && x.HasUploadedImage == "true");
    }

    #region Pooya

    public List<RollCallEmployeeViewModel> GetRollCallEmployeesByWorkshopId(long workshopId)
    {
        var dateNow = DateTime.Now.Date;
        var personnelCodes = _context.PersonnelCodeSet.Where(x => x.WorkshopId == workshopId);
        return _context.RollCallEmployees.Include(x => x.EmployeesStatus).Where(x => x.WorkshopId == workshopId &&
                personnelCodes.Any(y => y.EmployeeId == x.EmployeeId))
            .Select(x =>
                new RollCallEmployeeViewModel()
                {
                    EmployeeId = x.EmployeeId,
                    EmployeeFullName = x.EmployeeFullName,
                    Id = x.id,
                    WorkshopId = x.WorkshopId,
                    IsActiveString = x.EmployeesStatus.Any(y => y.StartDate.Date <= dateNow && y.EndDate.Date > dateNow) ? "true" : "false",
                    HasUploadedImage = x.HasUploadedImage,
                    Statuses = x.EmployeesStatus.Select(y => new RollCallEmployeeStatusViewModel()
                    {
                        StartDateGr = y.StartDate,
                        EndDateGr = y.EndDate,
                        Id = y.id
                    })

                }).ToList();

    }

    public List<RollCallEmployeeViewModel> GetByEmployeeIdWithStatuses(long employeeId)
    {
        return _context.RollCallEmployees.Include(x => x.EmployeesStatus)
            .Where(x => x.EmployeeId == employeeId).Select(x =>
                new RollCallEmployeeViewModel()
                {
                    EmployeeId = x.EmployeeId,
                    EmployeeFullName = x.EmployeeFullName,
                    Id = x.id,
                    WorkshopId = x.WorkshopId,
                    IsActiveString = x.IsActiveString,
                    HasUploadedImage = x.HasUploadedImage,
                    Statuses = x.EmployeesStatus.Select(y => new RollCallEmployeeStatusViewModel()
                    {
                        StartDateGr = y.StartDate,
                        EndDateGr = y.EndDate,
                        Id = y.id
                    })

                }).ToList();
        ;
    }

    public List<RollCallEmployeeViewModel> GetActivePersonnelByWorkshopId(long workshopId)
    {
        var dateNow = DateTime.Now.Date;

        var leftWork = _context.LeftWorkList.Where(x =>
            x.WorkshopId == workshopId && x.StartWorkDate <= dateNow && x.LeftWorkDate >= dateNow);

        var rollCallEmployeesQuery = _context.RollCallEmployees.Include(x => x.EmployeesStatus)
            .Where(x => x.WorkshopId == workshopId
            && x.EmployeesStatus.Any(y => y.StartDate.Date <= dateNow && y.EndDate.Date > dateNow)
            && x.HasUploadedImage == "true" && leftWork.Any(l => l.EmployeeId == x.EmployeeId && l.WorkshopId == x.WorkshopId));


        var personnel =
            _context.PersonnelCodeSet.Where(x => x.WorkshopId == workshopId && rollCallEmployeesQuery.Any(y => y.EmployeeId == x.EmployeeId && y.WorkshopId == x.WorkshopId))
                .Select(x => new { x.EmployeeId, x.PersonnelCode }).ToList();

        var rollCallEmployeesList = rollCallEmployeesQuery.ToList();
        return personnel.Select(x =>
        {
            var name = rollCallEmployeesList.FirstOrDefault(y => x.EmployeeId == y.EmployeeId);
            return new RollCallEmployeeViewModel()
            {
                PersonelCode = x.PersonnelCode,
                EmployeeFName = name.FName,
                EmployeeLName = name.LName,
                EmployeeId = x.EmployeeId,
                EmployeeFullName = name.EmployeeFullName
            };
        }).OrderBy(x => x.EmployeeLName).ToList();


    }

    public List<RollCallEmployeeViewModel> GetEmployeeRollCalls(long workshopId)
    {
        var personnelCodes = _context.PersonnelCodeSet.Where(x => x.WorkshopId == workshopId);

        var rollCallEmployeesQuery = _context.RollCallEmployees.Include(x => x.EmployeesStatus)
            .Where(x => x.WorkshopId == workshopId && x.EmployeesStatus.Any() && personnelCodes.Any(y => y.EmployeeId == x.EmployeeId));

        var res = rollCallEmployeesQuery.Select(x => new RollCallEmployeeViewModel
        {
            RollCallEmployeeId = x.id,
            EmployeeId = x.EmployeeId,
            EmployeeFullName = x.EmployeeFullName
        })
            .ToList();

        return res;
    }

    public List<RollCallEmployeeViewModel> GetPersonnelRollCallListAll(long workshopId)
    {
        //var dateNow = DateTime.Now;
        //var f = _context.Employees.Include(x => x.LeftWorks).Include(x => x.LeftWorkInsurances)
        //	.Where(x => x.LeftWorks.Any(y => y.WorkshopId == workshopId && y.StartWorkDate <= dateNow && y.LeftWorkDate > dateNow) ||
        //				x.LeftWorkInsurances.Any(y => y.WorkshopId == workshopId && y.StartWorkDate <= dateNow &&
        //											  (y.LeftWorkDate > dateNow || y.LeftWorkDate == null))).ToList();


        //var res = f.Select(x => new RollCallEmployeeViewModel
        //{
        //	WorkshopId = workshopId,
        //	EmployeeId = x.id,
        //	Id = _context.RollCallEmployees.Any(r => r.EmployeeId == x.id && r.WorkshopId == workshopId) ?
        //			_context.RollCallEmployees.FirstOrDefault(r => r.EmployeeId == x.id && r.WorkshopId == workshopId)!.id : 0,
        //	EmployeeFullName = $"{x.FName} {x.LName}",
        //	EmployeeSlug = _passwordHasher.SlugHasher(x.id),
        //	NationalCode = _context.Employees.FirstOrDefault(e => e.id == x.id).NationalCode,
        //	IsActiveString = _context.RollCallEmployees.Any(r => r.EmployeeId == x.id && r.WorkshopId == workshopId && r.IsActiveString == "true") ? "true" : "false",
        //	HasUploadedImage = _context.RollCallEmployees.Any(r => r.EmployeeId == x.id && r.WorkshopId == workshopId && r.HasUploadedImage == "true") ? "true" : "false",
        //	ImagePath = (System.IO.File.Exists(Path.Combine(_webHostEnvironment.ContentRootPath, "Faces", workshopId.ToString(), x.id.ToString(), "1.jpg")))
        //			? Tools.ResizeImage(Path.Combine(_webHostEnvironment.ContentRootPath, "Faces", workshopId.ToString(), x.id.ToString(), "1.jpg"), 150, 150)
        //			: "",
        //}).OrderBy(x => x.PersonelCode)
        //	.ToList();

        //return res;

        return new();
    }

    #endregion

    #region Farokhi&Mahan

    public (int activeEmployees, int deActiveEmployees) GetActiveAndDeActiveRollCallEmployees(long workshopId)
    {
        var dateNow = DateTime.Now;

        var rawQuery = _context.Employees.Include(x => x.LeftWorks).Include(x => x.LeftWorkInsurances)
            .Where(x => x.LeftWorks.Any(y =>
                            y.WorkshopId == workshopId && y.StartWorkDate <= dateNow &&
                            y.LeftWorkDate > dateNow) ||
                        x.LeftWorkInsurances.Any(y =>
                            y.WorkshopId == workshopId && y.StartWorkDate <= dateNow &&
                            (y.LeftWorkDate > dateNow || y.LeftWorkDate == null))).OrderByDescending(x => x.id)
            .Select(x => new
            {
                Id = x.id,
            }).Distinct();

        var rollCallEmployees = _context.RollCallEmployees.Include(x => x.EmployeesStatus).Where(x => x.WorkshopId == workshopId);

        var joinedQuery = from employee in rawQuery
                          join rollCallEmployee in rollCallEmployees
                              on employee.Id equals rollCallEmployee.EmployeeId into grp
                          from joinedRollCall in grp.DefaultIfEmpty()
                          select new RollCallEmployeeViewModel()
                          {
                              IsActiveString = joinedRollCall.EmployeesStatus.Any(y => y.StartDate.Date <= dateNow.Date && y.EndDate.Date > dateNow.Date) ? "true" : "false",

                          };
        var deActiveCount = joinedQuery.Count(x => x.IsActiveString == "false");
        var ActiveCount = joinedQuery.Count(x => x.IsActiveString == "true");
        return (ActiveCount, deActiveCount);

    }

    public bool HasEmployees(long workshopId)
    {
        var dateNow = DateTime.Now;
        return _context.Employees.Include(x => x.LeftWorks).Include(x => x.LeftWorkInsurances)
            .Any(x => x.LeftWorks.Any(y =>
                          y.WorkshopId == workshopId && y.StartWorkDate <= dateNow &&
                          y.LeftWorkDate > dateNow) ||
                      x.LeftWorkInsurances.Any(y =>
                          y.WorkshopId == workshopId && y.StartWorkDate <= dateNow &&
                          (y.LeftWorkDate > dateNow || y.LeftWorkDate == null)));

    }

    public RollCallEmployee GetBy(long employeeId, long workshopId)
    {
        return _context.RollCallEmployees.Include(x => x.EmployeesStatus)
            .FirstOrDefault(x => x.EmployeeId == employeeId && x.WorkshopId == workshopId);
    }

    #endregion

}