using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using FrameworkDAL.CustomCode.RoleVsModule;
using FrameworkDAL.DTO.Project;
using FrameworkDAL.DTO.Menu;
using GB5Shared.DTO.Framework.AutoNumber;
using GB5Shared.DTO.Framework.Login;
using GB5Shared.DTO.Framework.Criteria;
using GB5Shared.GenerateAutoNumber;
using GB5Shared.Resource.Response;
using Newtonsoft.Json;

namespace FrameworkBLL.RoleVsModule
{
    public class RoleVsModulesBLL : IRoleVsModulesBLL
    {
        private readonly IRoleVsModulesDAL _RoleVsModulesDAL;
        private readonly AutoNumber _AutoNumber;

        public RoleVsModulesBLL(IRoleVsModulesDAL RoleVsModulesDAL, AutoNumber AutoNumber)
        {
            _RoleVsModulesDAL = RoleVsModulesDAL;
            _AutoNumber = AutoNumber;
        }

        public async Task<string> Save(List<RoleVsModulesDTO> RoleVsModulesDTOs, LoginDTO LoginDTO)
        {
            AutoNumberDTO? AutoNumberDTO = null;

            try
            {
                if (RoleVsModulesDTOs == null || RoleVsModulesDTOs.Count == 0)
                    return $"{SuccessResponse.SaveSuccessMessage} 0";

                int RoleId = RoleVsModulesDTOs[0].RoleId;

                // Load existing (RoleVsModulesId, ModuleId) pairs for this role from DB
                var existingRows = await _RoleVsModulesDAL.GetExistingForRole(RoleId, LoginDTO);

                var existingByModuleId = existingRows
                    .ToDictionary(r => r.ModuleId, r => r.RoleVsModulesId);

                var toInsert = RoleVsModulesDTOs
                    .Where(d => !existingByModuleId.ContainsKey(d.ModuleId))
                    .ToList();

                var toUpdate = RoleVsModulesDTOs
                    .Where(d => existingByModuleId.ContainsKey(d.ModuleId))
                    .ToList();

                int savedId = 0;

                // =====================================================
                // INSERT
                // =====================================================
                if (toInsert.Count > 0)
                {
                    AutoNumberDTO = await _AutoNumber.GetNumberAsync(
                        toInsert.Count,
                        "ROLEVSMODULES",
                        LoginDTO);

                    for (int i = 0; i < toInsert.Count; i++)
                    {
                        toInsert[i].RoleVsModulesId = AutoNumberDTO.StartNumber + i;
                    }

                    await _RoleVsModulesDAL.SaveRoleVsModules(
                        toInsert,
                        LoginDTO);

                    savedId = AutoNumberDTO.StartNumber;
                }

                // =====================================================
                // UPDATE
                // =====================================================
                foreach (var record in toUpdate)
                {
                    record.RoleVsModulesId = existingByModuleId[record.ModuleId];

                    await _RoleVsModulesDAL.UpdateRoleVsModules(
                        record,
                        LoginDTO);

                    if (savedId == 0)
                        savedId = record.RoleVsModulesId;
                }

                // =====================================================
                // RESPONSE
                // =====================================================

                // Only Update
                if (toInsert.Count == 0 && toUpdate.Count > 0)
                {
                    return $"{SuccessResponse.UpdateSuccessMessage} {savedId}";
                }

                // Insert or Insert + Update
                return $"{SuccessResponse.SaveSuccessMessage} {savedId}";
            }
            catch (Exception)
            {
                if (AutoNumberDTO != null)
                {
                    await _AutoNumber.RollbackAutoNumber(
                        "ROLEVSMODULES",
                        AutoNumberDTO.StartNumber,
                        LoginDTO);
                }

                throw;
            }
        }

        public async Task<string> DeleteRoleVsModules(int RoleId, LoginDTO LoginDTO)
        {
            try
            {
                int Result = await _RoleVsModulesDAL.DeleteRoleVsModules(RoleId, LoginDTO);
                if (Result > 0)
                    return $"{SuccessResponse.DeleteSuccessMessage}";
                else
                    return $"{ErrorResponse.DeleteNotFoundMessage}";
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> DeleteRoleVsModulesByModuleId(int ModuleId, int RoleId, LoginDTO LoginDTO)
        {
            try
            {
                int Result = await _RoleVsModulesDAL.DeleteRoleVsModulesByModuleId(ModuleId, RoleId, LoginDTO);
                if (Result > 0)
                    return $"{SuccessResponse.DeleteSuccessMessage}";
                else
                    return $"{ErrorResponse.DeleteNotFoundMessage}";
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> GetRoleVsModuleWithRoleId(int RoleId, LoginDTO LoginDTO)
        {
            try
            {
                List<RoleVsModulesDTO> RoleVsModulesDTOs = await _RoleVsModulesDAL.GetRoleVsModuleWithRoleId(RoleId, LoginDTO);
                return JsonConvert.SerializeObject(RoleVsModulesDTOs);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> GetRoleVsModule(int RoleId, int ModuleId, string ModuleCode, string ModuleName, LoginDTO LoginDTO)
        {
            try
            {
                List<ModulePicklistDTO> ModulePicklistDTOs = await _RoleVsModulesDAL.GetRoleVsModule(RoleId, ModuleId, ModuleCode, ModuleName, LoginDTO);
                return JsonConvert.SerializeObject(ModulePicklistDTOs);
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<string> GetUserRoleVsMenuSelectList(int FirstNumber, int MaxResult, CriteriaDTO CriteriaDTO, LoginDTO LoginDTO)
        {
            try
            {
                int roleId = -1, moduleId = -1;
                if (CriteriaDTO?.SectionCriteriaList != null)
                {
                    foreach (var section in CriteriaDTO.SectionCriteriaList)
                    {
                        if (section?.AttributesCriteriaList == null) continue;
                        foreach (var attr in section.AttributesCriteriaList)
                        {
                            if (attr?.FieldName == null || attr.FieldValue == null) continue;
                            if (int.TryParse(attr.FieldValue.ToString(), out int val))
                            {
                                switch (attr.FieldName.ToLower())
                                {
                                    case "roleid":   roleId   = val; break;
                                    case "moduleid": moduleId = val; break;
                                }
                            }
                        }
                    }
                }
                List<MenuPicklistDTO> MenuPicklistDTOs = await _RoleVsModulesDAL.GetUserRoleVsMenu(roleId, moduleId, LoginDTO);
                return JsonConvert.SerializeObject(MenuPicklistDTOs);
            }
            catch (Exception)
            {
                throw;
            }
        }
    }
}