server.js

const express = require('express');
const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const cors = require('cors');

// Initialize Express app
const app = express();
app.use(express.json());
app.use(cors());

// MongoDB connection setup
const MONGO_URI = 'mongodb://localhost:27017/personal_finance_tool'; // Replace with your MongoDB URI
mongoose.connect(MONGO_URI, { useNewUrlParser: true, useUnifiedTopology: true })
    .then(() => console.log('Connected to MongoDB'))
    .catch((err) => console.log('Failed to connect to MongoDB', err));

// JWT Secret
const JWT_SECRET = 'your_jwt_secret_key'; // Replace with a strong secret key

// User schema and model
const userSchema = new mongoose.Schema({
    name: { type: String, required: true },
    email: { type: String, required: true, unique: true },
    password: { type: String, required: true }
});

userSchema.pre('save', async function(next) {
    if (this.isModified('password')) {
        const salt = await bcrypt.genSalt(10);
        this.password = await bcrypt.hash(this.password, salt);
    }
    next();
});

const User = mongoose.model('User', userSchema);

// Transaction schema and model
const transactionSchema = new mongoose.Schema({
    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    date: { type: Date, required: true },
    type: { type: String, enum: ['Income', 'Expense', 'Savings'], required: true },
    amount: { type: Number, required: true },  // Ensure amount is a number
    category: { type: String, required: true },
    description: { type: String }
});

const Transaction = mongoose.model('Transaction', transactionSchema);

// Amount schema and model
const amountSchema = new mongoose.Schema({
    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
    totalIncome: { type: Number, default: 0 },  // Number for Income totals
    totalExpense: { type: Number, default: 0 }, // Number for Expense totals
    totalSavings: { type: Number, default: 0 }  // Number for Savings totals
});

const Amount = mongoose.model('Amount', amountSchema);

// Middleware to authenticate token
const authenticateToken = (req, res, next) => {
    const token = req.header('Authorization').split(' ')[1];
    if (!token) return res.status(401).json({ message: 'No token provided' });

    jwt.verify(token, JWT_SECRET, (err, user) => {
        if (err) return res.status(403).json({ message: 'Invalid token' });
        req.user = user;
        next();
    });
};

// User registration route
app.post('/api/register', async (req, res) => {
    const { name, email, password } = req.body;
    try {
        let user = await User.findOne({ email });
        if (user) return res.status(400).json({ message: 'User already exists' });

        user = new User({ name, email, password });
        await user.save();

        // Create an Amount record for the user
        const amount = new Amount({ userId: user._id });
        await amount.save();

        res.status(201).json({ message: 'User registered successfully' });
    } catch (error) {
        res.status(500).json({ message: 'Server error' });
    }
});

// User login route
app.post('/api/login', async (req, res) => {
    const { email, password } = req.body;
    try {
        const user = await User.findOne({ email });
        if (!user) return res.status(400).json({ message: 'Invalid email or password' });

        const isMatch = await bcrypt.compare(password, user.password);
        if (!isMatch) return res.status(400).json({ message: 'Invalid email or password' });

        const token = jwt.sign({ userId: user._id }, JWT_SECRET, { expiresIn: '1h' });
        res.json({ token });
    } catch (error) {
        res.status(500).json({ message: 'Server error' });
    }
});

// Add a new transaction and update the amount totals
app.post('/api/transactions', authenticateToken, async (req, res) => {
    const { type, amount, category, description } = req.body;
    try {
        const transaction = new Transaction({
            userId: req.user.userId,
            date: new Date(),
            type,
            amount: Number(amount),  // Ensure amount is treated as a number
            category,
            description
        });
        await transaction.save();

        // Update the totals in Amount table
        const userAmount = await Amount.findOne({ userId: req.user.userId });
        if (type === 'Income') {
            userAmount.totalIncome += Number(amount);
        } else if (type === 'Expense') {
            userAmount.totalExpense += Number(amount);
        } else if (type === 'Savings') {
            userAmount.totalSavings += Number(amount);
        }
        await userAmount.save();

        res.status(201).json({ message: 'Transaction saved and totals updated successfully' });
    } catch (error) {
        res.status(500).json({ message: 'Server error' });
    }
});

// Get all transactions for the logged-in user
app.get('/api/transactions', authenticateToken, async (req, res) => {
    try {
        const transactions = await Transaction.find({ userId: req.user.userId });
        res.json(transactions);
    } catch (error) {
        res.status(500).json({ message: 'Server error' });
    }
});

// Get transaction totals (income, expenses, savings) for the logged-in user
app.get('/api/transactions/totals', authenticateToken, async (req, res) => {
    try {
        const totals = await Amount.findOne({ userId: req.user.userId });
        res.json(totals);
    } catch (error) {
        res.status(500).json({ message: 'Server error' });
    }
});

// Start the server
const PORT = process.env.PORT || 5000;
app.listen(PORT, () => {
    console.log(`Server running on port ${PORT}`);
});