api/resources/Stock/StockController.js

import mongoose from "mongoose";
import { PDStock } from "./PdStockModel.js";
import { Product } from "../Products/ProductModel.js";
import { RDStock } from "./RdStockModel.js";

export const getProductsAndStockByPD = async (req, res) => {
  try {
    const userId = req.params.userId || req.user._id;

    // Pagination parameters
    const PAGE_SIZE = parseInt(req.query.show) || 10;
    const page = parseInt(req.query.page) || 1;
    const skip = (page - 1) * PAGE_SIZE;

    // Filtering criteria
    const filter = {};
    if (req.query.name) {
      filter.name = {
        $regex: new RegExp(req.query.name, "i"),
      };
    }
    if (req.query.category) {
      filter.category = mongoose.Types.ObjectId(req.query.category);
    }
    if (req.query.brand) {
      filter.brand = mongoose.Types.ObjectId(req.query.brand);
    }

    // Fetch user's PDStock data and products concurrently
    const [userStock, products] = await Promise.all([
      PDStock.findOne({ userId: mongoose.Types.ObjectId(userId) }),
      Product.aggregate([
        { $match: filter },
        {
          $lookup: {
            from: "categorymodels",
            localField: "category",
            foreignField: "_id",
            as: "categoryDetails",
          },
        },
        {
          $lookup: {
            from: "brandmodels",
            localField: "brand",
            foreignField: "_id",
            as: "brandDetails",
          },
        },
        {
          $project: {
            category: { $arrayElemAt: ["$categoryDetails.categoryName", 0] },
            brand: { $arrayElemAt: ["$brandDetails.brandName", 0] },
            GST: 1,
            HSN_Code: 1,
            SKU: 1,
            addedBy: 1,
            createdAt: 1,
            description: 1,
            image: 1,
            name: 1,
            price: 1,
            product_Status: 1,
            updatedAt: 1,
          },
        },
        { $skip: skip },
        { $limit: PAGE_SIZE },
      ]),
    ]);

    // Create a stock map for easy lookup
    const stockMap = {};
    if (userStock && userStock.products) {
      userStock.products.forEach((product) => {
        stockMap[product.productid.toString()] = product.Stock;
      });
    }

    // Combine products with their respective stock
    const productsWithStock = products.map((product) => ({
      ...product,
      stock: stockMap[product._id.toString()] || 0,
    }));

    // Get total count for pagination purposes
    const total = await Product.countDocuments(filter);

    return res.status(200).json({
      success: true,
      totalProducts: total,
      totalPages: Math.ceil(total / PAGE_SIZE),
      currentPage: page,
      products: productsWithStock,
    });
  } catch (error) {
    console.error("Error fetching products with stock:", error);
    return res.status(500).json({
      success: false,
      message: "Error fetching products and stock",
    });
  }
};

export const getProductsAndStockByRD = async (req, res) => {
  try {
    const userId = req.params.userId || req.user._id;

    // Pagination parameters
    const PAGE_SIZE = parseInt(req.query.show) || 10;
    const page = parseInt(req.query.page) || 1;
    const skip = (page - 1) * PAGE_SIZE;

    // Filtering criteria
    const filter = {};
    if (req.query.name) {
      filter.name = {
        $regex: new RegExp(req.query.name, "i"),
      };
    }
    if (req.query.category) {
      filter.category = mongoose.Types.ObjectId(req.query.category);
    }
    if (req.query.brand) {
      filter.brand = mongoose.Types.ObjectId(req.query.brand);
    }

    // Fetch user's RDStock data and products concurrently
    const [userStock, products] = await Promise.all([
      RDStock.findOne({ userId: mongoose.Types.ObjectId(userId) }),
      Product.aggregate([
        { $match: filter },
        {
          $lookup: {
            from: "categorymodels",
            localField: "category",
            foreignField: "_id",
            as: "categoryDetails",
          },
        },
        {
          $lookup: {
            from: "brandmodels",
            localField: "brand",
            foreignField: "_id",
            as: "brandDetails",
          },
        },
        {
          $project: {
            category: { $arrayElemAt: ["$categoryDetails.categoryName", 0] },
            brand: { $arrayElemAt: ["$brandDetails.brandName", 0] },
            GST: 1,
            HSN_Code: 1,
            SKU: 1,
            addedBy: 1,
            createdAt: 1,
            description: 1,
            image: 1,
            name: 1,
            price: 1,
            product_Status: 1,
            updatedAt: 1,
          },
        },
        { $skip: skip },
        { $limit: PAGE_SIZE },
      ]),
    ]);

    // Create a stock map for easy lookup
    const stockMap = {};
    if (userStock && userStock.products) {
      userStock.products.forEach((product) => {
        stockMap[product.productid.toString()] = product.Stock;
      });
    }

    // Combine products with their respective stock
    const productsWithStock = products.map((product) => ({
      ...product,
      stock: stockMap[product._id.toString()] || 0,
    }));

    // Get total count for pagination purposes
    const total = await Product.countDocuments(filter);

    return res.status(200).json({
      success: true,
      totalProducts: total,
      totalPages: Math.ceil(total / PAGE_SIZE),
      currentPage: page,
      products: productsWithStock,
    });
  } catch (error) {
    console.error("Error fetching products with stock:", error);
    return res.status(500).json({
      success: false,
      message: "Error fetching products and stock",
    });
  }
};

// Create or Update Stock
export const createOrUpdateStock = async (req, res) => {
  const userId = req.user._id;
  try {
    const { products } = req.body; // products: [{ productid, Stock }]

    // Get all product IDs from the Product collection
    const allProducts = await Product.find({}, "_id"); // Fetch only the _id field
    const allProductIds = allProducts.map((p) => p._id.toString()); // Convert to string array

    // Initialize stock for all products as 0
    const updatedProducts = allProductIds.map((productId) => {
      const productInRequest = products.find((p) => p.productid === productId);

      return {
        productid: productId,
        Stock: productInRequest ? productInRequest.Stock : 0,
      };
    });

    // Check if stock entry already exists for the user
    let stock = await PDStock.findOne({ userId });

    if (stock) {
      // Replace stock with the updated product list
      stock.products = updatedProducts;
      await stock.save();
      return res
        .status(200)
        .json({ message: "Stock updated successfully", stock });
    } else {
      // Create a new stock entry if it doesn't exist
      const newStock = new PDStock({ userId, products: updatedProducts });
      await newStock.save();
      return res
        .status(201)
        .json({ message: "Stock created successfully", stock: newStock });
    }
  } catch (error) {
    console.error("Error updating or creating stock:", error);
    res.status(500).json({ message: "Server error", error });
  }
};

export const getStockPD = async (req, res) => {
  try {
    const userId = req.user._id; // userId is provided in the URL

    // Fetch all products with their _id, name, and SKU
    const allProducts = await Product.find({}, "_id name SKU"); // Adjust field names if needed

    // Map products into an object for easy access
    const productMap = new Map(
      allProducts.map((p) => [p._id.toString(), { name: p.name, sku: p.SKU }])
    );

    // Fetch the user's stock from the PDStock model
    let stock = await PDStock.findOne({ userId });

    let productsWithStock = [];

    if (stock) {
      // Create a map of product stocks from the user's stock
      const stockMap = new Map(
        stock.products.map((p) => [p.productid.toString(), p.Stock])
      );

      // Iterate over all products, assigning stock or initializing to 0
      productsWithStock = allProducts.map((product) => ({
        productid: product._id,
        name: product.name,
        SKU: product.SKU,
        Stock: stockMap.get(product._id.toString()) || 0,
      }));
    } else {
      // If no stock entry exists, initialize all products with stock 0
      productsWithStock = allProducts.map((product) => ({
        productid: product._id,
        name: product.name,
        sku: product.sku,
        Stock: 0,
      }));
    }

    return res.status(200).json({
      message: "Stock fetched successfully",
      stocks: productsWithStock,
    });
  } catch (error) {
    console.error("Error fetching stock:", error);
    res.status(500).json({ message: "Server error", error });
  }
};