using FrameworkBLL.User;
using FrameworkDAL.CustomCode.Menu;
using GB5Shared.Tree;
using FrameworkDAL.CustomCode.User;
using FrameworkDAL.DTO.Menu;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.Resource.Response;
using GB5Shared.Telemetry;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using static GB5Shared.GB5Constant.Constant;

namespace FrameworkBLL.Menu
{
    /// <summary>
    /// MenuBLL
    /// </summary>
    ///
    public class MenuBLL : IMenuBLL
    {
        private readonly IMenuDAL _MenuDAL;
        private readonly AutoNumber _autoNumber;
        /// <summary>
        /// Initializes a new instance of the <see cref="MenuBLL"/> class.
        /// </summary>
        public MenuBLL(IMenuDAL MenuDAL, AutoNumber autoNumber)
        {
            _MenuDAL = MenuDAL;
            _autoNumber = autoNumber;
        }
        /// <summary> 
        /// Gets the menu for a user module.
        /// </summary>
        /// <param name="UserId">The user identifier.</param>
        /// <param name="ModuleId">The module identifier.</param>
        /// <param name="LoginDTO">The login data transfer object.</param>
        /// <returns>A JSON string representing the menu tree.</returns>
        public async Task<string> GetMenuForUserModule(int UserId, int ModuleId, LoginDTO LoginDTO)
        {
            try
            {
                if (LoginDTO.ModeOfOperation == 0)
                {
                    // FindModuleWiseLicnese(UserId, ModuleId, LoginDTO);//Currently commented since we dont have provision to generate license 
                }

                List<MenuTreeDTO> MenuTreeDTOs = new List<MenuTreeDTO>();
                List<LoadMenuListDTO> menuList = (await _MenuDAL.GetMenuForUserModule(UserId, ModuleId, LoginDTO)).ToList(); // Convert to List

                for (int i = 0; i < menuList.Count; i++)
                {
                    LoadMenuListDTO menu = menuList[i];

                    MenuTreeDTO menuTreeDTO = new MenuTreeDTO();
                    menuTreeDTO.Id = menu.MenuId;
                    menuTreeDTO.Code = menu.MenuCode;
                    menuTreeDTO.data = menu.MenuName;
                    menuTreeDTO.MenuType = menu.MenuMenuType;
                    menuTreeDTO.ModuleId = menu.ModuleId;
                    menuTreeDTO.ModuleCode = menu.ModuleCode;
                    menuTreeDTO.ModuleName = menu.ModuleName;
                    menuTreeDTO.DisplayName = menu.MenuDisplayName;
                    menuTreeDTO.MenuObjectModelName = menu.MenuObjectModelName;
                    menuTreeDTO.Section = menu.MenuSection;
                    menuTreeDTO.ReportId = menu.ReportId;
                    menuTreeDTO.ReportName = menu.ReportName;
                    menuTreeDTO.BizTransactionClassId = menu.MenuBizTransactionClassId;
                    menuTreeDTO.BizTransactionClassName = menu.MenuBizTransactionClassName;
                    menuTreeDTO.MenuObjectModelFileLocation = menu.MenuObjectModelFileLocation;
                    menuTreeDTO.Level = menu.MenuLevel;
                    menuTreeDTO.WebFormId = menu.WebFormId;
                    menuTreeDTO.WebFormName = menu.WebFormName;
                    menuTreeDTO.WebFormURL = menu.WebFormURL;
                    menuTreeDTO.WebFormSecondURL = menu.WebFormSecondURL;
                    menuTreeDTO.MenuDescription = menu.MenuDescription;
                    menuTreeDTO.GcmTypeId = menu.GcmTypeId;
                    menuTreeDTO.GcmTypeCode = menu.GcmTypeCode;
                    menuTreeDTO.GcmTypeName = menu.GcmTypeName;
                    menuTreeDTO.HelpUrl = menu.HelpUrl;
                    menuTreeDTO.ImageId = menu.ImageId;
                    menuTreeDTO.ImageName = menu.ImageName;
                    menuTreeDTO.ImageLinkURL = menu.ImageLinkURL;
                    menuTreeDTO.MenuSortOrder = menu.MenuSortOrder;
                    menuTreeDTO.EntityId = menu.EntityId;
                    menuTreeDTO.InchargeId = menu.InchargeId;
                    menuTreeDTO.InchargeCode = menu.InchargeCode;
                    menuTreeDTO.InchargeName = menu.InchargeName;
                    menuTreeDTO.AnalysisWebServiceId = menu.AnalysisWebServiceId;
                    menuTreeDTO.UserVsMenuId = menu.UserVsMenuId;
                    menuTreeDTO.DefaultMenuId = menu.DefaultMenuId;
                    menuTreeDTO.DefaultMenuCode = menu.DefaultMenuCode;
                    menuTreeDTO.DefaultMenuName = menu.DefaultMenuName;
                    menuTreeDTO.DefaultMenuMenuNature = menu.DefaultMenuMenuNature;
                    menuTreeDTO.DefaultMenuMenuType = menu.DefaultMenuMenuType;
                    menuTreeDTO.DefaultMenuSection = menu.DefaultMenuSection;
                    menuTreeDTO.DefaultMenuReportId = menu.DefaultMenuReportId;
                    menuTreeDTO.DefaultMenuEntityId = menu.DefaultMenuEntityId;
                    menuTreeDTO.DefaultMenuBizTransactionClassId = menu.DefaultMenuBizTransactionClassId;
                    menuTreeDTO.DefaultMenuBizTransactionClassName = menu.DefaultMenuBizTransactionClassName;
                    menuTreeDTO.DefaultMenuGCMTypeId = menu.DefaultMenuGCMTypeId;
                    menuTreeDTO.DefaultMenuWebFormId = menu.DefaultMenuWebFormId;
                    menuTreeDTO.DefaultMenuWebFormName = menu.DefaultMenuWebFormName;
                    menuTreeDTO.DefaultMenuWebFormUrl = menu.DefaultMenuWebFormUrl;
                    menuTreeDTO.DefaultMenuHelpUrl = menu.DefaultMenuHelpUrl;
                    menuTreeDTO.DefaultMenuImageId = menu.DefaultMenuImageId;
                    menuTreeDTO.MenuWebFormObjectModelIds = menu.MenuWebFormObjectModelIds;
                    menuTreeDTO.MenuWebFormObjectModelNames = menu.MenuWebFormObjectModelNames;
                    menuTreeDTO.DefaultWebFormObjectModelIds = menu.DefaultWebFormObjectModelIds;
                    menuTreeDTO.DefaultWebFormObjectModelNames = menu.DefaultWebFormObjectModelNames;
                    menuTreeDTO.ListMenuId = menu.ListMenuId;
                    menuTreeDTO.PageCode = menu.PageCode;
                    menuTreeDTO.PageId = menu.PageId;
                    menuTreeDTO.PageName = menu.PageName;
                    menuTreeDTO.TargetType = menu.TargetType;
                    menuTreeDTO.TargetId = menu.TargetId;
                    menuTreeDTO.MenuIconName = menu.MenuIconName;

                    if (menu.ParentId != -1)
                    {
                        MenuTreeDTO parentMenuTreeDTO = new MenuTreeDTO();
                        parentMenuTreeDTO.Id = menu.ParentId;
                        parentMenuTreeDTO.UserVsMenuId = menu.UserVsMenuId;
                        parentMenuTreeDTO.DefaultMenuId = menu.DefaultMenuId;
                        parentMenuTreeDTO.DefaultMenuCode = menu.DefaultMenuCode;
                        parentMenuTreeDTO.DefaultMenuName = menu.DefaultMenuName;
                        parentMenuTreeDTO.DefaultMenuMenuNature = menu.DefaultMenuMenuNature;
                        parentMenuTreeDTO.DefaultMenuMenuType = menu.DefaultMenuMenuType;
                        parentMenuTreeDTO.DefaultMenuSection = menu.DefaultMenuSection;
                        parentMenuTreeDTO.DefaultMenuReportId = menu.DefaultMenuReportId;
                        parentMenuTreeDTO.DefaultMenuEntityId = menu.DefaultMenuEntityId;
                        parentMenuTreeDTO.DefaultMenuBizTransactionClassId = menu.DefaultMenuBizTransactionClassId;
                        parentMenuTreeDTO.DefaultMenuBizTransactionClassName = menu.DefaultMenuBizTransactionClassName;
                        parentMenuTreeDTO.DefaultMenuGCMTypeId = menu.DefaultMenuGCMTypeId;
                        parentMenuTreeDTO.DefaultMenuWebFormId = menu.DefaultMenuWebFormId;
                        parentMenuTreeDTO.DefaultMenuWebFormName = menu.DefaultMenuWebFormName;
                        parentMenuTreeDTO.DefaultMenuWebFormUrl = menu.DefaultMenuWebFormUrl;
                        parentMenuTreeDTO.DefaultMenuHelpUrl = menu.DefaultMenuHelpUrl;
                        parentMenuTreeDTO.DefaultMenuImageId = menu.DefaultMenuImageId;
                        parentMenuTreeDTO.MenuWebFormObjectModelIds = menu.MenuWebFormObjectModelIds;
                        parentMenuTreeDTO.MenuWebFormObjectModelNames = menu.MenuWebFormObjectModelNames;
                        parentMenuTreeDTO.DefaultWebFormObjectModelIds = menu.DefaultWebFormObjectModelIds;
                        parentMenuTreeDTO.DefaultWebFormObjectModelNames = menu.DefaultWebFormObjectModelNames; 
                        menuTreeDTO.Parent = parentMenuTreeDTO;
                    }

                    MenuTreeAttributeDTO attr = new MenuTreeAttributeDTO();
                    attr.Id = menuTreeDTO.Id;
                    attr.Code = menuTreeDTO.Code;
                    attr.Nature = menu.MenuMenuNature;

                    menuTreeDTO.attr = attr;

                    MenuTreeDTOs.Add(menuTreeDTO);
                }

                string Json1 = JsonConvert.SerializeObject(MenuTreeDTOs);
                IList<MenuTreeDTO> TreeTopLevelCategory = TreeHelper.ConvertToTree(MenuTreeDTOs);
                string Json = JsonConvert.SerializeObject(TreeTopLevelCategory);
                return Json;
            }
            catch (Exception)
            {
                throw;
            }
        }


        public async Task<string> GetMenu(int MenuId, LoginDTO LoginDTO)
        {
            try
            { 
                return await _MenuDAL.GetMenu(MenuId, LoginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task <string> GetReportCriteriaForMenu(int UserId, int MenuId, int IsFromScreen, LoginDTO LoginDTO)
        {
            try
            {
                    return await _MenuDAL.GetReportCriteriaForMenu(UserId, MenuId, IsFromScreen, LoginDTO);
            }
            catch (Exception)
            {
                throw;
            } 
        }

        /// <summary>
        /// Retrieves a list of Menu records based on filter criteria.
        /// Typically used for populating dropdowns or selection lists in the UI.
        /// </summary>
        /// <param name="CriteriaDTO">Filter criteria for selecting Menus.</param>
        /// <param name="LoginDTO">The current user's login details.</param>
        /// <returns>A JSON string representing the list of Menus.</returns>
        public async Task<string> GetSelectListMenu(CriteriaDTO CriteriaDTO, LoginDTO LoginDTO)
        {
            try
            {
                return await _MenuDAL.GetSelectListMenu(CriteriaDTO, LoginDTO);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> GetMenuListBasedMenuSetForTree(int Type, int ModuleId, CriteriaDTO CriteriaDTO, LoginDTO LoginDTO)
        {
            try
            {
                List<MenuTreeDTO> MenuTreeDTOs = new List<MenuTreeDTO>();
                List<LoadMenuListDTO> menuList = (await _MenuDAL.GetMenuListBasedMenuSetForTree(ModuleId, CriteriaDTO, LoginDTO)).ToList();

                for (int i = 0; i < menuList.Count; i++)
                {
                    LoadMenuListDTO menu = menuList[i];

                    MenuTreeDTO menuTreeDTO = new MenuTreeDTO();
                    menuTreeDTO.Id = menu.MenuId;
                    menuTreeDTO.Code = menu.MenuCode;
                    menuTreeDTO.data = menu.MenuDisplayName;
                    menuTreeDTO.MenuType = menu.MenuMenuType;
                    menuTreeDTO.ModuleId = menu.ModuleId;
                    menuTreeDTO.ModuleCode = menu.ModuleCode;
                    menuTreeDTO.ModuleName = menu.ModuleName;
                    menuTreeDTO.DisplayName = menu.MenuDisplayName;
                    menuTreeDTO.Section = menu.MenuSection;
                    menuTreeDTO.ReportId = menu.ReportId;
                    menuTreeDTO.ReportName = menu.ReportName;
                    menuTreeDTO.BizTransactionClassId = menu.MenuBizTransactionClassId;
                    menuTreeDTO.BizTransactionClassName = menu.MenuBizTransactionClassName;
                    menuTreeDTO.Level = menu.MenuLevel;
                    menuTreeDTO.WebFormId = menu.WebFormId;
                    menuTreeDTO.WebFormName = menu.WebFormName;
                    menuTreeDTO.MenuDescription = menu.MenuDescription;
                    menuTreeDTO.GcmTypeId = menu.GcmTypeId;
                    menuTreeDTO.GcmTypeCode = menu.GcmTypeCode;
                    menuTreeDTO.GcmTypeName = menu.GcmTypeName;

                    if (menu.ParentId != -1)
                    {
                        menuTreeDTO.Parent = new MenuTreeDTO();
                        menuTreeDTO.Parent.Id = menu.ParentId;
                    }

                    MenuTreeAttributeDTO attr = new MenuTreeAttributeDTO();
                    attr.Id = menuTreeDTO.Id;
                    attr.Code = menuTreeDTO.Code;
                    attr.Nature = menu.MenuMenuNature;
                    menuTreeDTO.attr = attr;

                    MenuTreeDTOs.Add(menuTreeDTO);
                }

                if (Type == 0)
                {
                    IList<MenuTreeDTO> TreeTopLevelCategory = TreeHelper.ConvertToTree(MenuTreeDTOs);
                    return JsonConvert.SerializeObject(TreeTopLevelCategory);
                }
                else
                {
                    return JsonConvert.SerializeObject(MenuTreeDTOs);
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<MenuAdminDTO?> GetMenuAdmin(int menuId, LoginDTO LoginDTO, CancellationToken ct)
            => await _MenuDAL.GetMenuAdmin(menuId, LoginDTO).ConfigureAwait(false);

        public async Task<string> SaveMenu(MenuAdminDTO dto, LoginDTO LoginDTO, CancellationToken ct)
        {
            if (dto is null) throw new ArgumentNullException(nameof(dto));
            if (string.IsNullOrWhiteSpace(dto.MenuCode)) throw new ArgumentException("MenuCode is required.", nameof(dto));
            if (string.IsNullOrWhiteSpace(dto.MenuName)) throw new ArgumentException("MenuName is required.", nameof(dto));

            try
            {
                var now = DateTime.UtcNow;
                bool isNew = dto.MenuId <= 0;
                GB5Trace.Step("save-menu", new { dto.MenuId, isNew });

                dto.ModifiedById = LoginDTO.UserId;
                dto.ModifiedOn = now;

                if (isNew)
                {
                    var auto = await _autoNumber.GetNumberAsync(1, AUTONUMBERCONSTANT.MENU, LoginDTO).ConfigureAwait(false);
                    dto.MenuId = auto.StartNumber;
                    dto.CreatedById = LoginDTO.UserId;
                    dto.CreatedOn = now;
                    await _MenuDAL.SaveMenu(dto, LoginDTO).ConfigureAwait(false);
                }
                else
                {
                    await _MenuDAL.UpdateMenu(dto, LoginDTO).ConfigureAwait(false);
                }

                return isNew ? $"{SuccessResponse.SaveSuccessMessage} {dto.MenuId}" : SuccessResponse.UpdateSuccess;
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("save-menu-failed", ex);
                throw;
            }
        }

        public async Task<string> DeleteMenu(int menuId, LoginDTO LoginDTO, CancellationToken ct)
        {
            try
            {
                GB5Trace.Step("delete-menu", new { menuId });
                await _MenuDAL.DeleteMenu(menuId, LoginDTO).ConfigureAwait(false);
                return SuccessResponse.DeleteSuccessMessage;
            }
            catch (Exception ex)
            {
                GB5Trace.MarkFailed("delete-menu-failed", ex);
                throw;
            }
        }
    }
}