// server.js
const express = require('express');
const mongoose = require('mongoose');
const cors = require('cors');
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const app = express();
// Middleware
app.use(cors());
app.use(express.json());
// MongoDB Models
const User = require('./models/User');
const Application = require('./models/Application');
const Message = require('./models/Message');
// AI Service Integration
const AIService = require('./services/aiService');
// Authentication middleware
const auth = require('./middleware/auth');
// User Registration
app.post('/api/register', async (req, res) => {
  try {
    const { email, password, name, userType } = req.body;
    
    // Check if user exists
    let user = await User.findOne({ email });
    if (user) {
      return res.status(400).json({ message: 'User already exists' });
    }
    // Create new user
    user = new User({
      name,
      email,
      password: await bcrypt.hash(password, 10),
      userType: userType || 'founder'
    });
    await user.save();
    // Generate JWT token
    const token = jwt.sign(
      { userId: user._id }, 
      process.env.JWT_SECRET, 
      { expiresIn: '24h' }
    );
    res.status(201).json({
      token,
      user: {
        id: user._id,
        name: user.name,
        email: user.email,
        userType: user.userType
      }
    });
  } catch (error) {
    res.status(500).json({ message: 'Server error' });
  }
});
// User Login
app.post('/api/login', async (req, res) => {
  try {
    const { email, password } = req.body;
    
    const user = await User.findOne({ email });
    if (!user) {
      return res.status(400).json({ message: 'Invalid credentials' });
    }
    const isMatch = await bcrypt.compare(password, user.password);
    if (!isMatch) {
      return res.status(400).json({ message: 'Invalid credentials' });
    }
    const token = jwt.sign(
      { userId: user._id },
      process.env.JWT_SECRET,
      { expiresIn: '24h' }
    );
    res.json({
      token,
      user: {
        id: user._id,
        name: user.name,
        email: user.email,
        userType: user.userType
      }
    });
  } catch (error) {
    res.status(500).json({ message: 'Server error' });
  }
});
// Submit Application
app.post('/api/applications', auth, async (req, res) => {
  try {
    const application = new Application({
      ...req.body,
      user: req.userId,
      status: 'submitted'
    });
    await application.save();
    // AI Analysis of Application
    const aiAnalysis = await AIService.analyzeApplication(application);
    application.aiAnalysis = aiAnalysis;
    await application.save();
    res.status(201).json(application);
  } catch (error) {
    res.status(500).json({ message: 'Server error' });
  }
});
// AI Chat with Users
app.post('/api/chat', auth, async (req, res) => {
  try {
    const { message, applicationId, context } = req.body;
    
    const application = await Application.findById(applicationId);
    if (!application) {
      return res.status(404).json({ message: 'Application not found' });
    }
    // Generate AI response
    const aiResponse = await AIService.generateResponse({
      userMessage: message,
      application: application,
      context: context || 'general',
      userId: req.userId
    });
    // Save message to database
    const chatMessage = new Message({
      application: applicationId,
      sender: req.userId,
      message: message,
      aiResponse: aiResponse,
      timestamp: new Date()
    });
    await chatMessage.save();
    res.json({
      response: aiResponse,
      messageId: chatMessage._id
    });
  } catch (error) {
    res.status(500).json({ message: 'Server error' });
  }
});
// Get Application Messages
app.get('/api/applications/:id/messages', auth, async (req, res) => {
  try {
    const messages = await Message.find({
      application: req.params.id
    }).sort({ timestamp: 1 });
    res.json(messages);
  } catch (error) {
    res.status(500).json({ message: 'Server error' });
  }
});
// AI Service for Application Analysis
app.post('/api/analyze-application/:id', auth, async (req, res) => {
  try {
    const application = await Application.findById(req.params.id);
    
    if (!application) {
      return res.status(404).json({ message: 'Application not found' });
    }
    const analysis = await AIService.comprehensiveAnalysis(application);
    
    application.aiAnalysis = analysis;
    await application.save();
    res.json(analysis);
  } catch (error) {
    res.status(500).json({ message: 'Server error' });
  }
});
const PORT = process.env.PORT || 5000;
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});