using Marco.Pms.DataAccess.Data;
using Marco.Pms.Model.Dtos.Activities;
using Marco.Pms.Model.Dtos.Master;
using Marco.Pms.Model.Entitlements;
using Marco.Pms.Model.Forum;
using Marco.Pms.Model.Mapper;
using Marco.Pms.Model.Master;
using Marco.Pms.Model.Utilities;
using Marco.Pms.Model.ViewModels.Activities;
using Marco.Pms.Model.ViewModels.Forum;
using Marco.Pms.Model.ViewModels.Master;
using Marco.Pms.Services.Helpers;
using MarcoBMS.Services.Helpers;
using MarcoBMS.Services.Service;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace Marco.Pms.Services.Controllers
{
    [Authorize]
    [Route("api/[controller]")]
    [ApiController]
    public class MasterController : ControllerBase
    {
        private readonly ApplicationDbContext _context;
        private readonly UserHelper _userHelper;
        private readonly ILoggingService _logger;
        private readonly MasterHelper _masterHelper;
        public MasterController(ApplicationDbContext context, UserHelper userHelper, ILoggingService logger, MasterHelper masterHelper)
        {
            _context = context;
            _userHelper = userHelper;
            _logger = logger;
            _masterHelper = masterHelper;
        }

        // --------------------------------  Activity  --------------------------------
        [HttpGet]
        [Route("activities")]
        public async Task<IActionResult> GetActivitiesMaster()
        {
            Guid tenantId = _userHelper.GetTenantId();
            var activities = await _context.ActivityMasters.Where(c => c.TenantId == tenantId && c.IsActive == true).ToListAsync();
            List<ActivityVM> activitiesVM = new List<ActivityVM>();
            foreach (var activity in activities)
            {
                var checkList = await _context.ActivityCheckLists.Where(c => c.TenantId == tenantId && c.ActivityId == activity.Id).ToListAsync();
                List<CheckListVM> checkListVM = new List<CheckListVM>();
                if (checkList != null)
                {
                    foreach (ActivityCheckList check in checkList)
                    {
                        var checkVM = check.ToCheckListVMFromActivityCheckList(activity.Id, false);
                        checkListVM.Add(checkVM);
                    }
                }

                ActivityVM activityVM = activity.ToActivityVMFromActivityMaster(checkListVM);
                activitiesVM.Add(activityVM);
            }
            _logger.LogInfo("{count} activity records fetched successfully from tenant {tenantId}", activitiesVM.Count, tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(activitiesVM, System.String.Format("{0} activity records fetched successfully", activitiesVM.Count), 200));
        }

        [HttpPost("activity")]
        public async Task<IActionResult> CreateActivity([FromBody] CreateActivityMasterDto createActivity)
        {
            Guid tenantId = _userHelper.GetTenantId();
            var employee = await _userHelper.GetCurrentEmployeeAsync();
            if (employee.TenantId != tenantId)
            {
                _logger.LogWarning("User from tenant {employeeTenantId} tries to access data from tenant {tenantId}", employee.TenantId, tenantId);
                return Unauthorized(ApiResponse<object>.ErrorResponse("Current tenant did not match with user's tenant", "Current tenant did not match with user's tenant", 401));
            }
            var activityMaster = createActivity.ToActivityMasterFromCreateActivityMasterDto(tenantId);
            _context.ActivityMasters.Add(activityMaster);
            await _context.SaveChangesAsync();
            List<CheckListVM> checkListVM = new List<CheckListVM>();

            if (createActivity.CheckList != null)
            {
                List<ActivityCheckList> activityCheckList = new List<ActivityCheckList>();
                foreach (var check in createActivity.CheckList)
                {
                    ActivityCheckList checkList = check.ToActivityCheckListFromCreateCheckListDto(tenantId, activityMaster.Id);
                    activityCheckList.Add(checkList);
                }
                _context.ActivityCheckLists.AddRange(activityCheckList);
                await _context.SaveChangesAsync();

                foreach (ActivityCheckList check in activityCheckList)
                {
                    var checkVM = check.ToCheckListVMFromActivityCheckList(activityMaster.Id, false);
                    checkListVM.Add(checkVM);
                }
            }
            ActivityVM activityVM = activityMaster.ToActivityVMFromActivityMaster(checkListVM);

            _logger.LogInfo("activity created successfully from tenant {tenantId}", tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(activityVM, "activity created successfully", 200));
        }

        [HttpPost("activity/edit/{id}")]
        public async Task<IActionResult> UpdateActivity(Guid id, [FromBody] CreateActivityMasterDto createActivity)
        {
            Guid tenantId = _userHelper.GetTenantId();
            var employee = await _userHelper.GetCurrentEmployeeAsync();
            ActivityMaster? activity = await _context.ActivityMasters.FirstOrDefaultAsync(x => x.Id == id && x.IsActive == true && x.TenantId == tenantId);
            if (activity != null && createActivity.UnitOfMeasurement != null && createActivity.ActivityName != null)
            {

                activity.ActivityName = createActivity.ActivityName;
                activity.UnitOfMeasurement = createActivity.UnitOfMeasurement;
                List<ActivityCheckList> activityCheckLists = await _context.ActivityCheckLists.AsNoTracking().Where(c => c.ActivityId == activity.Id).ToListAsync();
                List<CheckListVM> checkListVM = new List<CheckListVM>();

                if (createActivity.CheckList != null)
                {

                    var newCheckIds = createActivity.CheckList.Select(c => c.Id);

                    List<ActivityCheckList> updateCheckList = new List<ActivityCheckList>();
                    List<ActivityCheckList> deleteCheckList = new List<ActivityCheckList>();
                    if (newCheckIds.Contains(null))
                    {
                        foreach (var check in createActivity.CheckList)
                        {
                            if (check.Id == null)
                            {
                                ActivityCheckList checkList = check.ToActivityCheckListFromCreateCheckListDto(tenantId, activity.Id);
                                updateCheckList.Add(checkList);
                            }
                        }
                    }
                    foreach (var check in activityCheckLists)
                    {
                        if (newCheckIds.Contains(check.Id))
                        {
                            var updatedCheck = createActivity.CheckList.Find(c => c.Id == check.Id);
                            ActivityCheckList checkList = updatedCheck != null ? updatedCheck.ToActivityCheckListFromCreateCheckListDto(tenantId, activity.Id) : new ActivityCheckList();
                            updateCheckList.Add(checkList);
                        }
                        else
                        {
                            deleteCheckList.Add(check);
                        }
                    }
                    _context.ActivityCheckLists.UpdateRange(updateCheckList);
                    if (deleteCheckList != null)
                    {
                        _context.ActivityCheckLists.RemoveRange(deleteCheckList);
                    }
                    await _context.SaveChangesAsync();

                    foreach (ActivityCheckList check in updateCheckList)
                    {
                        var checkVM = check.ToCheckListVMFromActivityCheckList(activity.Id, false);
                        checkListVM.Add(checkVM);
                    }
                }
                else if (activityCheckLists != null)
                {
                    _context.ActivityCheckLists.RemoveRange(activityCheckLists);
                    await _context.SaveChangesAsync();
                }
                ActivityVM activityVM = activity.ToActivityVMFromActivityMaster(checkListVM);
                _logger.LogInfo("activity updated successfully from tenant {tenantId}", tenantId);
                return Ok(ApiResponse<object>.SuccessResponse(activityVM, "activity updated successfully", 200));
            }
            _logger.LogError("Activity {ActivityId} not found", id);
            return NotFound(ApiResponse<object>.ErrorResponse("Activity not found", "Activity not found", 404));
        }

        [HttpDelete("activity/delete/{id}")]
        public async Task<IActionResult> DeleteActivity(Guid Id)
        {
            Guid tenantId = _userHelper.GetTenantId();
            var activity = await _context.ActivityMasters.FirstOrDefaultAsync(a => a.Id == Id && a.TenantId == tenantId);
            if (activity != null)
            {
                activity.IsActive = false;
            }
            await _context.SaveChangesAsync();
            _logger.LogInfo("Activity Deleted Successfully from tenant {tenantId}", tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(new { }, "Activity Deleted Successfully", 200));
        }

        // --------------------------------  Industry  --------------------------------

        [HttpGet]
        [Route("industries")]
        public async Task<IActionResult> GetIndustries()
        {
            Guid tenantId = _userHelper.GetTenantId();
            var industries = await _context.Industries.ToListAsync();

            _logger.LogInfo("{count} industry records fetched successfully from tenant {tenantId}", industries.Count, tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(industries, System.String.Format("{0} industry records fetched successfully", industries.Count), 200));
        }

        // -------------------------------- Ticket Status  --------------------------------

        [HttpGet("ticket-status")]
        public async Task<IActionResult> GetTicketStatusMaster()
        {
            Guid tenantId = _userHelper.GetTenantId();
            List<TicketStatusVM> statusVMs = new List<TicketStatusVM>();
            List<TicketStatusMaster> statusMasters = await _context.TicketStatusMasters.Where(s => s.TenantId == tenantId).ToListAsync();
            foreach (var statusMaster in statusMasters)
            {
                statusVMs.Add(statusMaster.ToTicketStatusVMFromTicketStatusMaster());
            }

            _logger.LogInfo("{count} Ticket Status records fetched successfully from tenant {tenantId}", statusVMs.Count, tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(statusVMs, System.String.Format("{0} Ticket Status records fetched successfully", statusVMs.Count), 200));
        }

        [HttpPost("ticket-status")]
        public async Task<IActionResult> CreateTicketStatusMaster([FromBody] TicketStatusMasterDto statusMasterDto)
        {
            Guid tenantId = _userHelper.GetTenantId();
            if (statusMasterDto != null)
            {
                TicketStatusMaster? statusMaster = statusMasterDto.ToTicketStatusMasterFromTicketStatusMasterDto(tenantId);
                _context.TicketStatusMasters.Add(statusMaster);
                await _context.SaveChangesAsync();

                TicketStatusVM statusVM = statusMaster.ToTicketStatusVMFromTicketStatusMaster();
                _logger.LogInfo("Ticket Status master {TicketStatusId} added successfully from tenant {tenantId}", statusMaster.Id, tenantId);
                return Ok(ApiResponse<object>.SuccessResponse(statusVM, "Ticket Status master added successfully", 200));
            }
            _logger.LogError("User sent empyt payload");
            return BadRequest(ApiResponse<object>.ErrorResponse("Sent Empty payload", "Sent Empty payload", 400));
        }

        [HttpPost("ticket-status/edit/{id}")]
        public async Task<IActionResult> UpdateTicketStatusMaster(Guid id, [FromBody] TicketStatusMasterDto statusMasterDto)
        {
            Guid tenantId = _userHelper.GetTenantId();
            if (statusMasterDto != null && statusMasterDto.Id != id)
            {
                TicketStatusMaster? statusMaster = await _context.TicketStatusMasters.AsNoTracking().FirstOrDefaultAsync(s => s.TenantId == tenantId && s.Id == statusMasterDto.Id);
                if (statusMaster != null)
                {
                    statusMaster = statusMasterDto.ToTicketStatusMasterFromTicketStatusMasterDto(tenantId);
                    _context.TicketStatusMasters.Update(statusMaster);
                    await _context.SaveChangesAsync();

                    TicketStatusVM statusVM = statusMaster.ToTicketStatusVMFromTicketStatusMaster();
                    _logger.LogInfo("Ticket Status master {TicketStatusId} updated successfully from tenant {tenantId}", statusMaster.Id, tenantId);
                    return Ok(ApiResponse<object>.SuccessResponse(statusVM, "Ticket Status master updated successfully", 200));
                }
                _logger.LogError("Ticket Status master {TicketStatusId} not found in database", statusMasterDto.Id != null ? statusMasterDto.Id.Value : Guid.Empty);
                return NotFound(ApiResponse<object>.ErrorResponse("Ticket Status master not found", "Ticket Status master not found", 404));
            }
            _logger.LogError("User sent empyt payload");
            return BadRequest(ApiResponse<object>.ErrorResponse("Sent Empty payload", "Sent Empty payload", 400));
        }

        [HttpDelete("ticket-status/{id}")]
        public async Task<IActionResult> DeleteTicketStatusMaster(Guid id)
        {
            var tenantId = _userHelper.GetTenantId();
            TicketStatusMaster? statusMaster = await _context.TicketStatusMasters.FirstOrDefaultAsync(t => t.TenantId == tenantId && t.Id == id);
            if (statusMaster != null)
            {
                if (statusMaster.IsDefault == false)
                {
                    _context.TicketStatusMasters.Remove(statusMaster);
                    await _context.SaveChangesAsync();

                    _logger.LogInfo("Ticket Status {TickeStatusId} deleted successfully from tenant {tenantId}", id, tenantId);
                    return Ok(ApiResponse<object>.SuccessResponse(new { }, "Ticket Status deleted successfully", 200));
                }
                else
                {
                    _logger.LogWarning("User tries to delete default ticket Status {TickeStatusId}", id);
                    return BadRequest(ApiResponse<object>.ErrorResponse("Can not delete default ticket Status", "Can not delete default ticket Status", 400));
                }
            }
            else
            {
                _logger.LogError("Ticket Status {TickeStatusId} not found in database", id);
                return NotFound(ApiResponse<object>.ErrorResponse("Ticket Status not found", "Ticket Status not found", 404));
            }
        }

        // -------------------------------- Ticket Type  --------------------------------

        [HttpGet("ticket-types")]
        public async Task<IActionResult> GetTicketTypeMaster()
        {
            Guid tenantId = _userHelper.GetTenantId();
            List<TicketTypeVM> typeVMs = new List<TicketTypeVM>();
            List<TicketTypeMaster> typeMasters = await _context.TicketTypeMasters.Where(s => s.TenantId == tenantId).ToListAsync();
            foreach (var typeMaster in typeMasters)
            {
                typeVMs.Add(typeMaster.ToTicketTypeVMFromTicketTypeMaster());
            }

            _logger.LogInfo("{count} Ticket Type records fetched successfully from tenant {tenantId}", typeVMs.Count, tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(typeVMs, System.String.Format("{0} Ticket Type records fetched successfully", typeVMs.Count), 200));
        }

        [HttpPost("ticket-types")]
        public async Task<IActionResult> CreateTicketTypeMaster([FromBody] TicketTypeMasterDto typeMasterDto)
        {
            Guid tenantId = _userHelper.GetTenantId();
            if (typeMasterDto != null)
            {
                TicketTypeMaster? typeMaster = typeMasterDto.ToTicketTypeMasterFromTicketTypeMasterDto(tenantId);
                _context.TicketTypeMasters.Add(typeMaster);
                await _context.SaveChangesAsync();

                TicketTypeVM typeVM = typeMaster.ToTicketTypeVMFromTicketTypeMaster();
                _logger.LogInfo("Ticket Type master {TicketTypeId} added successfully from tenant {tenantId}", typeMaster.Id, tenantId);
                return Ok(ApiResponse<object>.SuccessResponse(typeVM, "Ticket type master added successfully", 200));

            }
            _logger.LogError("User sent empyt payload");
            return BadRequest(ApiResponse<object>.ErrorResponse("User sent Empty payload", "User sent Empty payload", 400));
        }

        [HttpPost("ticket-types/edit/{id}")]
        public async Task<IActionResult> UpdateTicketTypeMaster(Guid id, [FromBody] TicketTypeMasterDto typeMasterDto)
        {
            Guid tenantId = _userHelper.GetTenantId();
            if (typeMasterDto != null && typeMasterDto.Id != id)
            {
                TicketTypeMaster? typeMaster = await _context.TicketTypeMasters.AsNoTracking().FirstOrDefaultAsync(s => s.TenantId == tenantId && s.Id == typeMasterDto.Id);
                if (typeMaster != null)
                {
                    typeMaster = typeMasterDto.ToTicketTypeMasterFromTicketTypeMasterDto(tenantId);
                    _context.TicketTypeMasters.Update(typeMaster);
                    await _context.SaveChangesAsync();

                    TicketTypeVM typeVM = typeMaster.ToTicketTypeVMFromTicketTypeMaster();
                    _logger.LogInfo("Ticket Type master {TicketTypeId} updated successfully from tenant {tenantId}", typeMaster.Id, tenantId);
                    return Ok(ApiResponse<object>.SuccessResponse(typeVM, "Ticket type master updated successfully", 200));
                }
                _logger.LogError("Ticket type master {TicketTypeId} not found in database", typeMasterDto.Id != null ? typeMasterDto.Id.Value : Guid.Empty);
                return NotFound(ApiResponse<object>.ErrorResponse("Ticket type master not found", "Ticket type master not found", 404));
            }
            _logger.LogError("User sent empyt payload");
            return BadRequest(ApiResponse<object>.ErrorResponse("User sent Empty payload", "User sent Empty payload", 400));
        }

        [HttpDelete("ticket-types/{id}")]
        public async Task<IActionResult> DeleteTicketTypeMaster(Guid id)
        {
            var tenantId = _userHelper.GetTenantId();
            TicketTypeMaster? typeMaster = await _context.TicketTypeMasters.FirstOrDefaultAsync(t => t.TenantId == tenantId && t.Id == id);
            if (typeMaster != null)
            {
                if (typeMaster.IsDefault == false)
                {
                    _context.TicketTypeMasters.Remove(typeMaster);
                    await _context.SaveChangesAsync();

                    _logger.LogInfo("Ticket Type {TickeTypeId} deleted successfully from tenant {tenantId}", id, tenantId);
                    return Ok(ApiResponse<object>.SuccessResponse(new { }, "Ticket Type deleted successfully", 200));
                }
                else
                {
                    _logger.LogWarning("User tries to delete default ticket Type {TickeTypeId}", id);
                    return BadRequest(ApiResponse<object>.ErrorResponse("Can not delete default ticket Type", "Can not delete default ticket Type", 400));
                }
            }
            else
            {
                _logger.LogError("Ticket Type {TickeTypeId} not found in database", id);
                return NotFound(ApiResponse<object>.ErrorResponse("Ticket Type not found", "Ticket Type not found", 404));
            }
        }

        // --------------------------------  Ticket Priority  --------------------------------

        [HttpGet("ticket-priorities")]
        public async Task<IActionResult> GetTicketPriorityMaster()
        {
            Guid tenantId = _userHelper.GetTenantId();
            List<TicketPriorityVM> priorityVMs = new List<TicketPriorityVM>();
            List<TicketPriorityMaster> priorityMasters = await _context.TicketPriorityMasters.Where(s => s.TenantId == tenantId).ToListAsync();
            foreach (var priorityMaster in priorityMasters)
            {
                priorityVMs.Add(priorityMaster.ToTicketPriorityVMFromTicketPriorityMaster());
            }

            _logger.LogInfo("{count} Ticket Priority records fetched successfully from tenant {tenantId}", priorityVMs.Count, tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(priorityVMs, System.String.Format("{0} Ticket Priority records fetched successfully", priorityVMs.Count), 200));
        }

        [HttpPost("ticket-priorities")]
        public async Task<IActionResult> CreateTicketPriorityMaster([FromBody] TicketPriorityMasterDto priorityMasterDto)
        {

            Guid tenantId = _userHelper.GetTenantId();
            if (priorityMasterDto != null)
            {
                TicketPriorityMaster? typeMaster = priorityMasterDto.ToTicketPriorityMasterFromTicketPriorityMasterDto(tenantId);
                _context.TicketPriorityMasters.Add(typeMaster);
                await _context.SaveChangesAsync();

                TicketPriorityVM typeVM = typeMaster.ToTicketPriorityVMFromTicketPriorityMaster();
                _logger.LogInfo("Ticket Priority master {TicketPriorityId} added successfully from tenant {tenantId}", typeMaster.Id, tenantId);
                return Ok(ApiResponse<object>.SuccessResponse(typeVM, "Ticket Priority master added successfully", 200));
            }

            _logger.LogError("User sent empyt payload");
            return BadRequest(ApiResponse<object>.ErrorResponse("User sent Empty payload", "User sent Empty payload", 400));
        }
        [HttpPost("ticket-priorities/edit/{id}")]
        public async Task<IActionResult> UpdateTicketPriorityMaster(Guid id, [FromBody] TicketPriorityMasterDto priorityMasterDto)
        {
            Guid tenantId = _userHelper.GetTenantId();
            if (priorityMasterDto != null && priorityMasterDto.Id != null)
            {
                TicketPriorityMaster? typeMaster = await _context.TicketPriorityMasters.AsNoTracking().FirstOrDefaultAsync(s => s.TenantId == tenantId && s.Id == priorityMasterDto.Id);
                if (typeMaster != null)
                {
                    typeMaster = priorityMasterDto.ToTicketPriorityMasterFromTicketPriorityMasterDto(tenantId);
                    _context.TicketPriorityMasters.Update(typeMaster);
                    await _context.SaveChangesAsync();

                    TicketPriorityVM typeVM = typeMaster.ToTicketPriorityVMFromTicketPriorityMaster();
                    _logger.LogInfo("Ticket Priority master {TicketPriorityId} updated successfully from tenant {tenantId}", typeMaster.Id, tenantId);
                    return Ok(ApiResponse<object>.SuccessResponse(typeVM, "Ticket Priority master updated successfully", 200));
                }
                _logger.LogError("Ticket Priority master {TicketPriorityId} not found in database", priorityMasterDto.Id != null ? priorityMasterDto.Id.Value : Guid.Empty);
                return NotFound(ApiResponse<object>.ErrorResponse("Ticket Priority master not found", "Ticket Priority master not found", 404));
            }
            _logger.LogError("User sent empyt payload");
            return BadRequest(ApiResponse<object>.ErrorResponse("User sent Empty payload", "User sent Empty payload", 400));
        }

        [HttpDelete("ticket-priorities/{id}")]
        public async Task<IActionResult> DeleteTicketPriorityMaster(Guid id)
        {
            var tenantId = _userHelper.GetTenantId();
            TicketPriorityMaster? priorityMaster = await _context.TicketPriorityMasters.FirstOrDefaultAsync(t => t.TenantId == tenantId && t.Id == id);
            if (priorityMaster != null)
            {
                if (priorityMaster.IsDefault == false)
                {
                    _context.TicketPriorityMasters.Remove(priorityMaster);
                    await _context.SaveChangesAsync();

                    _logger.LogInfo("Ticket Priority {TickePriorityId} deleted successfully from tenant {tenantId}", id, tenantId);
                    return Ok(ApiResponse<object>.SuccessResponse(new { }, "Ticket Priority deleted successfully", 200));
                }
                else
                {
                    _logger.LogWarning("User tries to delete default ticket Priority {TickePriorityId}", id);
                    return BadRequest(ApiResponse<object>.ErrorResponse("Can not delete default ticket Priority", "Can not delete default ticket Priority", 400));
                }
            }
            else
            {
                _logger.LogError("Ticket Priority {TickePriorityId} not found in database", id);
                return NotFound(ApiResponse<object>.ErrorResponse("Ticket Priority not found", "Ticket Priority not found", 404));
            }
        }

        // -------------------------------- Ticket Tag  --------------------------------

        [HttpGet("ticket-tags")]
        public async Task<IActionResult> GetTicketTagMaster()
        {
            Guid tenantId = _userHelper.GetTenantId();
            List<TicketTagVM> tagVMs = new List<TicketTagVM>();
            List<TicketTagMaster> tagMasters = await _context.TicketTagMasters.Where(s => s.TenantId == tenantId).ToListAsync();
            foreach (var tagMaster in tagMasters)
            {
                tagVMs.Add(tagMaster.ToTicketTagVMFromTicketTagMaster());
            }

            _logger.LogInfo("{count} Ticket Tag records fetched successfully from tenant {tenantId}", tagVMs.Count, tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(tagVMs, System.String.Format("{0} Ticket Tag records fetched successfully", tagVMs.Count), 200));
        }

        [HttpPost("ticket-tags")]
        public async Task<IActionResult> CreateTicketTagMaster([FromBody] TicketTagMasterDto tagMasterDto)
        {
            Guid tenantId = _userHelper.GetTenantId();
            if (tagMasterDto != null)
            {
                TicketTagMaster? tagMaster = tagMasterDto.ToTicketTagMasterFromTicketTagMasterDto(tenantId);
                _context.TicketTagMasters.Add(tagMaster);
                await _context.SaveChangesAsync();

                TicketTagVM typeVM = tagMaster.ToTicketTagVMFromTicketTagMaster();
                _logger.LogInfo("Ticket Tag master {TicketTypeId} added successfully from tenant {tenantId}", tagMaster.Id, tenantId);
                return Ok(ApiResponse<object>.SuccessResponse(typeVM, "Ticket tag master added successfully", 200));

            }
            _logger.LogError("User sent empyt payload");
            return BadRequest(ApiResponse<object>.ErrorResponse("User sent Empty payload", "User sent Empty payload", 400));
        }

        [HttpPost("ticket-tags/edit/{id}")]
        public async Task<IActionResult> UpdateTicketTagMaster(Guid id, [FromBody] TicketTagMasterDto tagMasterDto)
        {
            var tenantId = _userHelper.GetTenantId();
            if (tagMasterDto != null && tagMasterDto.Id != id)
            {
                TicketTagMaster? tagMaster = await _context.TicketTagMasters.AsNoTracking().FirstOrDefaultAsync(s => s.TenantId == tenantId && s.Id == tagMasterDto.Id);
                if (tagMaster != null)
                {
                    tagMaster = tagMasterDto.ToTicketTagMasterFromTicketTagMasterDto(tenantId);
                    _context.TicketTagMasters.Update(tagMaster);
                    await _context.SaveChangesAsync();

                    TicketTagVM typeVM = tagMaster.ToTicketTagVMFromTicketTagMaster();
                    _logger.LogInfo("Ticket Tag master {TicketTypeId} updated successfully from tenant {tenantId}", tagMaster.Id, tenantId);
                    return Ok(ApiResponse<object>.SuccessResponse(typeVM, "Ticket tag master updated successfully", 200));
                }
                _logger.LogError("Ticket tag master {TicketTypeId} not found in database", tagMasterDto.Id != null ? tagMasterDto.Id.Value : Guid.Empty);
                return NotFound(ApiResponse<object>.ErrorResponse("Ticket tag master not found", "Ticket tag master not found", 404));
            }
            _logger.LogError("User sent empyt payload");
            return BadRequest(ApiResponse<object>.ErrorResponse("User sent Empty payload", "User sent Empty payload", 400));
        }

        [HttpDelete("ticket-tags/{id}")]
        public async Task<IActionResult> DeleteTicketTagMaster(Guid id)
        {
            var tenantId = _userHelper.GetTenantId();
            TicketTagMaster? tagMaster = await _context.TicketTagMasters.FirstOrDefaultAsync(t => t.TenantId == tenantId && t.Id == id);
            if (tagMaster != null)
            {
                if (tagMaster.IsDefault == false)
                {
                    _context.TicketTagMasters.Remove(tagMaster);
                    await _context.SaveChangesAsync();

                    _logger.LogInfo("Ticket Tag {TickeTagId} deleted successfully from tenant {tenantId}", id, tenantId);
                    return Ok(ApiResponse<object>.SuccessResponse(new { }, "Ticket Tag deleted successfully", 200));
                }
                else
                {
                    _logger.LogWarning("User tries to delete default ticket tag {TickeTagId}", id);
                    return BadRequest(ApiResponse<object>.ErrorResponse("Can not delete default ticket tag", "Can not delete default ticket tag", 400));
                }
            }
            else
            {
                _logger.LogError("Ticket Tag {TickeTagId} not found in database", id);
                return NotFound(ApiResponse<object>.ErrorResponse("Ticket tag not found", "Ticket tag not found", 404));
            }
        }

        // -------------------------------- Work Category  --------------------------------

        [HttpGet("work-categories")]
        public async Task<IActionResult> GetWorkCategoryMasterList()
        {
            Guid tenantId = _userHelper.GetTenantId();
            List<WorkCategoryMasterVM> workCategoryMasterVMs = new List<WorkCategoryMasterVM>();
            List<WorkCategoryMaster> workCategories = await _context.WorkCategoryMasters.Where(s => s.TenantId == tenantId).ToListAsync();
            foreach (var workCategory in workCategories)
            {
                workCategoryMasterVMs.Add(workCategory.ToWorkCategoryMasterVMFromWorkCategoryMaster());
            }

            _logger.LogInfo("{count} Work Category records fetched successfully from tenant {tenantId}", workCategoryMasterVMs.Count, tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(workCategoryMasterVMs, System.String.Format("{0} Work Category records fetched successfully", workCategoryMasterVMs.Count), 200));
        }

        [HttpGet("work-category/{id})")]
        public async Task<IActionResult> GetWorkCategoryMaster(Guid id)
        {
            Guid tenantId = _userHelper.GetTenantId();
            WorkCategoryMaster? workCategory = await _context.WorkCategoryMasters.FirstOrDefaultAsync(s => s.TenantId == tenantId && s.Id == id);
            if (workCategory != null)
            {
                WorkCategoryMasterVM workCategoryMasterVM = workCategory.ToWorkCategoryMasterVMFromWorkCategoryMaster();
                _logger.LogInfo("{WorkCategoryId} Work Category fetched successfully from tenant {tenantId}", workCategoryMasterVM.Id ?? Guid.Empty, tenantId);
                return Ok(ApiResponse<object>.SuccessResponse(workCategoryMasterVM, "Work Category fetched successfully", 200));
            }

            _logger.LogInfo("{WorkCategoryId} Work Category not found in database", id);
            return NotFound(ApiResponse<object>.ErrorResponse("Work Category not found", "Work Category not found", 404));
        }

        [HttpPost("work-category")]
        public async Task<IActionResult> CreateWorkCategoryMaster([FromBody] WorkCategoryMasterDto workCategoryMasterDto)
        {
            Guid tenantId = _userHelper.GetTenantId();
            if (workCategoryMasterDto != null)
            {
                WorkCategoryMaster? existingWorkCategory = await _context.WorkCategoryMasters.FirstOrDefaultAsync(w => w.Name == workCategoryMasterDto.Name);
                if (existingWorkCategory != null)
                {
                    _logger.LogWarning("Work Category of name {WorkCategoryName} already exist", existingWorkCategory.Name);
                    return Conflict(ApiResponse<object>.ErrorResponse("Work Category already exist", "Work Category already exist", 409));
                }
                WorkCategoryMaster? workCategory = workCategoryMasterDto.ToWorkCategoryMasterFromWorkCategoryMasterDto(tenantId);
                WorkCategoryMasterVM workCategoryMasterVM = new WorkCategoryMasterVM();
                if (workCategory != null && workCategory.Id == Guid.Empty)
                {

                    _context.WorkCategoryMasters.Add(workCategory);
                    await _context.SaveChangesAsync();

                    workCategoryMasterVM = workCategory.ToWorkCategoryMasterVMFromWorkCategoryMaster();
                }
                _logger.LogInfo("Work category master {WorkCategoryId} added successfully from tenant {tenantId}", workCategoryMasterVM.Id ?? Guid.Empty, tenantId);
                return Ok(ApiResponse<object>.SuccessResponse(workCategoryMasterVM, "Work category master added successfully", 200));

            }
            _logger.LogError("User sent empyt payload");
            return BadRequest(ApiResponse<object>.ErrorResponse("User sent Empty payload", "User sent Empty payload", 400));
        }

        [HttpPost("work-category/edit/{id}")]
        public async Task<IActionResult> UpdateWorkCategoryMaster(Guid id, [FromBody] WorkCategoryMasterDto workCategoryMasterDto)
        {
            var tenantId = _userHelper.GetTenantId();
            if (workCategoryMasterDto != null && workCategoryMasterDto.Id != id)
            {
                WorkCategoryMaster? workCategory = await _context.WorkCategoryMasters.AsNoTracking().FirstOrDefaultAsync(s => s.TenantId == tenantId && s.Id == workCategoryMasterDto.Id);
                if (workCategory != null)
                {
                    if (workCategory.IsSystem)
                    {
                        _logger.LogError("User tries to update system-defined work category");
                        return BadRequest(ApiResponse<object>.ErrorResponse("Cannot update system-defined work", "Cannot update system-defined work", 400));
                    }
                    workCategory = workCategoryMasterDto.ToWorkCategoryMasterFromWorkCategoryMasterDto(tenantId);
                    _context.WorkCategoryMasters.Update(workCategory);
                    await _context.SaveChangesAsync();

                    WorkCategoryMasterVM workCategoryMasterVM = workCategory.ToWorkCategoryMasterVMFromWorkCategoryMaster();
                    _logger.LogInfo("Work category master {WorkCategoryId} updated successfully from tenant {tenantId}", workCategory.Id, tenantId);
                    return Ok(ApiResponse<object>.SuccessResponse(workCategoryMasterVM, "Work category master updated successfully", 200));
                }
                _logger.LogError("Work category master {WorkCategoryId} not found in database", workCategoryMasterDto.Id ?? Guid.Empty);
                return NotFound(ApiResponse<object>.ErrorResponse("Work category master not found", "Work category master not found", 404));
            }
            _logger.LogError("User sent empyt payload");
            return BadRequest(ApiResponse<object>.ErrorResponse("User sent Empty payload", "User sent Empty payload", 400));
        }

        [HttpDelete("work-category/{id}")]
        public async Task<IActionResult> DeleteWorkCategoryMaster(Guid id)
        {
            var tenantId = _userHelper.GetTenantId();
            var LoggedEmployee = await _userHelper.GetCurrentEmployeeAsync();
            WorkCategoryMaster? workCategory = await _context.WorkCategoryMasters.FirstOrDefaultAsync(t => t.TenantId == tenantId && t.Id == id);
            if (workCategory != null)
            {
                if (workCategory.IsSystem == false)
                {
                    _context.WorkCategoryMasters.Remove(workCategory);
                    await _context.SaveChangesAsync();

                    _logger.LogInfo("Work category {WorkCategoryId} deleted successfully from tenant {tenantId}", id, tenantId);
                    return Ok(ApiResponse<object>.SuccessResponse(new { }, "Work category deleted successfully", 200));
                }
                else
                {
                    _logger.LogWarning("Employee with {LoggedEmployeeId} tries to delete system-defined work category {WorkCategoryId}", LoggedEmployee.Id, id);
                    return BadRequest(ApiResponse<object>.ErrorResponse("Can not delete system-defined work category", "Can not delete system-defined work category", 400));
                }
            }
            else
            {
                _logger.LogError("Work category {WorkCategoryId} not found in database", id);
                return NotFound(ApiResponse<object>.ErrorResponse("Work category not found", "Work category not found", 404));
            }
        }

        // -------------------------------- Contact Category  --------------------------------

        [HttpGet("contact-categories")]
        public async Task<IActionResult> GetContactCategoryMasterList()
        {
            var response = await _masterHelper.GetContactCategoriesList();
            return Ok(response);
        }

        [HttpGet("contact-category/{id})")]
        public async Task<IActionResult> GetContactCategoryMaster(Guid id)
        {
            return Ok();
        }

        [HttpPost("contact-category")]
        public async Task<IActionResult> CreateContactCategoryMaster([FromBody] CreateContactCategoryDto contactCategoryDto)
        {
            var response = await _masterHelper.CreateContactCategory(contactCategoryDto);
            if (response.StatusCode == 200)
            {
                return Ok(response);
            }
            else if (response.StatusCode == 409)
            {
                return Conflict(response);
            }
            else
            {
                return BadRequest(response);
            }
        }

        [HttpPost("contact-category/edit/{id}")]
        public async Task<IActionResult> UpdateContactCategoryMaster(Guid id, [FromBody] UpdateContactCategoryDto updateContactCategoryDto)
        {
            return Ok();
        }

        [HttpDelete("contact-category/{id}")]
        public async Task<IActionResult> DeletecontactCategoryMaster(Guid id)
        {
            var response = await _masterHelper.DeleteContactCategory(id);
            return Ok(response);
        }

        // -------------------------------- Contact Tag  --------------------------------

        [HttpGet("contact-tags")]
        public async Task<IActionResult> GetContactTagMasterList()
        {
            var response = await _masterHelper.GetContactTags();
            return Ok(response);
        }

        [HttpGet("contact-tag/{id})")]
        public async Task<IActionResult> GetContactTagMaster(Guid id)
        {
            return Ok();
        }

        [HttpPost("contact-tag")]
        public async Task<IActionResult> CreateContactTagMaster([FromBody] CreateContactTagDto contactTagDto)
        {
            if (!ModelState.IsValid)
            {
                var errors = ModelState.Values
                    .SelectMany(v => v.Errors)
                    .Select(e => e.ErrorMessage)
                    .ToList();
                _logger.LogError("User sent Invalid Date while marking attendance");
                return BadRequest(ApiResponse<object>.ErrorResponse("Invalid data", errors, 400));
            }
            var response = await _masterHelper.CreateContactTag(contactTagDto);
            if (response.StatusCode == 200)
            {
                return Ok(response);
            }
            else if (response.StatusCode == 409)
            {
                return Conflict(response);
            }
            else
            {
                return BadRequest(response);
            }
        }

        [HttpPost("contact-tag/edit/{id}")]
        public async Task<IActionResult> UpdateContactTagMaster(Guid id, [FromBody] UpdateContactTagDto updateContactTagDto)
        {
            return Ok();
        }

        [HttpDelete("contact-tag/{id}")]
        public async Task<IActionResult> DeletecontactTagMaster(Guid id)
        {
            return Ok();
        }
    }
}