import jwt from "jsonwebtoken";
import mongoose from "mongoose";
import express from "express";
import request from "supertest";
import { MongoMemoryServer } from "mongodb-memory-server";
import User from "../models/userModel.js";

const JWT_KEY = "test-jwt-secret-key-for-testing";

const buildAppWithRoute = async () => {
  const { default: router } = await import(`../routes/farmerDetailsRoute.js?test=${Date.now()}`);
  const app = express();
  app.use(express.json());
  app.use("/api/farmer-details", router);
  return app;
};

describe("Language preference route", () => {
  let mongoServer;
  let app;
  let user;

  beforeAll(async () => {
    process.env.JWT_KEY = JWT_KEY;
    mongoServer = await MongoMemoryServer.create();
    await mongoose.connect(mongoServer.getUri("language_preference_tests"));
    app = await buildAppWithRoute();
  });

  afterAll(async () => {
    await mongoose.disconnect();
    await mongoServer.stop();
  });

  beforeEach(async () => {
    await User.deleteMany({});
    user = await User.create({
      name: "Language User",
      email: "language@example.com",
    });
  });

  const makeToken = (id) => jwt.sign({ id, role: "farmer" }, JWT_KEY, { expiresIn: "1h" });

  it("updates language for authenticated user", async () => {
    const token = makeToken(user._id.toString());
    const response = await request(app)
      .post("/api/farmer-details/user/preferences/language")
      .set("Authorization", `Bearer ${token}`)
      .send({ language: "hi" });

    expect(response.status).toBe(200);
    expect(response.body).toEqual({ success: true, language: "hi" });

    const updated = await User.findById(user._id);
    expect(updated.language).toBe("hi");
  });

  it("returns 400 for unsupported language", async () => {
    const token = makeToken(user._id.toString());
    const response = await request(app)
      .post("/api/farmer-details/user/preferences/language")
      .set("Authorization", `Bearer ${token}`)
      .send({ language: "xx" });

    expect(response.status).toBe(400);
    expect(response.body).toEqual({ message: "Invalid language" });
  });

  it("returns 404 when user is not found", async () => {
    const missingUserId = new mongoose.Types.ObjectId().toString();
    const token = makeToken(missingUserId);
    const response = await request(app)
      .post("/api/farmer-details/user/preferences/language")
      .set("Authorization", `Bearer ${token}`)
      .send({ language: "en" });

    expect(response.status).toBe(404);
    expect(response.body).toEqual({ message: "User not found" });
  });

  it("returns 401 when token is missing", async () => {
    const response = await request(app)
      .post("/api/farmer-details/user/preferences/language")
      .send({ language: "en" });

    expect(response.status).toBe(401);
    expect(response.body).toEqual({ message: "Access Denied, token missing" });
  });
});