require('dotenv').config();

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

const app = express();

// Basic middleware
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(cors({
  origin: config.frontend.url,
  credentials: true
}));

// Connect to MongoDB with proper error handling
mongoose.connect(config.mongodb.uri, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
  serverSelectionTimeoutMS: 30000, // Increase timeout for Atlas
  socketTimeoutMS: 45000,
  retryWrites: true,
  w: 'majority',
  maxPoolSize: 10,
  minPoolSize: 2,
  retryAttempts: 3
})
.then(() => {
  console.log('Connected to MongoDB Atlas');
})
.catch(err => {
  console.error('MongoDB Atlas connection error:', err);
  if (err.name === 'MongoServerSelectionError') {
    console.error('Could not connect to MongoDB Atlas. Please check:');
    console.error('1. Network connectivity');
    console.error('2. IP whitelist in Atlas');
    console.error('3. Credentials in connection string');
  }
  process.exit(1);
});

// Add more detailed error handling
mongoose.connection.on('error', err => {
  console.error('MongoDB error:', err);
  if (err.name === 'MongoNetworkError') {
    console.log('Attempting to reconnect to MongoDB Atlas...');
  }
});

mongoose.connection.on('disconnected', () => {
  console.warn('MongoDB disconnected. Attempting to reconnect to Atlas...');
});

mongoose.connection.on('connected', () => {
  console.log('Successfully connected to MongoDB Atlas');
});

mongoose.connection.on('reconnected', () => {
  console.log('Successfully reconnected to MongoDB Atlas');
});

// Auth0 configuration
const auth0Config = {
  authRequired: false,
  auth0Logout: true,
  baseURL: config.server.url,
  clientID: config.auth0.clientId,
  issuerBaseURL: `https://${config.auth0.domain}`,
  secret: config.auth0.secret,
  routes: {
    login: false,  // Disable default login route
    logout: false  // Disable default logout route
  }
};

app.use(auth(auth0Config));

// Auth routes
app.get('/api/auth/login', (req, res) => {
  res.oidc.login({
    returnTo: config.frontend.url,
    authorizationParams: {
      redirect_uri: `${config.server.url}/callback`
    }
  });
});

app.get('/api/auth/logout', (req, res) => {
  res.oidc.logout({
    returnTo: config.frontend.url
  });
});

app.get('/api/auth/user', (req, res) => {
  if (req.oidc.isAuthenticated()) {
    res.json(req.oidc.user);
  } else {
    res.json(null);
  }
});

// Callback route
app.get('/callback', (req, res) => {
  res.redirect(config.frontend.url);
});

// Other routes...
const deploymentRoutes = require('./routes/deployments');
app.use('/api/deployments', deploymentRoutes);

// Start server
const port = config.port || 3001;
app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});