Sindbad~EG File Manager

const { Op } = require("sequelize");
const db = require("../models");
const { col, literal, fn, transaction } = require("sequelize");

function calculateDateRange(timeRange) {
  const currentDate = new Date();

  switch (timeRange) {
    case "currentweek":
      const currentWeekStartDate = new Date(currentDate);
      currentWeekStartDate.setDate(
        currentDate.getDate() - currentDate.getDay()
      );
      currentWeekStartDate.setHours(0, 0, 0, 0);

      const currentWeekEndDate = new Date(currentDate);
      currentWeekEndDate.setDate(
        currentWeekEndDate.getDate() + (6 - currentWeekEndDate.getDay())
      );
      currentWeekEndDate.setHours(23, 59, 59, 999);

      return { startDate: currentWeekStartDate, endDate: currentWeekEndDate };

    case "lastweek":
      const lastWeekStartDate = new Date(currentDate);
      lastWeekStartDate.setDate(
        lastWeekStartDate.getDate() - lastWeekStartDate.getDay() - 7
      );
      lastWeekStartDate.setHours(0, 0, 0, 0);

      const lastWeekEndDate = new Date(currentDate);
      lastWeekEndDate.setDate(
        lastWeekEndDate.getDate() - lastWeekEndDate.getDay() - 1
      );
      lastWeekEndDate.setHours(23, 59, 59, 999);

      return { startDate: lastWeekStartDate, endDate: lastWeekEndDate };

    case "last4weeks":
      const last4WeeksStartDate = new Date(currentDate);
      last4WeeksStartDate.setDate(last4WeeksStartDate.getDate() - 28);
      last4WeeksStartDate.setHours(0, 0, 0, 0);

      const last4WeeksEndDate = new Date(currentDate);
      last4WeeksEndDate.setDate(last4WeeksEndDate.getDate());
      last4WeeksEndDate.setHours(23, 59, 59, 999);

      return { startDate: last4WeeksStartDate, endDate: last4WeeksEndDate };
    case "last12weeks":
      const last12WeeksStartDate = new Date(currentDate);
      last12WeeksStartDate.setDate(last12WeeksStartDate.getDate() - 84);
      last12WeeksStartDate.setHours(0, 0, 0, 0);

      const last12WeeksEndDate = new Date(currentDate);
      last12WeeksEndDate.setDate(last12WeeksEndDate.getDate());
      last12WeeksEndDate.setHours(23, 59, 59, 999);

      return { startDate: last12WeeksStartDate, endDate: last12WeeksEndDate };

    default:
      // Handle other cases or return an error
      return null;
  }
}
const getAllUserVehicles = async (req, res) => {
  try {
    const user_id = req.params.id;

    let timeRange;
    if (!req.body.timeRange) {
      timeRange = "currentweek";
    } else {
      timeRange = req.body.timeRange;
    }
    timeRange = timeRange.replace(/\s/g, "");
    timeRange = timeRange.toLowerCase();
    const weekRange = calculateDateRange(timeRange);
    // return res.json({ data: weekRange });
    /*  switch (timeRange) {
      case "currentweek":
        const currentWeekStartDate = new Date(currentDate);
        currentWeekStartDate.setDate(
          currentDate.getDate() - currentDate.getDay()
        );
        currentWeekStartDate.setHours(0, 0, 0, 0);

        const currentWeekEndDate = new Date(currentDate);
        currentWeekEndDate.setDate(
          currentWeekEndDate.getDate() + (6 - currentWeekEndDate.getDay())
        );
        currentWeekEndDate.setHours(23, 59, 59, 999);
        break;
      // return { startDate: currentWeekStartDate, endDate: currentWeekEndDate };

      case "lastweek":
        const lastWeekStartDate = new Date(currentDate);
        lastWeekStartDate.setDate(
          currentDate.getDate() - currentDate.getDay() - 7
        );
        lastWeekStartDate.setHours(0, 0, 0, 0);

        const lastWeekEndDate = new Date(currentDate);
        lastWeekEndDate.setDate(
          lastWeekEndDate.getDate() - lastWeekEndDate.getDay() - 1
        );
        lastWeekEndDate.setHours(23, 59, 59, 999);
        break;

      case "last4weeks":
        let last4WeeksStartDate = new Date(currentDate);
        last4WeeksStartDate.setDate(currentDate.getDate() - 28);
        last4WeeksStartDate.setHours(0, 0, 0, 0);

        let last4WeeksEndDate = new Date(currentDate);
        last4WeeksEndDate.setHours(23, 59, 59, 999);
        break;
      // return { startDate: last4WeeksStartDate, endDate: last4WeeksEndDate };

      default:
        last4WeeksStartDate = new Date(currentDate);
        last4WeeksStartDate.setDate(currentDate.getDate() - 28);
        last4WeeksStartDate.setHours(0, 0, 0, 0);

        last4WeeksEndDate = new Date(currentDate);
        last4WeeksEndDate.setHours(23, 59, 59, 999);
    } */

    let { sortBy, orderDirection } = req.body;

    const result = await db.tblVehicle.findAll({
      where: {
        user_id: user_id,
        createdAt: {
          [Op.between]: [weekRange.startDate, weekRange.endDate],
        },
      },
      order: [[sortBy || "vehicle_id", orderDirection || "ASC"]],
    });
    return res.json({
      status: 200,
      message: "Success",
      data: result,
    });
  } catch (error) {
    return res.status(500).json({ status: 500, message: `${error.message}` });
  }
};

const sortVehicles = async (req, res) => {
  try {
    const user_id = req.params.id;
    let { sortBy, orderDirection } = req.body;
    // Define the base where clause
    let whereClause = {
      user_id: user_id,
    };

    // Adjust the where clause based on sortBy
    if (sortBy == "sold_price") {
      sortBy = "vehicle_id";
      /*  whereClause.sold_price = {
        [Op.not]: null,
      }; */
    }

    let result = await db.tblVehicle.findAll({
      where: whereClause,
      order: [[sortBy || "vehicle_id", orderDirection || "ASC"]],
    });

    return res.json({ status: 200, message: "Success", data: result });
  } catch (error) {
    return res.status(500).json({ status: 500, message: `${error.message}` });
  }
};

const sortByYear = async (req, res) => {
  try {
    const user_id = req.params.id;
    let { orderDirection } = req.body;
    /*  sortOrder = sortOrder.replace(/\s/g, "");
    sortOrder = sortOrder.toLowerCase();
    const orderDirection = sortOrder === "lowest" ? "ASC" : "DESC";
 */
    let result = await db.tblVehicle.findAll({
      where: {
        user_id: user_id,
      },
      order: [["year", orderDirection]],
    });

    return res.json({ status: 200, message: "Success", data: result });
  } catch (error) {
    return res.status(500).json({ status: 500, message: `${error.message}` });
  }
};
const sortByMileage = async (req, res) => {
  try {
    const user_id = req.params.id;
    let { orderDirection } = req.body;
    let result = await db.tblVehicle.findAll({
      where: {
        user_id: user_id,
        mileage: {
          [Op.not]: null, // Exclude records with null sold_price
        },
      },
      order: [["mileage", orderDirection]],
    });
    return res.json({ status: 200, message: "Success", data: result });
  } catch (error) {
    return res.status(500).json({ status: 500, message: `${error.message}` });
  }
};

const sortByConditionLight = async (req, res) => {
  try {
    const { user_id, week_id } = req.body;

    const results = await db.tblOpportunity.findAll({
      attributes: ["opportunity_id", "auctioneer_id"],
      where: { user_id: user_id, week_id: week_id },
      include: [
        {
          model: db.tblVehicle,
          attributes: ["vehicle_id"],
          include: [
            {
              model: db.tblVehicleRun,
              attributes: ["condition_light"],
              order: [["condition_light", "ASC"]],
            },
          ],
        },
      ],
    });

    const groupedData = results.flatMap(
      ({ auctioneer_id, opportunity_id, tblVehicles }) => {
        const groupedByCondition = tblVehicles.reduce((acc, vehicle) => {
          const condition_light =
            vehicle.tblVehicleRuns[0]?.condition_light || 0;

          if (!acc[condition_light]) {
            acc[condition_light] = [];
          }

          acc[condition_light].push({
            vehicle_id: vehicle.vehicle_id,
            year: vehicle.year,
            make: vehicle.make,
            model: vehicle.model,
            imageUrl: vehicle.imageUrl,
            condition_light: condition_light || 0,
            sale_price: vehicle.tblVehicleRuns[0]?.sale_price || null,
            sale_status: vehicle.tblVehicleRuns[0]?.sale_status || null,
            lane_id: vehicle.tblVehicleRuns[0]?.lane_id || null,
          });

          return acc;
        }, {});

        return Object.entries(groupedByCondition).map(
          ([condition_light, vehicles_list]) => ({
            opportunity_id,
            auctioneer_id,
            condition_light: Number(condition_light),
            units: vehicles_list.length, // Add the units property
            // vehicles_list,
          })
        );
      }
    );

    const conditionLightValues = [0, 1, 2, 3];
    // Check for missing condition_light values
    const missingValues = conditionLightValues.filter((value) => {
      return !groupedData.some((item) => item.condition_light === value);
    });

    // Add missing values to the existing data
    const newData = groupedData.concat(
      missingValues.map((value) => ({
        opportunity_id: 0, // Replace with the appropriate value
        auctioneer_id: 0, // Replace with the appropriate value
        condition_light: value,
        units: 0, // Replace with the appropriate value
      }))
    );
    const filteredData = newData.filter((item) => item.condition_light != 0);
    return res.json({ status: 200, Message: "Success", data: filteredData });
  } catch (error) {
    return res.status(500).json({ error: error.message });
  }
};

const getConditionLightVehicles = async (req, res) => {
  try {
    const { condition_light, opportunity_id } = req.body;

    const results = await db.tblVehicle.findAll({
      attributes: [
        "vehicle_id",
        "year",
        "make",
        "model",
        "vin",
        "mileage",
        "imageUrl",
        "color",
      ],
      where: { opportunity_id: opportunity_id },
      include: [
        {
          model: db.tblVehicleRun,
          attributes: [
            "condition_light",
            "announcements",
            "sale_price",
            "auction_fee",
            "net_profit",
            "reserve",
            "sale_status",
            "lane_id",
          ],
          where: { condition_light: condition_light },
          raw: true,
          include: [
            {
              model: db.tblAuctionLane,
              attributes: ["name"],
              raw: true,
              // required: true,
              include: [
                {
                  model: db.tblAuction,
                  attributes: ["auction_id", "name"],
                  raw: true,
                  required: false,
                },
              ],
            },
          ],
        },
      ],
    });

    const outputArray = results.map((vehicle) => {
      const vehicleRun = vehicle.tblVehicleRuns[0];
      const auctionLane = vehicleRun.tblAuctionLane || {};
      const auction = auctionLane.tblAuction || {};

      return {
        vehicle_id: vehicle.vehicle_id,
        year: vehicle.year,
        make: vehicle.make,
        model: vehicle.model,
        vin: vehicle.vin,
        mileage: vehicle.mileage,
        imageUrl: vehicle.imageUrl,
        color: vehicle.color,
        vehicle_run_id: vehicleRun.vehicle_run_id,
        condition_light: vehicleRun.condition_light,
        announcements: vehicleRun.announcements,
        reserve: vehicleRun.reserve,
        sale_price: vehicleRun.sale_price,
        auction_fee: vehicleRun.auction_fee,
        net_profit: vehicleRun.net_profit,
        sale_status: vehicleRun.sale_status,
        run_no: vehicleRun.run_no,
        lane_id: vehicleRun.lane_id,
        lane_name: auctionLane.name,
        auction_id: auction.auction_id || null,
        auction_name: auction.name || null,
      };
    });
    return res.json({ status: true, message: "Success", data: outputArray });
  } catch (error) {
    return res.status(500).json({ error: error.message });
  }
};

const calculateLength = (data) => {
  return data.map((group) => ({
    sale_status: group.sale_status,
    vehicles_list_length: group.vehicles_list.length,
    vehicles_list: group.vehicles_list,
  }));
};

const sortBySaleStatus = async (req, res) => {
  try {
    const { auctioneer_id, user_id, week_id } = req.body;
    const result = await db.tblOpportunity.findAll({
      attributes: ["opportunity_id", "auctioneer_id"],
      where: { user_id: user_id, week_id: week_id },
      include: [
        {
          model: db.tblVehicle,
          attributes: ["vehicle_id", "opportunity_id"],
          where: { opportunity_id: col("tblOpportunity.opportunity_id") },
          raw: true,
          include: [
            {
              model: db.tblVehicleRun,
              attributes: ["condition_light", "sale_status"],
              where: { vehicle_id: col("tblVehicles.vehicle_id") },
            },
          ],
        },
      ],
    });
    // return res.json({ result });
    if (result.length <= 0) {
      return res.json({ status: 200, message: "Success", data: result });
    }
    let outputData = result[0].tblVehicles.flatMap((vehicle) => {
      return vehicle.tblVehicleRuns.map((run) => ({
        vehicle_id: vehicle.vehicle_id,
        opportunity_id: vehicle.opportunity_id,
        auctioneer_id: result[0].auctioneer_id,
        condition_light: run.condition_light,
        sale_status: run.sale_status,
      }));
    });

    const groupedData = outputData.reduce((acc, item) => {
      const { sale_status, ...rest } = item;

      if (!acc[sale_status]) {
        acc[sale_status] = { units: 0, data: [] };
      }

      acc[sale_status].units += 1;
      acc[sale_status].data.push(rest);

      return acc;
    }, {});

    // Transform groupedData into the desired format
    outputData = Object.keys(groupedData).map((sale_status) => {
      return {
        ...groupedData[sale_status].data[0], // Assuming all items in a group have the same vehicle_id, condition_light, and sale_status
        sale_status: sale_status,
        // sale_status: false,
        units: groupedData[sale_status].units,
      };
    });

    const saleStatusValues = ["true", "false"];
    // Check for missing sale_status values
    const missingValues = saleStatusValues.filter((value) => {
      return !outputData.some((item) => item.sale_status === value);
    });
    // Add missing values to the existing data
    const newData = outputData.concat(
      missingValues.map((value) => ({
        vehicle_id: 0, // Replace with the appropriate value
        opportunity_id: 0, // Replace with the appropriate value
        auctioneer_id: 0, // Replace with the appropriate value
        condition_light: 0, // Replace with the appropriate value
        sale_status: value,
        units: 0, // Replace with the appropriate value
      }))
    );
    return res.json({ status: 200, message: "Success", data: newData });
    [
      {
        vehicle_id: 0,
        opportunity_id: 0,
        auctioneer_id: 0,
        condition_light: 0,
        sale_status: "false",
        units: 0,
      },
      {
        vehicle_id: 0,
        opportunity_id: 0,
        auctioneer_id: 0,
        condition_light: 0,
        sale_status: "true",
        units: 0,
      },
    ];
  } catch (error) {
    return res.json(error.message);
  }
};

const getSaleStatusVehicles = async (req, res) => {
  try {
    const { sale_status, opportunity_id, sortBy, orderDirection } = req.body;

    const results = await db.tblVehicle.findAll({
      attributes: [
        "vehicle_id",
        "year",
        "make",
        "model",
        "vin",
        "mileage",
        "imageUrl",
        "color",
      ],
      where: { opportunity_id: opportunity_id },
      include: [
        {
          model: db.tblVehicleRun,
          // attributes: ["condition_light","announcements","sale_price","auction_fee","reserve","sale_status","lane_id"],
          where: { sale_status: sale_status },
          raw: true,
          include: [
            {
              model: db.tblAuctionLane,
              attributes: ["name"],
              raw: true,
              // required: true,
              include: [
                {
                  model: db.tblAuction,
                  attributes: ["auction_id", "name"],
                  raw: true,
                  required: false,
                },
              ],
            },
          ],
        },
      ],
      order: [[sortBy || "vehicle_id", orderDirection || "ASC"]],
    });

    const outputArray = results.map((vehicle) => {
      const vehicleRun = vehicle.tblVehicleRuns[0];
      const auctionLane = vehicleRun.tblAuctionLane || {};
      const auction = auctionLane.tblAuction || {};

      return {
        vehicle_id: vehicle.vehicle_id,
        year: vehicle.year,
        make: vehicle.make,
        model: vehicle.model,
        vin: vehicle.vin,
        mileage: vehicle.mileage,
        imageUrl: vehicle.imageUrl,
        color: vehicle.color,
        vehicle_run_id: vehicleRun.vehicle_run_id,
        condition_light: vehicleRun.condition_light,
        announcements: vehicleRun.announcements,
        reserve: vehicleRun.reserve,
        sale_price: vehicleRun.sale_price,
        auction_fee: vehicleRun.auction_fee,
        net_profit: vehicleRun.net_profit,
        sale_status: vehicleRun.sale_status,
        run_no: vehicleRun.run_no,
        lane_id: vehicleRun.lane_id,
        lane_name: auctionLane.name,
        auction_id: auction.auction_id || null,
        auction_name: auction.name || null,
      };
    });
    return res.json({ status: true, message: "Success", data: outputArray });
  } catch (error) {
    return res.status(500).json({ error: error.message });
  }
};

const totalSalePrice = async (req, res) => {
  try {
    let days = 1;
    if (req.body.days) {
      days = req.body.days;
    }
    console.log(`days are ${days}`);
    const currentDate = new Date();
    const last24Hours = new Date(currentDate - days * 24 * 60 * 60 * 1000);
    const user_id = req.params.id;
    const result = await db.tblVehicle.findAll({
      attributes: ["sold_price"],
      where: {
        user_id: user_id,
        createdAt: {
          [Op.between]: [last24Hours, currentDate],
        },
      },
      order: [["createdAt", "ASC"]],
    });

    const total_price = result
      .filter((item) => item.sold_price !== null)
      .reduce((sum, item) => sum + item.sold_price, 0);

    console.log("Total Price:", total_price);

    return res.json({ status: 200, message: "Success", data: total_price });
  } catch (error) {
    return res.status(500).json({ status: 500, message: `${error.message}` });
  }
};

//testingsale
const totalSaleAndNetProfit = async (req, res) => {
  try {
    let { user_id } = req.body;

    let timeRange;
    if (!req.body.timeRange) {
      timeRange = "currentweek";
    } else {
      timeRange = req.body.timeRange;
    }
    timeRange = timeRange.replace(/\s/g, "");
    timeRange = timeRange.toLowerCase();

    /*  const currentDate = new Date();
    let startDate;
    let endDate;

    switch (timeRange) {
      case "currentweek":
        startDate = new Date(currentDate);
        startDate.setHours(0, 0, 0, 0 - currentDate.getDay());
        startDate.setDate(startDate.getDate());

        endDate = new Date(currentDate);
        endDate.setHours(23, 59, 59, 999 - currentDate.getDay());

        break;
      case "lastweek":
        startDate = new Date(currentDate);
        startDate.setHours(0, 0, 0, 0 - currentDate.getDay());
        startDate.setDate(startDate.getDate() - 7);

        endDate = new Date(currentDate);
        endDate.setDate(endDate.getDate() - endDate.getDay());
        endDate.setHours(23, 59, 59, 999);
        break;
      case "last4weeks":
        startDate = new Date(currentDate);
        startDate.setDate(currentDate.getDate() - 28);
        endDate = new Date(currentDate);
        endDate.setDate(endDate.getDate() - endDate.getDay());
        endDate.setHours(23, 59, 59, 999);
        break;
      default:
        startDate = new Date(currentDate);
        startDate.setHours(0, 0, 0, 0 - currentDate.getDay());
        startDate.setDate(startDate.getDate() - 3);

        endDate = new Date(currentDate);
        endDate.setHours(23, 59, 59, 999 - endDate.getDay());
    } */

    const weekRange = calculateDateRange(timeRange);
    const results = await db.tblVehicle.findAll({
      attributes: [
        "vehicle_id",
        "user_id",
        /* [
          db.sequelize.literal("SUM(`tblVehicleRuns`.`sale_price`)"),
          "total_sale",
        ],
        [
          db.sequelize.literal("SUM(`tblVehicleRuns`.`net_profit`)"),
          "total_net_profit",
        ], */
      ],
      include: [
        {
          model: db.tblVehicleRun,
          attributes: [
            "vehicle_run_id",
            "sale_price",
            "auction_fee",
            "net_profit",
            "sale_status",
          ],
          raw: true,
          where: {
            sale_price: { [Op.ne]: null },
          },
        },
      ],
      where: {
        user_id: user_id,
        createdAt: {
          [Op.between]: [weekRange.startDate, weekRange.endDate],
        },
      },
      // order: [["createdAt", "ASC"]],
    });
    if (results.length === 0) {
      return res.json({
        status: 200,
        message: "Success",
        net_profit: 0,
        total_profit: 0,
        unit_sold: 0,
      });
    }
    const transformedData = results.reduce((result, vehicle) => {
      const existingUser = result.find(
        (user) => user.user_id === vehicle.user_id
      );

      if (existingUser) {
        // If user exists, update totals
        existingUser.total_profit += vehicle.tblVehicleRuns.reduce(
          (sum, run) => sum + run.sale_price,
          0
        );
        existingUser.net_profit += vehicle.tblVehicleRuns.reduce(
          (sum, run) => sum + run.net_profit,
          0
        );
        existingUser.sold_units += vehicle.tblVehicleRuns.length;
      } else {
        // If user doesn't exist, add a new user entry
        const newUser = {
          user_id: vehicle.user_id,
          total_profit: vehicle.tblVehicleRuns.reduce(
            (sum, run) => sum + run.sale_price,
            0
          ),
          net_profit: vehicle.tblVehicleRuns.reduce(
            (sum, run) => sum + run.net_profit,
            0
          ),
          sold_units: vehicle.tblVehicleRuns.length,
        };
        result.push(newUser);
      }

      return result;
    }, []);

    return res.json({
      status: 200,
      message: "Success",
      net_profit: transformedData[0]?.net_profit || 0,
      total_profit: transformedData[0]?.total_profit || 0,
      unit_sold: transformedData[0]?.sold_units || 0,
    });
  } catch (error) {
    return res.status(500).json({ status: 500, error: error.message });
  }
};

const updateUserAuctioneerCarsList = async (req, res) => {
  try {
    const { car_ids, auctioneerId, userId, weekId } = req.body;
    const week_id = parseInt(weekId);

    const [opportunity_id] = await db.tblOpportunity.findAll({
      where: {
        [Op.and]: [
          {
            week_id: week_id,
          },
          {
            auctioneer_id: auctioneerId,
          },
          {
            user_id: userId,
          },
        ],
      },
      attributes: ["opportunity_id"],
    });
    const data = {
      opportunity_id: opportunity_id.opportunity_id,
    };

    const promises = car_ids.map((item) => {
      db.tblVehicle.update(data, {
        where: {
          vehicle_id: item,
        },
      });
    });

    await Promise.all(promises);
    return res.json({ status: 200, message: "Updated Successfully" });
  } catch (error) {
    console.log(error);
    return res.json(error.message);
  }
};

const createVehicleController = async (req, res) => {
  try {
    const { user_id } = req.body;
    const userId = parseInt(user_id);
    let imageFiles;
    req.body.user_id = userId;

    if (req.files.length > 0) {
      console.log(req.files);
      imageFiles = req.files;
      const mainImageUrl = imageFiles[0].filename;
      req.body.imageUrl = mainImageUrl;
    }
    let result = await db.tblVehicle.create(req.body);

    const car_id = result.vehicle_id;
    if (req.files.length > 0) {
      console.log("Images Files Existed");

      await Promise.all(
        imageFiles.map(async (item) =>
          db.tblVehicleImage.create({
            vehicle_id: car_id,
            imageUrl: item.filename,
          })
        )
      );
    }

    if (!result) {
      return res.status(500).json({ status: 500, message: "Operation Failed" });
    }

    return res
      .status(200)
      .json({ status: 200, message: "data created successfully" });
  } catch (error) {
    console.log(error.message);
    return res.status(500).json({ status: 500, message: `${error.message}` });
  }
};

const createVehicleControllerWithoutImages = async (req, res) => {
  try {
    const body = req.body;
    const result = await db.tblVehicle.create(body);

    return res.json({ status: 200, message: "Success", data: result });
  } catch (error) {
    return res.status(500).json({ status: 500, message: `${error.message}` });
  }
};

const getVehicleDetailsById = async (req, res) => {
  try {
    const vehicle_id = req.params.id;

    let result = await db.tblVehicle.findAll({
      where: {
        vehicle_id: vehicle_id,
      },
    });

    return res
      .status(200)
      .json({ status: 200, message: "success", data: result });
  } catch (error) {
    return res.status(500).json({ status: 500, message: `${error.message}` });
  }
};

const getUserCarsData = async (req, res) => {
  try {
    const userId = req.params.id;
    const result = await db.tblVehicle.findAll({
      where: {
        user_id: userId,
      },
    });
    return res
      .status(200)
      .json({ status: 200, message: "success", data: result });
  } catch (error) {
    return res.status(500).json({ status: 500, message: `${error.message}` });
  }
};
const getVehicleImagesByCarId = async (req, res) => {
  try {
    const vehicle_id = req.params.id;
    let result = await db.tblVehicleImage.findAll({
      where: {
        vehicle_id: vehicle_id,
      },
    });
    return res
      .status(200)
      .json({ status: 200, message: "success", data: result });
  } catch (error) {
    return res.status(500).json({ status: 500, message: `${error.message}` });
  }
};

const updateVehicleDetails = async (req, res) => {
  try {
    const vehicle_id = req.params.id;
    console.log(req.body);
    const { imagesListIds } = req.body;
    let result = await db.tblVehicle.update(req.body, {
      where: {
        vehicle_id: vehicle_id,
      },
    });

    const promises = imagesListIds.map(async (id) => {
      try {
        result = await db.tblVehicleImage.destroy({
          where: { image_id: id },
        });
      } catch (error) {
        console.error(error);
        return res
          .status(500)
          .json({ status: 500, message: "Internal Server Error" });
      }
    });

    await Promise.all(promises);
    console.log(result);

    return res.json({ status: 200, message: "succes", data: result });
  } catch (error) {
    return res.json(error.message);
  }
};

const removeCarFromAuctioneer = async (req, res) => {
  try {
    const { carIds } = req.body;
    const results = await Promise.all(
      carIds.map(async (vehicle_id) => {
        let result;
        await db.sequelize.transaction(async (t) => {
          // Update tblVehicleRun
          result = await db.tblVehicleRun.destroy({
            where: {
              vehicle_id: vehicle_id,
            },
            transaction: t,
          });
          // Update tblVehicle
          await db.tblVehicle.update(
            {
              opportunity_id: null,
            },
            {
              where: {
                vehicle_id: vehicle_id,
              },
              transaction: t,
            }
          );
        });

        return result;
      })
    );

    return res.json({ status: 200, message: "Success", data: results });
  } catch (error) {
    return res.json({
      status: 500,
      message: `Error in removeCarFromAuctioneer: ${error.message}`,
    });
  }
};

const updateCarStatus = async (req, res) => {
  try {
    // const { vehicle_id, anoucements, reserve } = req.body;
    // console.log(req.body);
    let result;
    const vehicle_id = req.body.vehicle_id;
    [result] = await db.tblVehicleRun.findAll({
      where: {
        vehicle_id: vehicle_id,
      },
    });

    if (!result) {
      await db.tblVehicleRun.create(req.body);
    } else {
      await db.tblVehicleRun.update(req.body, {
        where: {
          vehicle_id: vehicle_id,
        },
      });
    }
    return res.json({ status: 200, message: "Success" });
  } catch (error) {
    console.log(error);
    return res.json(error.message);
  }
};

const deleteUserVehicle = async (req, res) => {
  try {
    let vehicle_id = req.params.id;
    vehicle_id = parseInt(vehicle_id);
    // Use Promise.all for concurrent execution

    const [tblVehicleResult] = await db.tblVehicle.destroy({
      where: {
        vehicle_id: vehicle_id,
      },
    });
    let tblVehicleRunResult;
    if (!tblVehicleResult) {
      [tblVehicleRunResult] = await db.tblVehicleRun.destroy({
        where: {
          vehicle_id: vehicle_id,
        },
      });
    }

    return res.json({
      status: 200,
      message: "Success",
      tblVehicleRunRueslt: tblVehicleRunResult || 0,
    });
  } catch (error) {
    return res.json(error.message);
  }
};

module.exports = {
  getAllUserVehicles,
  createVehicleControllerWithoutImages,
  createVehicleController,
  getVehicleImagesByCarId,
  getVehicleDetailsById,
  updateVehicleDetails,
  updateUserAuctioneerCarsList,
  getUserCarsData,
  removeCarFromAuctioneer,
  updateCarStatus,
  totalSalePrice,
  totalSaleAndNetProfit,
  sortByYear,
  sortVehicles,
  sortByMileage,
  sortByConditionLight,
  sortBySaleStatus,
  deleteUserVehicle,
  getConditionLightVehicles,
  getSaleStatusVehicles,
};