import { promises as fs } from "fs";
import OpenAI from "openai";
import path from "path";
import { fileURLToPath } from "url";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const knowledgeFile = path.resolve(__dirname, "../../data/bridgeup.txt");

const HF_ENDPOINT =
  process.env.HF_ENDPOINT ||
  "https://f2k9nqxahy3hkdew.us-east-1.aws.endpoints.huggingface.cloud/v1/";
const HF_TOKEN =
  process.env.HF_TOKEN ||
  process.env.HUGGINGFACEHUB_API_TOKEN ||
  process.env.HUGGING_FACE_HUB_TOKEN ||
  "";
const MODEL_ID = process.env.MODEL_ID || "trucmtnguyen/bridgeup-ai-recommendation-insight";
const MAX_HISTORY = 6;
const KNOWLEDGE_CHAR_LIMIT = 10000;
const UPSTREAM_TIMEOUT_MS = Number(process.env.HF_TIMEOUT_MS || 20000);

const hfClient = HF_TOKEN
  ? new OpenAI({
      baseURL: HF_ENDPOINT,
      apiKey: HF_TOKEN,
      timeout: UPSTREAM_TIMEOUT_MS,
    })
  : null;

let cachedKnowledge = "";

function normalizeText(text) {
  return (text || "")
    .toLowerCase()
    .normalize("NFD")
    .replace(/[\u0300-\u036f]/g, "")
    .replace(/[^\p{L}\p{N}\s]/gu, " ")
    .replace(/\s+/g, " ")
    .trim();
}

function isGreeting(text) {
  const t = normalizeText(text);
  const greetings = ["hello", "heloo", "hi", "xin chao", "chao", "hey", "alo", "bot"];
  return greetings.some((g) => t === g || t.startsWith(`${g} `));
}

function isLearnCapCourseIntent(text) {
  const t = normalizeText(text);
  return (
    t.includes("khoa hoc learncap") ||
    t.includes("khoa hoc cua learncap") ||
    t.includes("danh sach khoa hoc learncap") ||
    t.includes("learncap co khoa hoc gi")
  );
}

function buildLearnCapCourseAnswer() {
  return [
    "LearnCap hiện có **32 khóa học**, chia thành 3 nhóm chính.",
    "",
    "Một số khóa học tiêu biểu:",
    "- Nhóm 1: Vòng xoay hạnh phúc, Phá kén, Bánh mì từ tâm, Ước nguyện của gỗ.",
    "- Nhóm 2: Buông, Món quà của ngoại, Dòng chảy ngầm, Fix bug.",
    "- Nhóm 3: Tôi hẹn Tôi, Mùa Quả Chín, Self On-boarding, CV thứ 17.",
    "",
    "Đặc điểm chung:",
    "- Thời lượng ngắn, chủ yếu từ 3-15 phút (micro-learning).",
    "- Tập trung vào phát triển nội lực, trưởng thành cá nhân, định hướng nghề nghiệp, chữa lành và thích nghi.",
    "",
    "Nếu bạn muốn, mình có thể liệt kê **đầy đủ 32 khóa học** theo từng nhóm ngay trong tin nhắn tiếp theo.",
  ].join("\n");
}

async function loadKnowledge() {
  if (cachedKnowledge) return cachedKnowledge;
  try {
    const raw = await fs.readFile(knowledgeFile, "utf8");
    cachedKnowledge = raw.slice(0, KNOWLEDGE_CHAR_LIMIT);
  } catch {
    cachedKnowledge = "";
  }
  return cachedKnowledge;
}

function normalizeHistory(history) {
  if (!Array.isArray(history)) return [];
  return history
    .filter((item) => item && typeof item.role === "string" && typeof item.content === "string")
    .map((item) => ({
      role: item.role === "assistant" ? "assistant" : "user",
      content: item.content,
    }))
    .slice(-MAX_HISTORY * 2);
}

function buildMessages(message, history, knowledge) {
  const msgs = [
    {
      role: "system",
      content:
        "Bạn là AI Assistant tiếng Việt của BridgeUp. Trả lời ngắn gọn, rõ ràng, đúng trọng tâm, ưu tiên dữ liệu trong ngữ cảnh được cung cấp.",
    },
  ];

  if (knowledge) {
    msgs.push({
      role: "system",
      content: `Ngữ cảnh BridgeUp:\n${knowledge}`,
    });
  }

  msgs.push(...history);
  msgs.push({ role: "user", content: message });
  return msgs;
}

async function requestChatCompletion(messages) {
  if (!hfClient) {
    return { ok: false, status: 500, error: "Missing HF_TOKEN" };
  }

  try {
    const completion = await hfClient.chat.completions.create({
      model: MODEL_ID,
      messages,
      temperature: 0.2,
      max_tokens: 700,
    });

    const answer = completion.choices?.[0]?.message?.content?.trim() || "";
    return { ok: true, answer };
  } catch (error) {
    const status = error?.status || error?.code || 500;
    const message = error?.message || "HF request failed";
    return { ok: false, status: Number(status) || 500, error: message };
  }
}

export async function warmupAiChatbot() {
  if (!hfClient) {
    return { ok: false, status: 500, message: "Missing HF_TOKEN" };
  }

  try {
    const completion = await hfClient.chat.completions.create({
      model: MODEL_ID,
      messages: [
        { role: "system", content: "Bạn là AI Assistant tiếng Việt của BridgeUp." },
        { role: "user", content: "Warmup" },
      ],
      temperature: 0,
      max_tokens: 8,
    });

    const warmed = Boolean(completion?.choices?.length);
    return { ok: warmed, status: warmed ? 200 : 503, message: warmed ? "Warmed up" : "Warmup failed" };
  } catch (error) {
    return { ok: false, status: error?.status || 503, message: error?.message || "Warmup failed" };
  }
}

export async function askAiChatbot({ message, history }) {
  if (!message?.trim()) {
    return { status: 400, body: { error: "Missing message" } };
  }

  try {
    if (isGreeting(message)) {
      return {
        status: 200,
        body: {
          answer: "Xin chào bạn. Mình là BridgeUp Coach. Bạn muốn tìm hiểu GrowCap, LearnCap hay ChallengeCap?",
          provider: "shortcut-greeting",
        },
      };
    }

    if (isLearnCapCourseIntent(message)) {
      return {
        status: 200,
        body: {
          answer: buildLearnCapCourseAnswer(),
          provider: "shortcut-learncap-courses",
        },
      };
    }

    const knowledge = await loadKnowledge();
    const normalizedHistory = normalizeHistory(history);
    const messages = buildMessages(message.trim(), normalizedHistory, knowledge);
    const result = await requestChatCompletion(messages);

    if (!result.ok) {
      if (result.status === 503) {
        return {
          status: 200,
          body: {
            answer:
              "Hiện endpoint AI đang bận (503). Mình vẫn có thể hỗ trợ câu hỏi chung về BridgeUp: GrowCap, LearnCap, ChallengeCap, hoặc hệ sinh thái tổng quan.",
            provider: "fallback-service-unavailable",
          },
        };
      }

      if (result.status === 504) {
        return {
          status: 200,
          body: {
            answer: "Kết nối AI bị timeout. Bạn thử lại giúp mình nhé.",
            provider: "fallback-timeout",
          },
        };
      }

      return {
        status: result.status || 500,
        body: { error: result.error || "AI chatbot request failed." },
      };
    }

    return {
      status: 200,
      body: {
        answer: result.answer || "Không có phản hồi.",
      },
    };
  } catch (error) {
    return {
      status: 500,
      body: {
        error: "AI chatbot request failed.",
        details: error.message,
      },
    };
  }
}

export async function streamAiChatbot({ message, history, res }) {
  if (!message?.trim()) {
    res.status(400).json({ error: "Missing message" });
    return;
  }

  if (!hfClient) {
    res.status(500).json({ error: "Missing HF_TOKEN" });
    return;
  }

  if (isGreeting(message)) {
    res.setHeader("Content-Type", "text/plain; charset=utf-8");
    res.setHeader("Cache-Control", "no-cache");
    res.setHeader("Connection", "keep-alive");
    res.write("Xin chào bạn. Mình là BridgeUp Coach. Bạn muốn tìm hiểu GrowCap, LearnCap hay ChallengeCap?");
    res.end();
    return;
  }

  if (isLearnCapCourseIntent(message)) {
    res.setHeader("Content-Type", "text/plain; charset=utf-8");
    res.setHeader("Cache-Control", "no-cache");
    res.setHeader("Connection", "keep-alive");
    res.write(buildLearnCapCourseAnswer());
    res.end();
    return;
  }

  try {
    const knowledge = await loadKnowledge();
    const normalizedHistory = normalizeHistory(history);
    const messages = buildMessages(message.trim(), normalizedHistory, knowledge);

    const stream = await hfClient.chat.completions.create({
      model: MODEL_ID,
      messages,
      temperature: 0.2,
      max_tokens: 700,
      stream: true,
    });

    res.setHeader("Content-Type", "text/plain; charset=utf-8");
    res.setHeader("Cache-Control", "no-cache");
    res.setHeader("Connection", "keep-alive");

    for await (const chunk of stream) {
      const delta = chunk?.choices?.[0]?.delta?.content || "";
      if (delta) res.write(delta);
    }

    res.end();
  } catch (error) {
    const status = error?.status || 500;

    if (status === 503) {
      res.setHeader("Content-Type", "text/plain; charset=utf-8");
      res.setHeader("Cache-Control", "no-cache");
      res.setHeader("Connection", "keep-alive");
      res.write(
        "Hiện endpoint AI đang bận (503). Bạn có thể thử lại sau ít phút hoặc hỏi ngắn gọn hơn để mình hỗ trợ theo dữ liệu BridgeUp sẵn có."
      );
      res.end();
      return;
    }

    if (status === 408 || status === 504) {
      res.setHeader("Content-Type", "text/plain; charset=utf-8");
      res.setHeader("Cache-Control", "no-cache");
      res.setHeader("Connection", "keep-alive");
      res.write("Kết nối AI bị timeout. Bạn thử lại giúp mình nhé.");
      res.end();
      return;
    }

    if (!res.headersSent) {
      res.status(500).json({ error: error?.message || "HF stream failed" });
    } else {
      res.end();
    }
  }
}
