using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Mono.TextTemplating;
using Newtonsoft.Json;
using PSTW_CentralSystem.Areas.Inventory.Models;
using PSTW_CentralSystem.DBContext;
using PSTW_CentralSystem.Models;
using System.ComponentModel.Design;
using System.Data;
using System.Diagnostics;
using System.Reflection;
using static System.Collections.Specialized.BitVector32;

namespace PSTW_CentralSystem.Controllers.API.Inventory
{
    [ApiController]
    [Route("[controller]")]

    public class InvMainAPI : Controller
    {
        private readonly ILogger<InvMainAPI> _logger;
        private readonly CentralSystemContext _centralDbContext;
        private readonly UserManager<UserModel> _userManager;

        public InvMainAPI(ILogger<InvMainAPI> logger, CentralSystemContext centralDbContext, UserManager<UserModel> userManager)
        {
            _logger = logger;
            _centralDbContext = centralDbContext;
            _userManager = userManager;
        }

        public class DepartmentCompany
        {
            public int DepartmentId { get; set; }
            public string? DepartmentName { get; set; }
            public int CompanyId { get; set; }
            public string? CompanyName { get; set; }
            public string? DepartmentCode { get; set; }
        }

        public async Task<List<DepartmentCompany>> GetDepartmentWithCompanyList()
        {
            var departmentList = await _centralDbContext.Departments.ToListAsync();
            var companyList = await _centralDbContext.Companies.ToListAsync();

            // Create a new list to store departments with their company name
            var departmentWithCompanyList = departmentList.Select(department => new DepartmentCompany
            {
                DepartmentId = department.DepartmentId,
                DepartmentName = department.DepartmentName,
                CompanyId = department.CompanyId,
                CompanyName = companyList.FirstOrDefault(company => company.CompanyId == department.CompanyId)?.CompanyName
            }).ToList();

            // Return the constructed list as JSON
            return departmentWithCompanyList;
        }
        public async Task<DepartmentCompany> GetDepartmentWithCompany(int companyId, int departmentId)
        {
            var departmentList = await _centralDbContext.Departments.FirstOrDefaultAsync(d => d.DepartmentId == departmentId );
            var companyList = await _centralDbContext.Companies.FirstOrDefaultAsync(c => c.CompanyId == companyId);

            // Create a new list to store departments with their company name
            var departmentWithCompany = new DepartmentCompany
            {
                DepartmentId = departmentList!.DepartmentId,
                DepartmentName = departmentList.DepartmentName,
                CompanyId = departmentList.CompanyId,
                CompanyName = companyList?.CompanyName,
                DepartmentCode = departmentList.DepartmentCode,
            };

            // Return the constructed list as JSON
            return departmentWithCompany;
        }

        #region Manufacturer

        [HttpPost("ManufacturerList")]
        public async Task<IActionResult> ManufacturerList()
        {
            var manifacturerList = await _centralDbContext.Manufacturers.ToListAsync();
            return Json(manifacturerList);
        }

        [HttpPost("AddManufacturer")]
        public async Task<IActionResult> AddManufacturer([FromBody] ManufacturerModel manufacturer)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            try
            {
                _centralDbContext.Manufacturers.Add(new ManufacturerModel
                {
                    ManufacturerName = manufacturer.ManufacturerName,
                });
                await _centralDbContext.SaveChangesAsync();
                var updatedList = await _centralDbContext.Manufacturers.ToListAsync();
                return Json(updatedList);
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }

        [HttpDelete("DeleteManufacturer/{id}")]
        public async Task<IActionResult> DeleteManufacturer(int id)
        {
            var manufacturer = await _centralDbContext.Manufacturers.FindAsync(id);
            if (manufacturer == null)
            {
                return NotFound(new { success = false, message = "Manufacturer not found" });
            }

            _centralDbContext.Manufacturers.Remove(manufacturer);
            await _centralDbContext.SaveChangesAsync();

            return Ok(new { success = true, message = "Manufacturer deleted successfully" });
        }

        #endregion Manufacturer

        #region Product

        [HttpPost("ProductList")]
        public async Task<IActionResult> ProductList()
        {
            var productList = await _centralDbContext.Products.Include("Manufacturer").ToListAsync();
            return Json(productList);
        }

        [HttpPost("ProductListWithItem")]
        public async Task<IActionResult> ProductListWithItem()
        {
            var productList = await _centralDbContext.Products
                .Include(p => p.Items) // Include related items
                .Include(p => p.Manufacturer) // Include related manufacturer
                .ToListAsync();

            return Json(productList);
        }


        [HttpPost("AddProduct")]
        public async Task<IActionResult> AddProduct([FromBody] ProductModel product)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            if (product == null)
            {
                return NotFound("Product is null");
            }

            try
            {
                product.QuantityProduct = 0;
                var productImage = product.ImageProduct; // Save image to wwwroot/media/inventory/images | Images name is product.ModelNo | product.ImageProduct is in base64 string
                if (!string.IsNullOrEmpty(product.ImageProduct))
                {
                    var bytes = Convert.FromBase64String(product.ImageProduct);
                    var filePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot/media/inventory/images", product.ModelNo + ".jpg");
                    await System.IO.File.WriteAllBytesAsync(filePath, bytes);
                    product.ImageProduct = "/media/inventory/images/" + product.ModelNo + ".jpg";
                }
                _centralDbContext.Products.Add(product);
                await _centralDbContext.SaveChangesAsync();
                var updatedList = await _centralDbContext.Products.Include("Manufacturer").Where(x => x.ManufacturerId == x.ManufacturerId).ToListAsync();
                return Json(updatedList);
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }

        [HttpDelete("DeleteProduct/{id}")]
        public async Task<IActionResult> DeleteProduct(int id)
        {
            var Product = await _centralDbContext.Products.FindAsync(id);
            if (Product == null)
            {
                return NotFound(new { success = false, message = "Product not found" });
            }

            _centralDbContext.Products.Remove(Product);
            await _centralDbContext.SaveChangesAsync();

            return Ok(new { success = true, message = "Product deleted successfully" });
        }

        #endregion Product

        #region Supplier

        [HttpPost("SupplierList")]
        public async Task<IActionResult> SupplierList()
        {
            var supplierList = await _centralDbContext.Suppliers.ToListAsync();
            return Json(supplierList);
        }

        [HttpPost("AddSupplier")]
        public async Task<IActionResult> AddSupplier([FromBody] SupplierModel supplier)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            try
            {
                _centralDbContext.Suppliers.Add(supplier);
                await _centralDbContext.SaveChangesAsync();
                var updatedList = await _centralDbContext.Suppliers.ToListAsync();
                return Json(updatedList);
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }

        [HttpDelete("DeleteSupplier/{id}")]
        public async Task<IActionResult> DeleteSupplier(int id)
        {
            var supplier = await _centralDbContext.Suppliers.FindAsync(id);
            if (supplier == null)
            {
                return NotFound(new { success = false, message = "Supplier not found" });
            }

            _centralDbContext.Suppliers.Remove(supplier);
            await _centralDbContext.SaveChangesAsync();

            return Ok(new { success = true, message = "Supplier deleted successfully" });
        }
        #endregion Supplier

        #region Item

        [HttpPost("ItemList")]
        public async Task<IActionResult> ItemList()
        {
            try
            {
                var user = await _userManager.GetUserAsync(User);
                if (user == null)
                {
                    return BadRequest("User not found");
                }
                else
                {
                    user.departmentId = user.departmentId != null ? user.departmentId : 0;
                }

                var userRole = await _userManager.GetRolesAsync(user);
                var isAdmin = userRole.Contains("SystemAdmin") || userRole.Contains("SuperAdmin") || userRole.Contains("Finance");
                List<ItemModel> itemList = new List<ItemModel>();
                // Get the item list
                if (isAdmin)
                {
                    itemList = await _centralDbContext.Items
                        .AsNoTracking()
                        .Include("CreatedBy")
                        .Include("Department")
                        .Include("Product")
                        .Include(i => i.Movement)
                        .ThenInclude(m => m!.FromStore)
                        .Include(i => i.Movement)
                        .ThenInclude(m => m!.FromStation)
                        .Include(i => i.Movement)
                        .ThenInclude(m => m!.FromUser)
                        .ToListAsync();
                }
                else
                {
                    itemList = await _centralDbContext.Items
                        .AsNoTracking()
                        .Include("CreatedBy")
                        .Include("Department")
                        .Include("Product")
                        .Include(i => i.Movement)
                        .ThenInclude(m => m!.FromStore)
                        .Include(i => i.Movement)
                        .ThenInclude(m => m!.FromStation)
                        .Include(i => i.Movement)
                        .ThenInclude(m => m!.FromUser)
                        .Where(i => i.DepartmentId == user.departmentId)
                        .ToListAsync();
                }

                // Get the departments list (DepartmentId references Departments)
                var departments = await _centralDbContext.Departments.ToListAsync();

                // Now join items with users and departments manually
                var itemListWithDetails = itemList.Select(item => new
                {
                    item.ItemID,
                    item.UniqueID,
                    item.CompanyId,
                    item.DepartmentId,
                    item.ProductId,
                    item.SerialNumber,
                    item.Quantity,
                    item.Supplier,
                    PurchaseDate = item.PurchaseDate.ToString("dd/MM/yyyy"),
                    item.PONo,
                    item.Currency,
                    item.DefaultPrice,
                    item.CurrencyRate,
                    item.ConvertPrice,
                    item.DODate,
                    item.Warranty,
                    item.PartNumber,
                    EndWDate = item.EndWDate.ToString("dd/MM/yyyy"),
                    InvoiceDate = item.InvoiceDate?.ToString("dd/MM/yyyy"),
                    item.Department?.DepartmentName,
                    CreatedBy=item.CreatedBy!.UserName,
                    item.Product!.ProductName,
                    item.Product!.ProductShortName,
                    item.Product!.Category,
                    //CurrentUser = item.Movement?.FromUser?.UserName,
                    CurrentUser = item.Movement?.FromUser?.UserName,
                    CurrentStore = item.Movement?.FromStore?.StoreName,
                    CurrentStation = item.Movement?.FromStation?.StationName,

                    QRString = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.Value}/I/{item.UniqueID}" // Generate QR String
                }).ToList();

                return Json(itemListWithDetails);
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }

        [HttpPost("GenerateItemQr/{id}")]
        public IActionResult GenerateItemQr(string id)
        {
            // Retrieve the request's host and scheme
            var request = HttpContext.Request;
            string domain = $"{request.Scheme}://{request.Host.Value}";

            // Append the QR path and item ID
            string QRString = $"{domain}/Inventory/ItemInformation/{id}";
            return Json(QRString);
        }

        [HttpPost("AddItem")]
        public async Task<IActionResult> AddItem([FromBody] ItemModel item)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            try
            {
                var product = await _centralDbContext.Products.FirstOrDefaultAsync(p => p.ProductId == item.ProductId) ?? throw new Exception("Product not found");
                var inventoryMaster = await _centralDbContext.InventoryMasters.Include("User").FirstOrDefaultAsync(i => i.UserId == item.CreatedByUserId) ?? new InventoryMasterModel{ UserId = item.CreatedByUserId };
                var addToProduct = item.Quantity;
                product.QuantityProduct += addToProduct;

                if (product.Category == "Disposable")
                {
                    item.SerialNumber = null;
                }

                _centralDbContext.Items.Add(item);
                _centralDbContext.Products.Update(product);

                await _centralDbContext.SaveChangesAsync(); // This generates the auto-incremented ItemID


                ItemMovementModel itemMovement = new ItemMovementModel
                {
                    ItemId = item.ItemID,
                    ToUser = inventoryMaster.UserId,
                    ToStore = inventoryMaster.StoreId,
                    LastStore = inventoryMaster.StoreId,
                    LastUser = inventoryMaster.UserId,
                    LatestStatus = "Ready To Deploy",
                    Quantity = item.Quantity,
                    Action= "Register",
                    Date = DateTime.Now,
                    MovementComplete = true,
                };

                _centralDbContext.ItemMovements.Add(itemMovement);
                await _centralDbContext.SaveChangesAsync();

                // Fetch the generated ItemID
                var savedItem = await _centralDbContext.Items.FirstOrDefaultAsync(i => i.ItemID == item.ItemID);
                // Fetch the generated itemMovement
                var savedMovement = await _centralDbContext.ItemMovements.FirstOrDefaultAsync(i => i.Id == itemMovement.Id);

                if (savedItem != null)
                {
                    var companyDepartment = await GetDepartmentWithCompany(item.CompanyId, item.DepartmentId);
                    var itemProduct = _centralDbContext.Products.Where(p => p.ProductId == item.ProductId).FirstOrDefault();

                    string? companyInitial = companyDepartment!.CompanyName?.ToString().Substring(0, 1).ToUpper();
                    string? departmentInitial = companyDepartment!.DepartmentName?.ToString().Substring(0, 1).ToUpper();
                    string? deptCode = companyDepartment!.DepartmentCode?.ToString();
                    char? initialCategory = itemProduct!.Category.ToString().Substring(0, 1).ToUpper().FirstOrDefault();
                    string? productId = itemProduct!.ProductId.ToString("D3");
                    string? itemId = item.ItemID.ToString("D5");
                    var uniqueId = $"{deptCode}{initialCategory}{productId}{itemId}".ToUpper();
                    savedItem.UniqueID = uniqueId;
                    savedItem.MovementId = savedMovement?.Id;

                    _centralDbContext.Items.Update(savedItem);
                    await _centralDbContext.SaveChangesAsync();
                }

                var updatedItem = new 
                {
                    savedItem!.ItemID,
                    savedItem.UniqueID,
                    savedItem.CompanyId,
                    savedItem.DepartmentId,
                    savedItem.ProductId,
                    savedItem.SerialNumber,
                    savedItem.Quantity,
                    savedItem.Supplier,
                    savedItem.PurchaseDate,
                    savedItem.PONo,
                    savedItem.Currency,
                    savedItem.DefaultPrice,
                    savedItem.CurrencyRate,
                    savedItem.ConvertPrice,
                    savedItem.DODate,
                    savedItem.Warranty,
                    savedItem.EndWDate,
                    savedItem.InvoiceDate,
                    savedItem.PartNumber,
                };
                return Json(updatedItem);
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }

        [HttpDelete("DeleteItem/{id}")]
        public async Task<IActionResult> DeleteItem(int id)
        {
            var item = await _centralDbContext.Items.FindAsync(id);
            if (item == null)
            {
                return NotFound(new { success = false, message = "Item not found" });
            }

            _centralDbContext.Items.Remove(item);
            await _centralDbContext.SaveChangesAsync();

            return Ok(new { success = true, message = "Item deleted successfully" });
        }

        [HttpPost("GetItem/{id}")] // Endpoint to retrieve an item by its ID
        public async Task<IActionResult> GetItem(string id)
        {
            var item = await _centralDbContext.Items
                        .Include("CreatedBy")
                        .Include("Department")
                        .Include("Product")
                        .Include(i => i.Movement)
                        .ThenInclude(m => m!.FromStore)
                        .Include(i => i.Movement)
                        .ThenInclude(m => m!.FromStation)
                        .Include(i => i.Movement)
                        .ThenInclude(m => m!.FromUser).FirstOrDefaultAsync(i => i.UniqueID == id);
            if (item == null){
                return NotFound(new { success = false, message = "Item not found" });
            }
            var singleItem = new
            {
                item.ItemID,
                item.UniqueID,
                item.CompanyId,
                item.DepartmentId,
                item.ProductId,
                item.SerialNumber,
                item.Quantity,
                item.Supplier,
                PurchaseDate = item.PurchaseDate.ToString("dd/MM/yyyy"),
                item.PONo,
                item.Currency,
                item.DefaultPrice,
                item.CurrencyRate,
                item.ConvertPrice,
                item.DODate,
                item.Warranty,
                item.PartNumber,
                EndWDate = item.EndWDate.ToString("dd/MM/yyyy"),
                InvoiceDate = item.InvoiceDate?.ToString("dd/MM/yyyy"),
                item.Department?.DepartmentName,
                item.CreatedBy!.UserName,
                item.Product!.ProductName,
                item.Product!.ProductShortName,
                item.Product!.ImageProduct,
                CurrentUser = item.Movement?.FromUser?.UserName,
                CurrentStore = item.Movement?.FromStore?.StoreName,
                CurrentStation = item.Movement?.FromStation?.StationName,
                QRString = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.Value}/I/{item.UniqueID}" // Generate QR String
            };
            return Json(singleItem);
        }

        #endregion Item

        #region ItemMovement

        [HttpPost("ItemMovementList")]
        public async Task<IActionResult> ItemMovementList()
        {

            var itemMovementList = await _centralDbContext.ItemMovements.ToListAsync();
            Console.WriteLine(Json(itemMovementList));
            return Json(itemMovementList);


            //try
            //{
            //    var user = await _userManager.GetUserAsync(User);
            //    if (user == null)
            //    {
            //        return BadRequest("User not found");
            //    }
            //    else
            //    {
            //        user.departmentId = user.departmentId != null ? user.departmentId : 0;
            //    }

            //    var userRole = await _userManager.GetRolesAsync(user);
            //    var isAdmin = userRole.Contains("SystemAdmin") || userRole.Contains("SuperAdmin") || userRole.Contains("Finance");
            //    List<ItemModel> itemList = new List<ItemModel>();
            //    // Get the item list
            //    if (isAdmin)
            //    {
            //        itemList = await _centralDbContext.Items
            //            .AsNoTracking()
            //            .Include("CreatedBy")
            //            .Include("Department")
            //            .Include("Product")
            //            .Include(i => i.Movement)
            //            .ThenInclude(m => m!.FromStore)
            //            .Include(i => i.Movement)
            //            .ThenInclude(m => m!.FromStation)
            //            .Include(i => i.Movement)
            //            .ThenInclude(m => m!.FromUser)
            //            .ToListAsync();
            //    }
            //    else
            //    {
            //        itemList = await _centralDbContext.Items
            //            .AsNoTracking()
            //            .Include("CreatedBy")
            //            .Include("Department")
            //            .Include("Product")
            //            .Include(i => i.Movement)
            //            .ThenInclude(m => m!.FromStore)
            //            .Include(i => i.Movement)
            //            .ThenInclude(m => m!.FromStation)
            //            .Include(i => i.Movement)
            //            .ThenInclude(m => m!.FromUser)
            //            .Where(i => i.DepartmentId == user.departmentId)
            //            .ToListAsync();
            //    }

            //    // Get the departments list (DepartmentId references Departments)
            //    var departments = await _centralDbContext.Departments.ToListAsync();

            //    // Now join items with users and departments manually
            //    var itemListWithDetails = itemList.Select(item => new
            //    {
            //        item.ItemID,
            //        item.UniqueID,
            //        item.CompanyId,
            //        item.DepartmentId,
            //        item.ProductId,
            //        item.SerialNumber,
            //        item.Quantity,
            //        item.Supplier,
            //        PurchaseDate = item.PurchaseDate.ToString("dd/MM/yyyy"),
            //        item.PONo,
            //        item.Currency,
            //        item.DefaultPrice,
            //        item.CurrencyRate,
            //        item.ConvertPrice,
            //        item.DODate,
            //        item.Warranty,
            //        item.PartNumber,
            //        EndWDate = item.EndWDate.ToString("dd/MM/yyyy"),
            //        InvoiceDate = item.InvoiceDate?.ToString("dd/MM/yyyy"),
            //        item.Department?.DepartmentName,
            //        CreatedBy = item.CreatedBy!.UserName,
            //        item.Product!.ProductName,
            //        item.Product!.ProductShortName,
            //        item.Product!.Category,
            //        //CurrentUser = item.Movement?.FromUser?.UserName,
            //        CurrentUser = item.Movement?.FromUser?.UserName,
            //        CurrentStore = item.Movement?.FromStore?.StoreName,
            //        CurrentStation = item.Movement?.FromStation?.StationName,

            //        QRString = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.Value}/I/{item.UniqueID}" // Generate QR String
            //    }).ToList();

            //    return Json(itemListWithDetails);
            //}
            //catch (Exception ex)
            //{
            //    return BadRequest(ex.Message);
            //}


        }

        #endregion ItemMovement

        #region ItemRequestUser

        [HttpPost("AddRequest")]
        public async Task<IActionResult> AddRequest([FromBody] RequestModel request, [FromQuery] int UserId)

        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            try
            {
                _centralDbContext.Requests.Add(request);
                await _centralDbContext.SaveChangesAsync();

                //ini akan paparkan user punya table sahaja.

                var updatedList = await _centralDbContext.Requests.Where(r => r.UserId == UserId).ToListAsync();

                return Json(updatedList);
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }

        [HttpGet("ItemRequestListEachUser/{id}")]
        public async Task<IActionResult> ItemRequestListEachUser(int UserId)
        {

            var itemRequestList = await _centralDbContext.Requests.Where(r => r.UserId == UserId).ToListAsync();

            return Json(itemRequestList);

        }

        [HttpDelete("DeleteRequest/{id}")]
        public async Task<IActionResult> DeleteRequest(int id)
        {
            var request = await _centralDbContext.Requests.FindAsync(id);
            if (request == null)
            {
                return NotFound(new { success = false, message = "Request not found" });
            }

            _centralDbContext.Requests.Remove(request);
            await _centralDbContext.SaveChangesAsync();

            return Ok(new { success = true, message = "Request deleted successfully" });
        }

        #endregion

        #region ItemRequestAdmin
        [HttpGet("ItemRequestList")]
        public async Task<IActionResult> ItemRequestList()
        {

            var itemRequestList = await _centralDbContext.Requests.ToListAsync();
            return Json(itemRequestList);

        }

        [HttpPost("ApproveRequest/{id}")]
        public async Task<IActionResult> ApproveRequest(int id)
        {
            var Request = await _centralDbContext.Requests.FindAsync(id);
            if (Request == null)
            {
                return NotFound(new { success = false, message = "Request not found" });
            }

            Request.status = "Approved";
            Request.approvalDate = DateTime.UtcNow;
            _centralDbContext.SaveChanges();

            return Ok(new { success = true, message = "Request Approved Successfully", data = Request });
        }

        [HttpPost("RejectRequest/{id}")]
        public async Task<IActionResult> RejectRequest(int id)
        {
            var Request = await _centralDbContext.Requests.FindAsync(id);
            if (Request == null)
            {
                return NotFound(new { success = false, message = "Request not found" });
            }

            Request.status = "Rejected";
            Request.approvalDate = DateTime.UtcNow;
            _centralDbContext.SaveChanges();

            return Ok(new { success = true, message="Request Rejected Successfully", data=Request });
        }

        #endregion ItemRequestAdmin

        #region ItemReport

        [HttpPost("GetInventoryReport/{deptId}")]
        public async Task<IActionResult> GetInventoryReport(int deptId)
        {
            try{
                var user = await _userManager.GetUserAsync(User);

                var userRole = await _userManager.GetRolesAsync(user ?? new UserModel());
                List<ItemModel> items = new List<ItemModel>();
                if (userRole.Contains("SuperAdmin") && userRole.Contains("SystemAdmin")) 
                {
                    items = await _centralDbContext.Items
                    .Include("CreatedBy")
                    .Include("Department")
                    .Include("Product")
                    .ToListAsync();
                }
                else
                {
                    items = await _centralDbContext.Items
                    .Include("CreatedBy")
                    .Include("Department")
                    .Include("Product")
                    .Where(i => i.DepartmentId == deptId)
                    .ToListAsync();
                }
                var itemListWithDetails = items.Where(i => i.Quantity > 0).Select(item => new
                {
                    item.ItemID,
                    item.UniqueID,
                    item.CompanyId,
                    item.DepartmentId,
                    item.ProductId,
                    item.SerialNumber,
                    item.Quantity,
                    item.Supplier,
                    PurchaseDate = item.PurchaseDate.ToString("dd/MM/yyyy"),
                    item.PONo,
                    item.Currency,
                    item.DefaultPrice,
                    item.CurrencyRate,
                    item.ConvertPrice,
                    item.DODate,
                    item.Warranty,
                    EndWDate = item.EndWDate.ToString("dd/MM/yyyy"),
                    InvoiceDate = item.InvoiceDate?.ToString("dd/MM/yyyy"),
                    item.Department?.DepartmentName,
                    CreatedBy = item.CreatedBy!.UserName,
                    item.Product!.ProductName,
                    item.Product!.ProductShortName,
                    item.Product!.Category,
                    //CurrentUser = item.Movement?.FromUser?.UserName,
                    CurrentUser = item.Movement?.FromUser?.UserName,
                    CurrentStore = item.Movement?.FromStore?.StoreName,
                    CurrentStation = item.Movement?.FromStation?.StationName,

                    QRString = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.Value}/I/{item.UniqueID}" // Generate QR String
                }).ToList();

                int itemCountRegistered = items.Count;
                int itemCountStillInStock = items.Where(i => i.Quantity > 0).Count();
                var itemsMovementsThisMonth = _centralDbContext.ItemMovements
                .Where(i => i.Date.Month == DateTime.Now.Month);
                int itemCountRegisteredThisMonth = itemsMovementsThisMonth.Count(i => i.Action == "Register");
                int itemCountStockOutThisMonth = itemsMovementsThisMonth.Count(i => i.Action == "Stock Out");

                var lastMonth = DateTime.Now.AddMonths(-1).Month;
                var itemsMovementsLastMonth = _centralDbContext.ItemMovements
                .Where(i => i.Date.Month == lastMonth);
                int itemCountRegisteredLastMonth = itemsMovementsLastMonth.Count(i => i.Action == "Register");
                int itemCountStockOutLastMonth = itemsMovementsLastMonth.Count(i => i.Action == "Stock Out");

                var report = new
                {
                    itemListWithDetails,
                    itemCountRegistered,
                    itemCountStillInStock,
                    itemCountRegisteredThisMonth,
                    itemCountStockOutThisMonth,
                    itemCountRegisteredLastMonth,
                    itemCountStockOutLastMonth
                };
                return Json(report);
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }

        #endregion

        #region Station
        [HttpPost("StationList")]
        public async Task<IActionResult> StationList()
        {
            var stationList = await _centralDbContext.Stations.ToListAsync();
            return Json(stationList);
        }

        [HttpPost("AddStation")]
        public async Task<IActionResult> AddStation([FromBody] StationModel station)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            try
            {
                _centralDbContext.Stations.Add(station);
                await _centralDbContext.SaveChangesAsync();
                var updatedList = await _centralDbContext.Stations.ToListAsync();
                return Json(updatedList);
            }
            catch (Exception ex)
            {
                return BadRequest(ex.Message);
            }
        }

        [HttpDelete("DeleteStation/{id}")]
        public async Task<IActionResult> DeleteStation(int id)
        {
            var station = await _centralDbContext.Stations.FindAsync(id);
            if (station == null)
            {
                return NotFound(new { success = false, message = "Station not found" });
            }

            _centralDbContext.Stations.Remove(station);
            await _centralDbContext.SaveChangesAsync();

            return Ok(new { success = true, message = "Station deleted successfully" });
        }
        #endregion Station

        #region Store

        [HttpPost("StoreList")]
        public async Task<IActionResult> StoreList()
        {
            var storeList = await _centralDbContext.Stores.ToListAsync();
            return Json(storeList);
        }


        #endregion Store

        #region AllUser

        [HttpPost("UserList")]
        public async Task<IActionResult> UserList()
        {
            var userList = await _centralDbContext.Users.ToListAsync();
            return Json(userList);
        }


        #endregion AllUser
    }
}