Function bodies 169 total

export function useAuth() {
    const router = useRouter();
    const { setUser, clearUser } = useAuthStore();
    const [loading, setLoading] = useState(true);
    const [error, setError] = useState(null);

    useEffect(() => {
        const checkAuth = async () => {
            setLoading(true); // Start loading at the beginning of the function
            try {
                const response = await fetch("/api/auth/session");
                if (response.ok) {
                    const user = await response.json();
                    if (user.isLoggedIn) {
                        setUser({
                            email: user.email,
                            userId: user.userId,
                            name: user.name,
                            isAdmin: user.isAdmin,
                            role: user.role,
                        }); // Pass complete user data
                    } else {
                        clearUser();
                    }
                }

export function requireAdmin(req) {
  const token = req.cookies.get("auth")?.value;
  if (!token) {
    return NextResponse.json({ message: "Not authenticated" }, { status: 401 });
  }

  let payload;
  try {
    payload = verify(token, process.env.JWT_SECRET || "your-secret-key");
  } catch {
    return NextResponse.json({ message: "Invalid token" }, { status: 401 });
  }

  console.log("Decoded JWT payload:", payload);


  if (!payload.isAdmin && payload.role !== "editor") {
    return NextResponse.json({ message: "Forbidden" }, { status: 403 });
  }

  return payload;
}

export function createAuthCookie(user) {
    const token = sign(
        {
            email: user.email,
            id: user.id,
            role: user.role,
            name: `${user.first_name} ${user.last_name}`,
        },
        process.env.JWT_SECRET,
        { expiresIn: "1d" }
    );

    return serialize("auth", token, {
        httpOnly: true,
        secure: process.env.NODE_ENV === "production",
        sameSite: "strict",
        maxAge: 86400,
        path: "/",
    });
}

export async function query(text, params) {
    try {
        const start = Date.now();
        const res = await pool.query(text, params);
        const duration = Date.now() - start;
        console.log("Executed query", { text, duration, rows: res.rowCount });
        return res;
    } catch (error) {
        console.error("Error executing query", error);
        throw error;
    }
}

export async function sendMagicLinkEmail({ tenant, email, url }) {
    const magicUrl = url; // EXACT URL passed from create route

    const transporter = nodemailer.createTransport({
        host: "smtp.gmail.com",
        port: 587,
        secure: false,
        auth: {
            user: process.env.EMAIL_USER,
            pass: process.env.EMAIL_PASS,
        },
    });

    await transporter.sendMail({
        from: `"Simplified Login" <${process.env.EMAIL_USER}>`,
        to: email,
        subject: "Your Magic Login Link",
        html: `
            <p>Click to sign in:</p>
            <a href="${magicUrl}" style="color: #4cb19f; font-size: 18px;">
                Login to your account
            </a>
            <p>This link expires in 30 days.</p>
        `,
    });

    return true;
}

export function getArticleIdFromHsfId(hsfId) {
  return hsfIdToArticleId[hsfId] || null;
}

export async function storeMagicLink({ tenant, email, tokenHash, redirectUrl }) {
    const pool = getTenantPool(tenant);

    await pool.query(
        `INSERT INTO magic_links (email, token_hash, redirect_url)
         VALUES ($1, $2, $3)`,
        [email, tokenHash, redirectUrl]
    );
}

export async function getMagicLinkRecord(tenant, tokenHash) {
    const pool = getTenantPool(tenant);

    const result = await pool.query(
        `SELECT * FROM magic_links 
         WHERE token_hash = $1 AND used = FALSE`,
        [tokenHash]
    );

    return result.rows[0] || null;
}

export async function markTokenUsed(tenant, tokenHash) {
    const pool = getTenantPool(tenant);

    await pool.query(
        `UPDATE magic_links SET used = TRUE WHERE token_hash = $1`,
        [tokenHash]
    );
}

export function getTenantPool(tenant) {
  if (pools[tenant]) {
    return pools[tenant];
  }

  // // Load tenant-specific env file
  // dotenv.config({
  //   path: path.join(process.cwd(), `.env.${tenant}`),
  //   override: true, // <--- THIS IS WHAT MAKES ENV SWITCH
  // });

  // console.log(`🔄 Loaded env for tenant: ${tenant}`);
  console.log("→ Using DB:", {
    host: process.env.PGHOST,
    user: process.env.PGUSER,
    db: process.env.PGDATABASE,
  });

  const pool = new Pool({
    user: process.env.PGUSER,
    host: process.env.PGHOST,
    database: process.env.PGDATABASE,
    password: process.env.PGPASSWORD,
    port: parseInt(process.env.PGPORT || "5432"),
    ssl: {
      rejectUnauthorized: false,
      require: true,
    },
  });

  pools[tenant] = pool;
  return pool;
}

export async function tenantQuery(tenant, text, params) {
  const pool = getTenantPool(tenant);
  return pool.query(text, params);
}

export async function findUserByEmail(tenant, email) {
    const res = await tenantQuery(
        tenant,
        "SELECT * FROM users WHERE email = $1",
        [email]
    );
    return res.rows[0] || null;
}

export async function createUserIfNotExists(tenant, email) {
    let user = await findUserByEmail(tenant, email);

    if (!user) {
        const insert = await tenantQuery(
            tenant,
            "INSERT INTO users (email, role, first_name, last_name) VALUES ($1, 'user', '', '') RETURNING *",
            [email]
        );
        user = insert.rows[0];
    }

    return user;
}

export function cn(...inputs) {
  return twMerge(clsx(inputs));
}

export function cleanName(name) {
  return name.trim().replace(/\s*\d+$/, "");
}

export async function summarizeArticle(content) {
    try {
        const response = await openai.chat.completions.create({
            model: "gpt-4.1-nano", // Fastest OpenAI model for simple summarization
            messages: [
                {
                    role: "system",
                    content:
                        "Can you write this as 2-3 sentence teaser summary for a Scientific American article for a lay person. Please define key medical terms. Specify the year the article was written. Maximum of 280 characters",
                },
                { role: "user", content },
            ],
        });

        return response.choices[0].message.content.trim();
    } catch (error) {
        console.error("Error summarizing article:", error);
        throw error;
    }
}

export async function simplifyArticle(content, lengthString) {
    try {
        // NF-specific addendum for updated nomenclature
        const nfAddendum = tenant.shortName === "NF" ? `
IMPORTANT - NF NOMENCLATURE:
When discussing types of neurofibromatosis, use the current diagnostic terminology:
• "NF2" should be referred to as "NF2-related schwannomatosis" (NF2-SWN)
• The umbrella term "schwannomatosis" now includes NF2-related schwannomatosis and SMARCB1/LZTR1-related schwannomatosis
• When referring to all forms collectively, use "all forms of neurofibromatosis and schwannomatosis"
• If the source article uses older terminology (just "NF2"), you may update it to the current nomenclature while preserving the original meaning
` : "";

        const instruction = `
You simplify scientific articles into a patient-friendly science summary for readers who already have basic familiarity with the condition being discussed. Assume an informed patient or caregiver audience. Do NOT explain 

function markdownToHtml(markdown) {
    return marked(markdown);
}

async function testPMC(pmcId) {
    const url = `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=pmc&id=${pmcId}&retmode=xml`;
    console.log(`Fetching: ${url}\n`);

    const response = await fetch(url);
    const xml = await response.text();
    const parsed = await xml2js.parseStringPromise(xml, { explicitArray: false });

    const article = parsed?.["pmc-articleset"]?.article;
    const meta = article?.front?.["article-meta"];

    // Debug: print contrib-group structure
    console.log("=== contrib-group structure ===");
    console.log(JSON.stringify(meta?.["contrib-group"], null, 2));

    console.log("\n=== Extracting authors ===");

    // Current extraction logic
    const contribs = meta?.["contrib-group"]?.contrib;
    let authors = [];

    if (contribs) {
        const contribArray = Array.isArray(contribs) ? contribs : [contribs];
        console.log(`Found ${contribArray.length} contrib entries`);

        authors = contribArray.map((c, i) => {