require('dotenv').config();

const express = require('express');
const { auth } = require('express-openid-connect');
const cors = require('cors');
const mongoose = require('mongoose');
const config = require('./config');

const app = express();

// Add body parser middleware BEFORE routes
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// Connect to MongoDB
mongoose.connect(config.mongodb.uri, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
  retryWrites: true,
  w: 'majority'
})
.then(() => console.log('Connected to MongoDB Atlas'))
.catch(err => console.error('MongoDB connection error:', err));

app.use(cors({
  origin: config.frontend.url,
  credentials: true
}));

const auth0Config = {
  authRequired: false,
  auth0Logout: true,
  secret: config.auth0.secret,
  baseURL: config.server.url,
  clientID: config.auth0.clientId,
  clientSecret: config.auth0.clientSecret,
  issuerBaseURL: `https://${config.auth0.domain}`,
  routes: {
    callback: '/callback',
    postLogoutRedirect: config.frontend.url
  },
  authorizationParams: {
    response_type: 'code',
    scope: 'openid profile email'
  }
};

app.use(auth(auth0Config));

// Basic routes
app.get('/', (req, res) => {
  if (req.oidc.isAuthenticated()) {
    res.redirect(config.frontend.url);
  } else {
    res.send('Logged out');
  }
});

// Protected API route
app.get('/api/auth/user', (req, res) => {
  res.setHeader('Content-Type', 'application/json');
  try {
    console.log('Auth state:', {
      isAuthenticated: req.oidc?.isAuthenticated(),
      user: req.oidc?.user,
      session: req.oidc?.idTokenClaims
    });

    if (req.oidc?.isAuthenticated() && req.oidc?.user) {
      const userData = {
        ...req.oidc.user,
        email: req.oidc.user.email || req.oidc.idTokenClaims?.email,
        name: req.oidc.user.name || req.oidc.idTokenClaims?.name
      };
      console.log('Sending user data:', userData);
      res.json(userData);
    } else {
      console.log('User not authenticated, sending null');
      res.json(null);
    }
  } catch (error) {
    console.error('User route error:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

// Add session debug route
app.get('/debug/session', (req, res) => {
  res.json({
    isAuthenticated: req.oidc?.isAuthenticated(),
    user: req.oidc?.user,
    claims: req.oidc?.idTokenClaims,
    accessToken: req.oidc?.accessToken,
  });
});

// Import routes
const deploymentRoutes = require('./routes/deployments');

// Use routes
app.use('/api/deployments', deploymentRoutes);

// Add callback route handler
app.get('/callback', (req, res) => {
  if (req.oidc.isAuthenticated()) {
    res.redirect(config.frontend.url);
  } else {
    res.redirect(`${config.frontend.url}/login`);
  }
});

app.listen(config.port, () => {
  console.log(`Server running on port ${config.port}`);
});