using Azure;
using CPRNIMS.Domain.Services;
using CPRNIMS.Domain.UIContracts.Items;
using CPRNIMS.Domain.UIServices.Updater;
using CPRNIMS.Infrastructure.Dto.Items;
using CPRNIMS.Infrastructure.Entities.Items;
using CPRNIMS.Infrastructure.Helper;
using CPRNIMS.Infrastructure.Models.Account;
using CPRNIMS.Infrastructure.ViewModel.Account;
using CPRNIMS.Infrastructure.ViewModel.Items;
using CPRNIMS.WebApps.Controllers.Base;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Drive.v3;
using Google.Apis.Drive.v3.Data;
using Google.Apis.Services;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.SignalR;
using System.Collections.Generic;

namespace CPRNIMS.WebApps.Controllers.Items
{
    public class ItemMgmtController : BaseMethod
    {
        private readonly IItem _item;
        List<ItemVM>? response;
        ItemVM? postPutItem;
        private readonly IConfiguration _config;
        private readonly IHubContext<CartHub> _hubContext;
        public ItemMgmtController(ErrorLogHelper errorMessageService,
            IWebHostEnvironment webHostEnvironment, IConfiguration config, TokenHelper tokenHelper,
            IItem item, IHubContext<CartHub> hubContext)
            : base(errorMessageService, webHostEnvironment,tokenHelper)
        {
            _item = item;
            _config = config;
            _hubContext = hubContext;
        }
        #region PutPost  
        public async Task<IActionResult> PostPutItemCart(ItemVM viewModel)
        {
            try
            {
                var postPutItem = await _item.PostPutItemCart(GetUser(), viewModel);
                int count = await UpdateCart(viewModel);
                await _hubContext.Clients.User(viewModel.UserId).SendAsync("ReceiveCartUpdate", count);

                if (postPutItem.messCode != 0)
                {
                    return Json(new { success = true, cartCount = count });
                }
                return Json(new { success = false, Response = postPutItem.message });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                
                throw;
            }
        }
        public async Task<int> UpdateCart(ItemVM viewModel)
        {
            viewModel.IsCount = true;
            int count=0;
            var itemCartResp = await _item.GetItemCart(GetUser(), viewModel);
            if (itemCartResp.Count <= 0)
            {
                ViewBag.CartItemCount = 0;
            }
            else
            {
                ViewBag.CartItemCount = itemCartResp[0].CartItemCount;
                count = itemCartResp[0].CartItemCount;
            }
            return count;
        }
        public async Task<IActionResult> PutItemDetail(ItemVM viewModel)
        {
            try
            {
                string base64Image;

                if (viewModel.ItemAttachPath==null)
                {
                    var defaultImagePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "Content", "Common", "empty.jpg");
                    byte[] imageBytes = await System.IO.File.ReadAllBytesAsync(defaultImagePath);
                    string imageBase64 = Convert.ToBase64String(imageBytes);
                    base64Image = $"data:image/jpeg;base64,{imageBase64}";
                }
                else
                {
                    base64Image = viewModel.ItemAttachPath;
                }
                var (uploadResult,isSuccess) = await UploadBase64Image(base64Image);
                if (isSuccess) {
                    viewModel.ItemAttachPath = uploadResult;

                    postPutItem = await _item.PutItemDetail(GetUser(), viewModel);

                    if (postPutItem.messCode != 0)
                    {
                        return Json(new { success = true, data = postPutItem });
                    }

                }
                return Json(new { success = false, response = uploadResult ?? postPutItem.statusResponse });
            }
            catch (Exception ex)
            {
                return Json(new { success = false, response = "An error occurred.", details = ex.Message });
            }
        }

        public async Task<IActionResult> PostPutItem(ItemVM viewModel)
        {
            try
            {
                var postPutItem = await _item.PostPutItem(GetUser(), viewModel);

                if (postPutItem.messCode != 0)
                {
                    return Json(new
                    {
                        success = true,
                        data = postPutItem,
                        itemCodeId = postPutItem.ItemCodeId 
                    });
                }

                return Json(new { success = false, response = postPutItem.message });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                throw;
            }
        }

        [HttpPost]
        public async Task<IActionResult> PostPurchRequest(ItemVM viewModel,List<ItemCartVM> ItemCartIds)
        {
            try
            {
                viewModel.ItemCartVM = new ItemCartVM
                {
                    ItemCartId = ItemCartIds.SelectMany(ic => ic.ItemCartId).ToList(),
                    Qty = ItemCartIds.SelectMany(ic => ic.Qty).ToList(),
                    ItemNo = ItemCartIds.SelectMany(ic => ic.ItemNo).ToList()
                };
                var postPutItem = await _item.PostPurchRequest(GetUser(), viewModel);

                if (postPutItem.statusResponse != "Error")
                {
                    return Json(new { success = true });
                }

                return Json(new { success = false, Response = postPutItem.message });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                
                throw;
            }
        }
        #endregion

        #region Get
        public async Task<IActionResult> GetImageFileIds()
        {
            try
            {
                var fileIds = new List<string>();
                var googleDriveService = new GoogleDriveService("secret");
                fileIds.Add(await googleDriveService.GetFileIdByNameAsync("1.jpg"));
                fileIds.Add(await googleDriveService.GetFileIdByNameAsync("2.jpg"));
                fileIds.Add(await googleDriveService.GetFileIdByNameAsync("3.jpg"));
                return Json(fileIds);
            }
            catch (Exception ex)
            {
                // Handle exception
                return BadRequest(ex.Message);
            }
        }
        public IActionResult GetImage(string url)
        {
            return Redirect(url);
        }
        public async Task<IActionResult> GetItemDetail(ItemVM viewModels)
        {
            try
            {
                response = await _item.GetItemDetail(GetUser(), viewModels);
                response[0].URL = _config["CommonEndpoints:ApiDefaultHeaders:ItemImages"];
                return GetResponse(response);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                
                throw;
            }
        }
        public async Task<IActionResult> GetItemCart(ItemVM viewModels)
        {
            try
            {
                response = await _item.GetItemCart(GetUser(), viewModels);
                return GetResponse(response);
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                
                throw;
            }
        }
        public async Task<IActionResult> GetItemList()
        {
            var viewModels = new ItemVM();
            response = await _item.GetItemList(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetItemCateg(ItemVM viewModels)
        {

            try
            {
                var responseQuery = await _item.GetItemCateg(GetUser(), viewModels);

                if (responseQuery == null)
                {
                    responseQuery = new List<ItemVM>();
                }

                return Json(new { success = true, data = responseQuery });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                throw;
            }
        }
        public async Task<IActionResult> GetItemColor(string query)
        {
            try
            {
                var viewModels = new ItemVM();
                viewModels.ItemColorName = query;
                var responseQuery = await _item.GetItemColor(GetUser(), viewModels);

                if (responseQuery == null)
                {
                    responseQuery = new List<ItemVM>();
                }

                // Convert the data to the format expected by jQuery UI Autocomplete
                var formattedData = responseQuery.Select(item => new
                {
                    label = item.ItemColorName,
                    value = item.ItemColorId,
                });

                return Json(new { success = true, data = formattedData });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                throw;
            }
        }
        public async Task<IActionResult> GetItemLocalization(string query)
        {
            try
            {
                var viewModels = new ItemVM();
                viewModels.ItemLocalName = query;
                var responseQuery = await _item.GetItemLocalization(GetUser(), viewModels);

                if (responseQuery == null)
                {
                    responseQuery = new List<ItemVM>();
                }

                // Convert the data to the format expected by jQuery UI Autocomplete
                var formattedData = responseQuery.Select(item => new
                {
                    label = item.ItemLocalName,
                    value = item.ItemLocalId,
                });

                return Json(new { success = true, data = formattedData });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                throw;
            }
        }
        public async Task<IActionResult> GetItemUOM(string query)
        {
            try
            {
                var viewModels = new ItemVM();
                viewModels.UOMName = query;
                var responseQuery = await _item.GetItemUOM(GetUser(), viewModels);

                if (responseQuery == null)
                {
                    responseQuery = new List<ItemVM>();
                }

                var formattedData = responseQuery.Select(item => new
                {
                    label = item.UOMName,
                    value = item.UOMId,
                });

                return Json(new { success = true, data = formattedData });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                throw;
            }
        }
        public async Task<IActionResult> GetDepartment()
        {
            try
            {
                var viewModels = new ItemVM();
                var responseQuery = await _item.GetDepartment(GetUser(), viewModels);

                if (responseQuery == null)
                {
                    responseQuery = new List<ItemVM>();
                }

                return Json(new { success = true, data = responseQuery });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                throw;
            }
        }
        #endregion
        #region Views
        public async Task<IActionResult> Index()
        {
            var viewModels = new ItemVM();
            await IsAuthenTicated();
            await UpdateCart(viewModels);

            return View();
        }
        public async Task<IActionResult> ItemCart(byte TypeOfRequest)
        {
            var viewModels = new ItemVM();
            await IsAuthenTicated();
            ViewBag.TypeOfRequest = TypeOfRequest;
            return View();
        }
        #endregion
        #region Common
        public async Task<(string,bool)> UploadBase64Image(string base64Image)
        {
            try
            {
                // Extract image format from base64 string
                var base64Data = base64Image.Substring(base64Image.IndexOf(',') + 1);
                var imageFormat = base64Image.Substring(base64Image.IndexOf('/') + 1, base64Image.IndexOf(';') - base64Image.IndexOf('/') - 1);

                // Check image format
                if (imageFormat.ToLowerInvariant() != "jpeg" && imageFormat.ToLowerInvariant() != "jpg" && imageFormat.ToLowerInvariant() != "png")
                {
                    return ("Only JPG and PNG images are allowed.", false);
                }
        
                // Decode base64 string to byte array
                byte[] imageBytes;
                try
                {
                    imageBytes = Convert.FromBase64String(base64Data);
                }
                catch (FormatException)
                {
                    return ("Invalid Base64 data.", false);
                }
                // Check byte array size (8MB limit)
                const int maxFileSizeInBytes = 8 * 1024 * 1024; // 8 MB
                if (imageBytes.Length > maxFileSizeInBytes)
                {
                    return ("Exceed 8MB.",false);
                }

                // Save the decoded byte array to the shared folder
                var serverPath = _config["LLI:NonInvent:ImageUploadSettings:UploadPath"];
                var fileName = Guid.NewGuid().ToString() + "." + imageFormat; 
                var filePath = Path.Combine(serverPath, fileName); 

                await System.IO.File.WriteAllBytesAsync(filePath, imageBytes);

                return (fileName,true);
            }
            catch (Exception ex)
            {
                // Handle exception
                Console.WriteLine(ex.ToString());
                throw;
            }
        }
        public async Task<IActionResult> UploadMultipleFile(List<IFormFile> files,long itemNo)
        {
            try
            {
                foreach (var file in files)
                {
                    // Check file size
                    if (file.Length > 2 * 1024 * 1024) // 2MB limit
                    {
                        return Json(new { success = false, Response = "File size should not exceed 2MB." });
                    }

                    // Check file extension
                    var fileExtension = Path.GetExtension(file.FileName).ToLowerInvariant();
                    if (fileExtension != ".jpg" && fileExtension != ".png")
                    {
                        return Json(new { success = false, Response = "Only JPG and PNG files are allowed." });
                    }

                    // Save the uploaded file to the shared folder
                    var serverPath = "\\\\172.16.16.215\\NonInventory"; // Shared folder path
                    var fileName = Guid.NewGuid().ToString() + fileExtension; // Generate unique file name
                    var filePath = Path.Combine(serverPath, fileName); // Combine path and file name

                    using (var stream = new FileStream(filePath, FileMode.Create))
                    {
                        await file.CopyToAsync(stream);
                    }

                    return Json(new { success = true });
                }

                return Json(new { success = true });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                return Json(new { success = false, Response ="There is something wrong, please ask administrator!" });
            }
        }

        #endregion
        #region Commented
        //private  DriveService _driveService;
        //public async Task<IActionResult> Index()
        //{
        //    var filePath = "D:\\sourcecode\\test.txt";
        //    var fileName = Path.GetFileName(filePath);
        //    var mimeType = "text/plain"; // Assuming the file is a text file

        //    try
        //    {
        //        GoogleCredential credential = GoogleCredential.FromFile("path/to/service-account-key.json")
        //         .CreateScoped(DriveService.ScopeConstants.Drive);

        //        // Create the Drive service using the service account credential
        //        _driveService = new DriveService(new BaseClientService.Initializer
        //        {
        //            HttpClientInitializer = credential,
        //            ApplicationName = "Your Application Name"
        //        });
        //    }
        //    catch (Exception ex)
        //    {
        //        // Log the error or handle it appropriately
        //        // For example, you can throw an exception or set _driveService to null
        //        _driveService = null;
        //    }
        //    return View();
        //}
        #endregion
    }
}