server.js

import express from "express";
import cors from "cors";
import axios from "axios";
import bcrypt from "bcrypt";
import jwt from "jsonwebtoken";
import pkg from "pg";
const { Pool } = pkg;

const app = express();
app.use(express.json());
app.use(cors());

// ----------------------------------------------------------
// DATABASE
// ----------------------------------------------------------
const pool = new Pool({
  user: "beyzacavusoglu",
  host: "localhost",
  database: "chatbot_db",
  password: "",
  port: 5432,
});

// ----------------------------------------------------------
// JWT CONFIG
// ----------------------------------------------------------
const JWT_SECRET = "supersecretkey";

function authMiddleware(req, res, next) {
  const authHeader = req.headers.authorization;
  if (!authHeader) return res.status(401).json({ error: "No token provided" });

  const token = authHeader.split(" ")[1];
  try {
    const decoded = jwt.verify(token, JWT_SECRET);
    req.userId = decoded.userId;
    next();
  } catch (err) {
    res.status(401).json({ error: "Invalid token" });
  }
}

// ----------------------------------------------------------
// AUTH ROUTES
// ----------------------------------------------------------
app.post("/api/signup", async (req, res) => {
  const { name, email, password } = req.body;
  try {
    const hash = await bcrypt.hash(password, 10);
    await pool.query(
      "INSERT INTO users (name, email, password_hash) VALUES ($1, $2, $3)",
      [name, email, hash]
    );
    res.json({ success: true });
  } catch (e) {
    res.status(400).json({ error: e.message });
  }
});

app.post("/api/login", async (req, res) => {
  const { email, password } = req.body;
  try {
    const result = await pool.query("SELECT * FROM users WHERE email=$1", [email]);
    const user = result.rows[0];
    if (!user) return res.status(400).json({ error: "User not found" });

    const valid = await bcrypt.compare(password, user.password_hash);
    if (!valid) return res.status(400).json({ error: "Invalid password" });

    const token = jwt.sign({ userId: user.id }, JWT_SECRET, { expiresIn: "2h" });
res.json({
  token,
  user: { name: user.name, email: user.email },
});
  } catch (e) {
    res.status(500).json({ error: e.message });
  }
});

// ----------------------------------------------------------
// CHAT ROUTE — Connects to FastAPI microservice
// ----------------------------------------------------------
app.post("/api/chat", authMiddleware, async (req, res) => {
  try {
    const { message, language } = req.body;

    //  user id as thread_id to maintain chat memory per user
    const response = await axios.post("http://127.0.0.1:8000/chat", {
      message,
      language: language || "English",
      thread_id: String(req.userId),
    });

    const reply =
      typeof response.data.reply === "string"
        ? response.data.reply
        : JSON.stringify(response.data.reply);

    // Saving message in chat_sessions
    await pool.query(
      "INSERT INTO chat_sessions (user_id, messages, created_at) VALUES ($1, $2, NOW())",
      [req.userId, JSON.stringify({ user: message, bot: reply })]
    );

    res.json({ reply });
  } catch (error) {
    console.error("Chat error:", error.response?.data || error.message);
    res.status(500).json({ error: "Chat failed" });
  }
});

// ----------------------------------------------------------
// HOSPITALS & DOCTORS ROUTES
// ----------------------------------------------------------
app.get("/api/hospitals", async (req, res) => {
  try {
    const result = await pool.query("SELECT * FROM hospitals ORDER BY id");
    res.json(result.rows);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

app.get("/api/doctors/:hospitalId", async (req, res) => {
  try {
    const { hospitalId } = req.params;
    const result = await pool.query(
      "SELECT * FROM doctors WHERE hospital_id=$1 ORDER BY id",
      [hospitalId]
    );
    res.json(result.rows);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// ----------------------------------------------------------
// APPOINTMENTS ROUTES
// ----------------------------------------------------------
app.post("/api/appointments", authMiddleware, async (req, res) => {
  const { doctor_id, hospital_id, date, notes } = req.body;
  try {
    const result = await pool.query(
      `INSERT INTO appointments (user_id, doctor_id, hospital_id, date, notes)
       VALUES ($1, $2, $3, $4, $5)
       RETURNING *`,
      [req.userId, doctor_id, hospital_id, date, notes]
    );
    res.json({ success: true, appointment: result.rows[0] });
  } catch (err) {
    if (err.code === "23505") {
      res.status(400).json({ error: "That doctor already has an appointment at that time." });
    } else {
      res.status(500).json({ error: err.message });
    }
  }
});

app.get("/api/appointments", authMiddleware, async (req, res) => {
  try {
    const result = await pool.query(
      `SELECT a.*, d.name AS doctor_name, h.name AS hospital_name
       FROM appointments a
       JOIN doctors d ON a.doctor_id = d.id
       JOIN hospitals h ON a.hospital_id = h.id
       WHERE a.user_id=$1
       ORDER BY a.date`,
      [req.userId]
    );
    res.json(result.rows);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

app.delete("/api/appointments/:id", authMiddleware, async (req, res) => {
  try {
    await pool.query("DELETE FROM appointments WHERE id=$1 AND user_id=$2", [
      req.params.id,
      req.userId,
    ]);
    res.json({ success: true });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

app.listen(3001, () =>
  console.log("🚀 Node backend running on http://localhost:3001")
);