background.js

import { KEY } from "./config.js";
import "./libs/pdf/pdf.mjs";
pdfjsLib.GlobalWorkerOptions.workerSrc = chrome.runtime.getURL("libs/pdf/pdf.worker.mjs");

async function detectGDPRFromIP() {
    try {
        console.log("Starting IP detection (ipinfo.io)...");

        const response = await fetch("https://ipinfo.io/json", {
            cache: "no-store"
        });

        const data = await response.json();

        const countryCode = data.country || "Unknown";

        console.log("[Location] Country Code:", countryCode);

        const gdprCountries = [
            "AT","BE","BG","HR","CY","CZ","DK","EE","FI","FR",
            "DE","GR","HU","IE","IT","LV","LT","LU","MT","NL",
            "PL","PT","RO","SK","SI","ES","SE"
        ];

        const applies = gdprCountries.includes(countryCode);

        await chrome.storage.local.set({
            userCountry: countryCode,
            userCountryName: data.country,
            gdprApplies: applies,
            lastLocationCheck: Date.now()
        });

        console.log("Location stored successfully.");

    } catch (err) {
        console.error("[Location] Detection failed:", err);
    }
}

async function loadLawText(countryCode) {
    try {
        const fileMap = {
            QA: "laws/Qatar.pdf",
            SA: "laws/Saudi.pdf",
            BH: "laws/Bahrain.pdf",
            JO: "laws/Jordan.pdf",
            AE: "laws/UAE.pdf",
            ES: "laws/GDPR.pdf"
        };

        const filePath = fileMap[countryCode];
        if (!filePath) return "";

        const response = await fetch(chrome.runtime.getURL(filePath));
        const arrayBuffer = await response.arrayBuffer();

        const pdf = await pdfjsLib.getDocument({ data: arrayBuffer }).promise;

        let fullText = "";

        for (let i = 1; i <= pdf.numPages; i++) {
            const page = await pdf.getPage(i);
            const content = await page.getTextContent();
            const strings = content.items.map(item => item.str);
            fullText += strings.join(" ") + " ";
        }

        return fullText;

    } catch (err) {
        console.error("Law loading failed:", err);
        return "";
    }
}

let personalizationConfigCache = null;

function loadPersonalizationConfig() {
    if (personalizationConfigCache) {
        return Promise.resolve(personalizationConfigCache);
    }

    const url = chrome.runtime.getURL("runtime_personalization.json");

    return fetch(url)
        .then(response => {
            if (!response.ok) {
                throw new Error(`Could not load runtime_personalization.json: ${response.status}`);
            }
            return response.json();
        })
        .then(data => {
            personalizationConfigCache = data;
            return data;
        })
        .catch(() => null);
}

function normalizeQuestions(userQA) {
    if (!Array.isArray(userQA)) return [];
    return userQA
        .filter(q => typeof q === "string" && q.trim().length > 0)
        .map(q => q.trim().toLowerCase());
}

function inferConcernFromConfig(userQA, config) {
    const questions = normalizeQuestions(userQA);
    const combined = questions.join(" ");

    if (!combined || !config?.profiles) return "general_privacy";

    let bestConcern = "general_privacy";
    let bestScore = 0;

    for (const [concern, profile] of Object.entries(config.profiles)) {
        const keywords = profile.keywords || [];
        let score = 0;

        for (const keyword of keywords) {
            if (combined.includes(String(keyword).toLowerCase())) {
                score++;
            }
        }

        if (score > bestScore) {
            bestScore = score;
            bestConcern = concern;
        }
    }

    return bestConcern;
}

function getRecommendationFromConfig(concern, config, userQA) {
    const selected = config?.profiles?.[concern] || null;
    if (!selected) return null;

    return {
        focusLabel: selected.focus_label || concern,
        recommendation: selected.recommendation || "",
        latestQuestion: userQA[userQA.length - 1] || ""
    };
}

chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {

    if (request.action === "detectGDPR") {
        detectGDPRFromIP();
        sendResponse({ status: "started" });
        return true;
    }

    if (request.action === "forceLocationCheck") {
        (async () => {
            await detectGDPRFromIP();
            const data = await chrome.storage.local.get(["userCountry", "gdprApplies"]);
            sendResponse(data);
        })();
        return true;
    }

    // Handle message requests from popup.js
    if (request.action === "processText") {

        (async () => {
            try {
                await detectGDPRFromIP();

                const data = await chrome.storage.local.get(["userCountry"]);

                const country = data.userCountry;
                const lawText = await loadLawText(country);

                const userQA = request.userQA || [];

                const config = await loadPersonalizationConfig();

                let personalization = null;

                if (userQA.length > 0 && config) {
                    const inferredConcern = inferConcernFromConfig(userQA, config);
                    personalization = getRecommendationFromConfig(inferredConcern, config, userQA);
                }

                let prompt = `
You are a legal AI assistant.

The following is the official data protection law applicable in the user's country (${country}):

${lawText.slice(0, 6000)}

Now simplify the following privacy policy.

Instructions:
- Simplify to 10th-grade level.
- Keep legal meaning accurate.
- Align explanation with the applicable national data protection law.
- Use short paragraphs.
- Use clear bullet points.
- Do NOT omit important legal information.
- Make the explanation easy to understand.
- Output language: ${request.language === "ar" ? "Modern Standard Arabic" : "English"}.
`;

                if (personalization && personalization.recommendation) {
                    prompt += `
The user previously asked:
"${personalization.latestQuestion}"

Their likely main concern:
${personalization.focusLabel}

Use this guidance:
${personalization.recommendation}

IMPORTANT LEGAL REQUIREMENT:
- You MUST maintain alignment with the national data protection law.
- You MUST reference specific article numbers where relevant.
- Legal contextualization must NOT be removed due to personalization.

Structure:
1) Provide the legally aligned simplified summary first.
2) Then add a clearly visible section titled "Personalized Recommendations".
3) The personalized section must support the legal rights mentioned above.
`;
                }

                prompt += `
Privacy Policy:
${request.text}
`;

                const response = await fetch("https://api.openai.com/v1/chat/completions", {
                    method: "POST",
                    headers: {
                        "Content-Type": "application/json",
                        "Authorization": `Bearer ${KEY}`,
                    },
                    body: JSON.stringify({
                        model: "gpt-4.1-mini",
                        messages: [
                            {
                                role: "system",
                                content: "You simplify privacy policies, ensure legal alignment, and personalize responses when relevant."
                            },
                            {
                                role: "user",
                                content: prompt
                            }
                        ],
                        temperature: 0.6,
                        max_tokens: 1500,
                    })
                });

                const result = await response.json();

                if (result.error) {
                    sendResponse({ summary: result.error.message });
                    return;
                }

                const simplifiedText =
                    result.choices?.[0]?.message?.content ||
                    "Unexpected API response format.";

                sendResponse({ summary: simplifiedText });

                if (request.deliveryMode === "audio") {
                    const utterance = new SpeechSynthesisUtterance(simplifiedText);
                    utterance.lang = request.language === "ar" ? "ar-SA" : "en-US";
                    speechSynthesis.speak(utterance);
                }

            } catch (err) {
                console.error("ProcessText Error:", err);
                sendResponse({ summary: "Error generating response." });
            }
        })();

        return true;
    }

    // Handle question and answer based on privacy policy
    if (request.action === "askQuestion") {

        (async () => {
            try {
                const data = await new Promise(resolve =>
                    chrome.storage.local.get(["userCountry"], resolve)
                );

                const country = data.userCountry;
                const lawText = await loadLawText(country);

                const policyText = request.policyText || "";

                const prompt = `
You are a legal AI assistant.

The following is the official data protection law applicable in the user's country (${country}):

${lawText.slice(0, 4000)}

Below is the privacy policy text:

${policyText}

Now answer the user's question.

IMPORTANT:
- You MUST use the provided privacy policy text.
- You MUST reference the specific article number(s) from the national data protection law when relevant.
- If applicable, explicitly mention the article number.
- Do NOT ask the user to provide the policy again.
- Assume the policy above is complete.

User Question:
${request.question}
`;

                const response = await fetch("https://api.openai.com/v1/chat/completions", {
                    method: "POST",
                    headers: {
                        "Content-Type": "application/json",
                        "Authorization": `Bearer ${KEY}`
                    },
                    body: JSON.stringify({
                        model: "gpt-4.1-mini",
                        messages: [
                            {
                                role: "system",
                                content: "You answer privacy questions and reference exact legal articles when applicable."
                            },
                            {
                                role: "user",
                                content: prompt
                            }
                        ],
                        temperature: 0.4,
                        max_tokens: 1000
                    })
                });

                const result = await response.json();

                sendResponse({
                    answer: result.choices?.[0]?.message?.content || "Sorry, I couldn’t generate a response."
                });

            } catch (err) {
                console.error("Q&A Error:", err);
                sendResponse({ answer: "There was an error generating the answer." });
            }
        })();

        return true;
    }
});

// Translation Function to Arabic (Optimized)
function translateToArabic(text, sendResponse) {
    // Using OpenAI's GPT model for translation
    const prompt = `
        You are a translation assistant. Translate the following text into Arabic while keeping the meaning accurate:

        Text:
        ${text}
    `;

    fetch("https://api.openai.com/v1/chat/completions", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            "Authorization": `Bearer ${KEY}`,
        },
        body: JSON.stringify({
            model: "gpt-4.1-mini",
            messages: [
                { "role": "system", "content": "You are a translator that translates text from English to Arabic." },
                { "role": "user", "content": prompt },
            ],
            temperature: 0.7,
            max_tokens: 1500,
        })
    })
        .then(response => response.json())
        .then(data => {
            if (data.error) {
                console.error("Translation API Error:", data.error);
                sendResponse({ summary: "Error: Unable to translate." });
                return;
            }

            // Send the translated Arabic text
            const arabicText = data.choices[0]?.message?.content || "Error: Unexpected API response format.";
            sendResponse({ summary: arabicText });
        })
        .catch(error => {
            console.error("Translation Error:", error);
            sendResponse({ summary: "Error: Unable to translate." });
        });
}
;

chrome.runtime.onInstalled.addListener(() => {
    detectGDPRFromIP();
});

chrome.runtime.onStartup.addListener(() => {
    detectGDPRFromIP();
});