const corsOptions = {
  origin: ENV.NODE_ENV === "production" 
    ? ENV.CLIENT_URL  
    : function (origin, callback) {
        const allowedOrigins = [
          'http://localhost:5173',           // Admin dashboard
          'http://localhost:5174',           // Web storefront
          'http://localhost:8081',           // Expo metro bundler
          'http://10.0.2.2:3000',           // Android emulator
        ];
        
        // Allow Expo connections
        if (origin.startsWith('exp://')) {
          return callback(null, true);
        }
        
        if (allowedOrigins.includes(origin)) {
          return callback(null, true);
        }
        callback(new Error('Not allowed by CORS'));
      },
  credentials: true,
  methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
  allowedHeaders: ['Content-Type', 'Authorization', 'clerk-session-id']
};

app.use("/api/admin", adminRoutes);        // Admin operations
app.use("/api/users", userRoutes);        // User management
app.use("/api/orders", orderRoutes);      // Order processing
app.use("/api/reviews", reviewRoutes);    // Product reviews
app.use("/api/products", productRoutes);  // Product catalog
app.use("/api/cart", cartRoutes);         // Shopping cart
app.use("/api/payment", paymentRoutes);   // Payment processing
app.use("/api/coupons", couponRoutes);    // Discount coupons

const PUBLISHABLE_KEY = import.meta.env.VITE_CLERK_PUBLISHABLE_KEY

const queryClient = new QueryClient({
  defaultOptions: {
    queries: {
      staleTime: 5 * 60 * 1000,        // 5 minutes
      gcTime: 10 * 60 * 1000,          // 10 minutes
      retry: 1,
      refetchOnWindowFocus: false,
      refetchOnMount: true,
      refetchOnReconnect: true,
      networkMode: 'online',
    },
    mutations: {
      retry: 0,
      networkMode: 'online',
    },
  },
})

createRoot(document.getElementById('root')).render(
  <StrictMode>
    <BrowserRouter>
      <ClerkProvider publishableKey={PUBLISHABLE_KEY} localization={esES}>
        <AuthProvider>
          <QueryClientProvider client={queryClient}>
            <App/>
          </QueryClientProvider>
        </AuthProvider>
      </ClerkProvider>
    </BrowserRouter>
  </StrictMode>
)

function App() {
  return (
    <ClerkProvider publishableKey={CLERK_KEY} localization={esES}>
      <QueryClientProvider client={queryClient}>
        <AuthProvider>
          <CartProvider>
            <Router>
              <ScrollToTop />
              <Routes>
                {/* Public routes */}
                <Route index element={<Home />} />
                <Route path="catalogo" element={<Catalog />} />
                <Route path="producto/:id" element={<ProductDetail />} />
                
                {/* Protected routes */}
                <Route path="perfil" element={
                  <ProtectedRoute><Profile /></ProtectedRoute>
                } />
                <Route path="checkout" element={
                  <ProtectedRoute><Checkout /></ProtectedRoute>
                } />
              </Routes>
              <CookieBanner />
              <ToastContainer />
            </Router>
          </CartProvider>
        </AuthProvider>
      </QueryClientProvider>
    </ClerkProvider>
  );
}

const userSchema = new mongoose.Schema({
  email: {
    type: String,
    required: true,
    unique: true,
  },
  name: {
    type: String,
    required: true,
  },
  clerkId: {
    type: String,
    unique: true,
    required: true,
  },
  stripeCustomerId: {
    type: String,
    default: ""
  },
  addresses: [addressSchema],
  wishlist: [{
    type: mongoose.Schema.Types.ObjectId,
    ref: "Product",
  }],
  isActive: {
    type: Boolean,
    default: true,
  },
  documentType: {
    type: String,
    enum: ["cedula_ciudadania", "cedula_extranjeria", "pasaporte"],
  },
  documentNumber: String,
  phone: String,
}, { timestamps: true });

const productSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true
  },
  description: {
    type: String,
    required: true
  },
  price: {
    type: Number,
    required: true,
    min: 0
  },
  stock: {
    type: Number,
    required: true,
    min: 0,
    default: 0
  },
  category: {
    type: String,
    required: true
  },
  images: [{
    type: String,
    required: true
  }],
  averageRating: {
    type: Number,
    min: 0,
    max: 5,
    default: 0
  },
  totalReviews: {
    type: Number,
    min: 0,
    default: 0
  }
}, { timestamps: true });

const orderSchema = new mongoose.Schema({
  user: {
    type: mongoose.Schema.Types.ObjectId,
    ref: "User",
    required: true
  },
  clerkId: {
    type: String,
    required: true,
  },
  orderItems: [orderItemSchema],
  shippingAddress: {
    type: shippingAddressSchema,
    required: true
  },
  paymentResult: {
    id: String,
    status: String,
  },
  totalPrice: {
    type: Number,
    required: true,
    min: 0
  },
  status: {
    type: String,
    enum: ["pending", "paid", "in_preparation", "ready", "delivered", "canceled", "rejected"],
    default: "pending"
  },
  paidAt: Date,
  deliveredAt: Date,
}, { timestamps: true });

export const requireAuth = async (req, res, next) => {
  const { userId } = req.auth;
  if (!userId) {
    return res.status(401).json({ message: "Unauthorized" });
  }
  next();
};

const ProtectedRoute = ({ children }) => {
  const { isSignedIn, isLoaded } = useAuth();
  
  if (!isLoaded) return <PageLoader />;
  if (!isSignedIn) return <Navigate to="/login" />;
  
  return children;
};

import { Inngest } from "inngest";

const inngest = new Inngest({ id: "don-palito-jr" });

const createUserFunction = inngest.createFunction(
  { id: "create-user" },
  { event: "clerk.user.created" },
  async ({ event }) => {
    const { id, email_addresses, first_name, last_name, image_url } = event.data;
    
    await User.create({
      clerkId: id,
      email: email_addresses[0].email_address,
      name: `${first_name} ${last_name}`,
      imageUrl: image_url,
    });
    
    // Send welcome email
    await sendWelcomeEmail(email_addresses[0].email_address);
  }
);

if (ENV.NODE_ENV === "production") {
  app.use(express.static(path.join(__dirname, "../admin/dist")));
  app.get("/{*any}", (req, res) => {
    res.sendFile(path.join(__dirname, "../admin", "dist", "index.html"));
  });
}