using CPRNIMS.Domain.UIContracts.Account;
using CPRNIMS.Infrastructure.Helper;
using CPRNIMS.Infrastructure.ViewModel.Account;
using CPRNIMS.Infrastructure.ViewModel.Common;
using CPRNIMS.WebApps.Controllers.Base;
using Microsoft.AspNetCore.Mvc;

namespace CPRNIMS.WebApps.Controllers.Account
{
    public class AccountController : BaseMethod
    {
        private readonly IAccount _account;
        List<UserRightsVM>? response;
        public AccountController(IWebHostEnvironment webHostEnvironment,
            IAccount account,ErrorLogHelper errorMessageService,TokenHelper tokenHelper
            ) : base(errorMessageService, webHostEnvironment,tokenHelper)
        {
            _account = account;
        }
        #region Change Password
        public async Task<IActionResult> SendOTPByEmail(EmailMessageDetailsVM model)
        {
            try
            {
                var response = await _account.GetUserByEmail(model.Email, model);
                if (response.messCode == 1)
                {
                    return Json(new { success = true, Response = response.status });
                }
                else
                {
                    return Json(new { success = false, Response = response.status });
                }
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                return BadRequest();
            }
        }
        public async Task<IActionResult> ValidateOTP(EmailMessageDetailsVM model)
        {
            try
            {
                var response = await _account.ValidateOTP(model);
                if (response.messCode == 1)
                {
                    return Json(new { success = true, Response = response.status });
                }
                else
                {
                    return Json(new { success = false, Response = response.status });
                }
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                return Json(new { data = "No Data" });
            }

        }
        public async Task<IActionResult> ChangePassword(EmailMessageDetailsVM userViewModel)
        {
            try
            {
                var response = await _account.ChangePassword(userViewModel);

                if (response.messCode == 1)
                {
                    return Json(new { success = true, Response = response.status, ResponseMessage = response.Message });
                }
                else
                {
                    return Json(new { success = false, Response = response.status, ResponseMessage = response.Message });
                }
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                return Json(new { data = "No Data" });
            }
        }
        #endregion
        #region Users Management
        public async Task<IActionResult> PutPostUserAccess(UserRightsVM viewModel, List<UserRightsList> userRightsList)
        {
            var postPutItem = new UserRightsVM();
            try
            {
                if (userRightsList.Count > 0)
                {
                    viewModel.UserRightsList = new UserRightsList
                    {
                        UserAccessId = userRightsList.SelectMany(ic => ic.UserAccessId).ToList(),
                        ContAccId = userRightsList.SelectMany(ic => ic.ContAccId).ToList(),
                        AccessTypeId = userRightsList.SelectMany(ic => ic.AccessTypeId).ToList(),
                        IsActive = userRightsList.SelectMany(ic => ic.IsActive).ToList()
                    };
                    var cred = GetUser();
                    viewModel.AdminUserId = cred.UserId;
                    postPutItem = await _account.PutPostUserAccess(cred, viewModel);
                    if (postPutItem.messCode != 0)
                    {
                        return Json(new { success = true });
                    }
                }
                else
                {
                    return Json(new { success = false, response = "Please contact the administrator!" });
                }
                return Json(new { success = false, response = postPutItem.errMessage });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                return Json(new { success = false, response = postPutItem.errMessage });
            }
        }
        public async Task<IActionResult> UpdateUserProfile(RegisterVM viewModel)
        {
            try
            {
                if (!string.IsNullOrEmpty(viewModel.ProfilePictureStr))
                {
                    var attachment = CreateUpdateAttachment(viewModel.ProfilePictureStr);

                    switch (attachment.Result)
                    {
                        case "InValidFileSize":
                            return Json(new { success = false, Response = "Image maximum size is 2mb only!" });
                        case "UnsupportedImage":
                            return Json(new { success = false, Response = "Please choose supported image format 'jpg or png'!" });
                        case "UnsupportedFormat":
                            return Json(new { success = false, Response = "Please choose correct image format 'jpg or png'!" });

                        default:
                            break;
                    }

                    viewModel.Attachment = attachment;
                }

                viewModel.Password = viewModel.NewPassword;
                // var registerResponse = await _account.UpdateUserProfile(viewModel, newCred);
                var registerResponse = await _account.CreateUserAsync(viewModel, GetUser());
                if (registerResponse.statusResponse != "Error")
                {
                    return Json(new { success = true });
                }

                return Json(new { success = false, Response = registerResponse.message });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                
                throw;
            }
        }
        public async Task<IActionResult> GetUserProfileById()
        {
            try
            {
                var cred = GetUser();

                var response = await _account.GetUserProfileById(cred);

                if (response != null)
                {
                    return Json(new { data = response });
                }
                else
                {
                    return RedirectToAction("Logout", "Home");
                }
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                return BadRequest();
            }
        }
        public async Task<IActionResult> CreateAccount(RegisterVM register)
        {
            try
            {
                var registerResponse = await _account.CreateUserAsync(register, GetUser());
                if (registerResponse.statusResponse != "Error")
                {
                    return Json(new { success = true });
                }
                return Json(new { success = false, Response = registerResponse.message });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                
                throw;
            }
        }
        public async Task<IActionResult> GetAllUsers()
        {
            try
            {
                var userResponse = await _account.GetAllUserAsync(GetUser());
                return Json(new { data = userResponse });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                
                return Json(new { data = "No Data" }); // Return empty array instead of "No Data" string
            }
        }
        public async Task<IActionResult> GetDepartment()
        {
            var viewModels = new UserRightsVM();
            response = await _account.GetDepartment(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetRoles()
        {
            try
            {
                var response = await _account.GetRoles(GetUser());

                if (response != null)
                {
                    // return Json(new { data = response });
                    return new JsonResult(new { data = response });

                }
                else
                {
                    return RedirectToAction("Logout", "Home");
                }
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                
                return Json(new { data = "No Data" });
            }
        }
        public async Task<IActionResult> GetUserRights(UserRightsVM viewModels)
        {
            try
            {
                response = await _account.GetUserRights(GetUser(), viewModels);
                return GetResponse(response);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                
                return Json(new { data = "No Data" });
            }
        }
        #endregion
        #region Views
        public async Task<IActionResult> Index()
        {
            await  IsAuthenTicated();
            return View();
        }
        #endregion
    }
}