using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Threading.Tasks;
using _0_Framework.Application;
using _0_Framework.InfraStructure;
using Company.Domain.LeftWorkAgg;
using Company.Domain.LeftWorkTempAgg;
using CompanyManagment.App.Contracts.LeftWorkTemp;
using CompanyManagment.EFCore.Migrations;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.ChangeTracking.Internal;

namespace CompanyManagment.EFCore.Repository;

public class LeftWorkTempRepository : RepositoryBase<long, LeftWorkTemp>, ILeftWorkTempRepository
{
	private readonly CompanyContext _companyContext;

	public LeftWorkTempRepository(CompanyContext companyContext) : base(companyContext)
	{
		_companyContext = companyContext;
	}

	public async Task<GetStartWorkTempDetails> GetStartAndLeftWorkDetails(long employeeId, long workshopId)
	{
		var employee = await _companyContext.Employees.FindAsync(employeeId);
		var workshop = await _companyContext.Workshops.FindAsync(workshopId);

		var leftWorkTemp =
			await _companyContext.LeftWorkTemps.FirstOrDefaultAsync(x =>
				x.WorkshopId == workshopId && x.EmployeeId == employeeId);

		if (employee == null || workshop == null || leftWorkTemp == null)
		{
			return new GetStartWorkTempDetails();
		}

		var job = await _companyContext.Jobs.FindAsync(leftWorkTemp.JobId);


		var previousLeftWorks = _companyContext.LeftWorkList
			.Where(x => leftWorkTemp.EmployeeId == x.EmployeeId && leftWorkTemp.WorkshopId == x.WorkshopId).ToList();



		if (leftWorkTemp.LeftWorkType == LeftWorkTempType.LeftWork)
		{
			previousLeftWorks = previousLeftWorks.Where(x => x.id != leftWorkTemp.LeftWorkId).ToList();


		}

		var personnelCode =
			_companyContext.PersonnelCodeSet.FirstOrDefault(x =>
				x.EmployeeId == employeeId && x.WorkshopId == workshopId)?.PersonnelCode;

		return new GetStartWorkTempDetails
		{
			WorkshopId = leftWorkTemp.WorkshopId,
			EmployeeId = leftWorkTemp.EmployeeId,
			WorkshopFullName = workshop.WorkshopFullName,
			EmployeeFullName = employee.FullName,
			JobId = leftWorkTemp.JobId,
			JobName = job?.JobName,
			PersonnelCode = personnelCode ?? 0,
			LeftWorkTemp = new LeftWorkTempDetailsViewModel()
			{
				Id = leftWorkTemp.id,
				LastDayStanding = leftWorkTemp.LastDayStanding == new DateTime() ? "" : leftWorkTemp.LastDayStanding.ToFarsi(),
				LeftWork = leftWorkTemp.LeftWork == new DateTime() ? "" : leftWorkTemp.LeftWork.ToFarsi(),
				StartWork = leftWorkTemp.StartWork.ToFarsi()
			},
			PreviousLeftWorks = previousLeftWorks.Select(x => new LeftWorkTempDetailsViewModel()
			{
				Id = x.id,
				LastDayStanding = x.LeftWorkDate.AddDays(-1).ToFarsi(),
				LeftWork = x.LeftWorkDate.ToFarsi(),
				StartWork = x.StartWorkDate.ToFarsi()
			}).ToList()
		};
	}

	public List<LeftWorkTempViewModel> GetLeftWorksByWorkshopId(long workshopId)
	{
		var data = _companyContext.LeftWorkTemps.Where(x => x.WorkshopId == workshopId)
			.Select(x => new LeftWorkTempViewModel
			{
				LeftWorkId = x.LeftWorkId,
				WorkshopId = x.WorkshopId,
				EmployeeId = x.EmployeeId,
				JobId = x.JobId,
				LastDayStanding = x.LastDayStanding,
				LeftWork = x.LeftWork,
				LeftWorkType = x.LeftWorkType,
				StartWork = x.StartWork
			}).ToList();

		return data;
	}

    public async Task<List<LeftWorkTempViewModel>> GetLeftWorkTempsByEmployeeId(long employeeId)
    {
        return await _companyContext.LeftWorkTemps.Where(x => x.EmployeeId == employeeId).Select(x =>
            new LeftWorkTempViewModel()
            {
                EmployeeId = x.EmployeeId,
                WorkshopId = x.WorkshopId,
                LeftWorkType = x.LeftWorkType,
                StartWork = x.StartWork,
                LeftWork = x.LeftWork,
                JobId = x.JobId,
                LastDayStanding = x.LastDayStanding,
                LeftWorkId = x.LeftWorkId
            }).ToListAsync();
    }
}