rentall-app/backend/routes/stripe.js

const express = require("express");
const { authenticateToken } = require("../middleware/auth");
const { User } = require("../models");
const { Rental, Item } = require("../models");
const StripeService = require("../services/stripeService");
const router = express.Router();
const platformFee = 0.1;

router.post("/create-checkout-session", async (req, res) => {
  try {
    const { itemName, total, return_url, rentalData } = req.body;

    if (!itemName) {
      return res.status(400).json({ error: "No item name found" });
    }
    if (total == null || total === undefined) {
      return res.status(400).json({ error: "No total found" });
    }
    if (!return_url) {
      return res.status(400).json({ error: "No return_url found" });
    }

    // Prepare metadata - Stripe metadata keys must be strings
    const metadata = rentalData
      ? {
          itemId: rentalData.itemId,
          startDate: rentalData.startDate,
          endDate: rentalData.endDate,
          startTime: rentalData.startTime,
          endTime: rentalData.endTime,
          totalAmount: rentalData.totalAmount.toString(),
          deliveryMethod: rentalData.deliveryMethod,
        }
      : {};

    const session = await StripeService.createCheckoutSession({
      item_name: itemName,
      total: total,
      return_url: return_url,
      metadata: metadata,
    });

    res.json({ clientSecret: session.client_secret });
  } catch (error) {
    console.error("Error creating checkout session:", error);
    res.status(500).json({ error: error.message });
  }
});

// Get checkout session status
router.get("/checkout-session/:sessionId", async (req, res) => {
  try {
    const { sessionId } = req.params;

    const session = await StripeService.getCheckoutSession(sessionId);

    res.json({
      status: session.status,
      payment_status: session.payment_status,
      customer_email: session.customer_details?.email,
      metadata: session.metadata,
    });
  } catch (error) {
    console.error("Error retrieving checkout session:", error);
    res.status(500).json({ error: error.message });
  }
});

// // Create connected account
// router.post("/accounts", authenticateToken, async (req, res) => {
//   try {
//     const user = await User.findByPk(req.user.id);

//     if (!user) {
//       return res.status(404).json({ error: "User not found" });
//     }

//     // Check if user already has a connected account
//     if (user.stripeConnectedAccountId) {
//       return res
//         .status(400)
//         .json({ error: "User already has a connected account" });
//     }

//     // Create connected account
//     const account = await StripeService.createConnectedAccount({
//       email: user.email,
//       country: "US", // You may want to make this configurable
//     });

//     // Update user with account ID
//     await user.update({
//       stripeConnectedAccountId: account.id,
//     });

//     res.json({
//       stripeConnectedAccountId: account.id,
//       success: true,
//     });
//   } catch (error) {
//     console.error("Error creating connected account:", error);
//     res.status(500).json({ error: error.message });
//   }
// });

// // Generate onboarding link
// router.post("/account-links", authenticateToken, async (req, res) => {
//   try {
//     const user = await User.findByPk(req.user.id);

//     if (!user || !user.stripeConnectedAccountId) {
//       return res.status(400).json({ error: "No connected account found" });
//     }

//     const { refreshUrl, returnUrl } = req.body;

//     if (!refreshUrl || !returnUrl) {
//       return res
//         .status(400)
//         .json({ error: "refreshUrl and returnUrl are required" });
//     }

//     const accountLink = await StripeService.createAccountLink(
//       user.stripeConnectedAccountId,
//       refreshUrl,
//       returnUrl
//     );

//     res.json({
//       url: accountLink.url,
//       expiresAt: accountLink.expires_at,
//     });
//   } catch (error) {
//     console.error("Error creating account link:", error);
//     res.status(500).json({ error: error.message });
//   }
// });

// // Get account status
// router.get("/account-status", authenticateToken, async (req, res) => {
//   try {
//     const user = await User.findByPk(req.user.id);

//     if (!user || !user.stripeConnectedAccountId) {
//       return res.status(400).json({ error: "No connected account found" });
//     }

//     const accountStatus = await StripeService.getAccountStatus(
//       user.stripeConnectedAccountId
//     );

//     res.json({
//       accountId: accountStatus.id,
//       detailsSubmitted: accountStatus.details_submitted,
//       payoutsEnabled: accountStatus.payouts_enabled,
//       capabilities: accountStatus.capabilities,
//       requirements: accountStatus.requirements,
//     });
//   } catch (error) {
//     console.error("Error getting account status:", error);
//     res.status(500).json({ error: error.message });
//   }
// });

// // Create payment intent for rental
// router.post("/payment-intents", authenticateToken, async (req, res) => {
//   try {
//     const { rentalId, amount } = req.body;

//     if (!rentalId || !amount) {
//       return res
//         .status(400)
//         .json({ error: "rentalId and amount are required" });
//     }

//     // Get rental details to find owner's connected account
//     const rental = await Rental.findByPk(rentalId, {
//       include: [{ model: Item, as: "item" }],
//     });

//     if (!rental) {
//       return res.status(404).json({ error: "Rental not found" });
//     }

//     if (rental.ownerId !== req.user.id) {
//       return res.status(403).json({ error: "Unauthorized" });
//     }

//     // Get owner's connected account
//     const owner = await User.findByPk(rental.ownerId);
//     if (!owner || !owner.stripeConnectedAccountId) {
//       return res
//         .status(400)
//         .json({ error: "Owner does not have a connected account" });
//     }

//     const applicationFeeAmount = Math.round(amount * platformFee);

//     const paymentIntent = await StripeService.createPaymentIntent({
//       amount: Math.round(amount * 100), // Convert to cents
//       currency: "usd",
//       connectedAccountId: owner.stripeConnectedAccountId,
//       applicationFeeAmount: applicationFeeAmount * 100, // Convert to cents
//       metadata: {
//         rentalId: rental.id,
//         renterId: rental.renterId,
//         ownerId: owner.id,
//       },
//     });

//     res.json({
//       clientSecret: paymentIntent.client_secret,
//       paymentIntentId: paymentIntent.id,
//     });
//   } catch (error) {
//     console.error("Error creating payment intent:", error);
//     res.status(500).json({ error: error.message });
//   }
// });

module.exports = router;