import { EventEmitter } from "events";
import { connect } from "puppeteer-real-browser";
import { v4 as uuidV4 } from "uuid";
import path from "path";
import { fileURLToPath } from "url";
import { createDirectoryIfNotExists, sleep, extractPerplexityCookie, getPerplexitySessionCookie } from "../utils/cookieUtils.mjs";
import '../proxyAgent.mjs';
import { detectBrowser } from '../utils/browserDetector.mjs';
import NetworkMonitor from '../networkMonitor.mjs';
import io from 'socket.io-client';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

class PerplexityProvider {
    constructor(config) {
        this.config = config;
        this.sessions = {};
        // 可以是 'chrome', 'edge', 或 'auto'
        this.preferredBrowser = 'auto';
        this.networkMonitor = new NetworkMonitor();
    }

    async init(config) {
        console.log(`本项目依赖Chrome或Edge浏览器，请勿关闭弹出的浏览器窗口。如果出现错误请检查是否已安装Chrome或Edge浏览器。`);
        
        const browserPath = detectBrowser(this.preferredBrowser); // 检测Chrome和Edge浏览器
        
        this.sessions = {};
        const timeout = 120000;

        if (process.env.USE_MANUAL_LOGIN === "true") {
            this.sessions['manual_login'] = {
                configIndex: 0,
                valid: false,
            };
            console.log("当前使用手动登录模式，跳过config.mjs文件中的 cookie 验证");
        } else {
            // 使用配置文件中的 cookie
            for (let index = 0; index < config.sessions.length; index++) {
                const session = config.sessions[index];
                const extractedCookie = extractPerplexityCookie(session.cookie);

                if (extractedCookie.sessionToken) {
                    const uniqueId = `user_${index}`;
                    this.sessions[uniqueId] = {
                        configIndex: index,
                        ...extractedCookie,
                        valid: false,
                    };
                    console.log(`已添加 #${index} ${uniqueId} (Perplexity cookie)`);
                } else {
                    console.error(`第${index}个cookie无效，请重新获取。`);
                    console.error(`未检测到有效的__Secure-next-auth.session-token字段。`);
                }
            }
            console.log(`已添加 ${Object.keys(this.sessions).length} 个 cookie，开始验证有效性`);
        }

        for (const originalUsername of Object.keys(this.sessions)) {
            let currentUsername = originalUsername;
            let session = this.sessions[currentUsername];
            createDirectoryIfNotExists(path.join(__dirname, "browser_profiles", currentUsername));

            try {
                const response = await connect({
                    headless: "auto",
                    turnstile: true,
                    customConfig: {
                        userDataDir: path.join(__dirname, "browser_profiles", currentUsername),
                        executablePath: browserPath,
                    },
                });

                const {page, browser} = response;
                if (process.env.USE_MANUAL_LOGIN === "true") {
                    console.log(`正在为 session #${session.configIndex} 进行手动登录...`);
                    await page.goto("https://www.perplexity.ai", {timeout: timeout});
                    await sleep(3000);
                    console.log(`请在打开的浏览器窗口中手动登录 Perplexity.ai (session #${session.configIndex})`);
                    const { sessionCookie, accountStatus } = await this.waitForManualLogin(page);
                    if (sessionCookie) {
                        const email = accountStatus.username || 'unknown_user';
                        this.sessions[email] = {
                            ...session,
                            cookies: sessionCookie,
                            isPro: accountStatus.isPro,
                        };
                        delete this.sessions[currentUsername];
                        currentUsername = email;
                        session = this.sessions[currentUsername];


                        console.log(`成功获取 ${email} 登录的 cookie${accountStatus.isPro ? '（Pro 账号）' : ''}`);
                    } else {
                        console.error(`未能获取到 session #${session.configIndex} 有效登录的 cookie`);
                        await browser.close();
                        continue;
                    }
                } else {
                    // 使用已有的 cookie
                    const perplexityCookies = getPerplexitySessionCookie(session);
                    await page.setCookie(...perplexityCookies);
                    await page.goto("https://www.perplexity.ai", {timeout: timeout});
                    await sleep(5000);
                }

                // 如果遇到 Cloudflare 挑战就多等一段时间
                const pageContent = await page.content();
                if (pageContent.indexOf("challenges.cloudflare.com") > -1) {
                    console.log(`请在30秒内完成人机验证 (${currentUsername})`);
                    await page.evaluate(() => {
                        alert("请在30秒内完成人机验证");
                    });
                    await sleep(30000);
                }
                try {
                    const isValid = await this.validateSession(page);
                    if (isValid) {
                        session.valid = true;
                        session.browser = browser;
                        session.page = page;
                    } else {
                        console.warn(`警告: ${currentUsername} 验证失败。请检查cookie是否有效。`);
                        await this.clearPerplexityCookies(page);
                        await browser.close();
                    }
                } catch (e) {
                    console.warn(`警告: ${currentUsername} 验证失败。请检查cookie是否有效。`);
                    console.error(e);
                    await this.clearPerplexityCookies(page);
                    await browser.close();
                }

            } catch (e) {
                console.error(`初始化浏览器失败 (${currentUsername})`);
                console.error(e);
            }
        }

        console.log(`验证完毕，有效cookie数量 ${Object.keys(this.sessions).filter((username) => this.sessions[username].valid).length}`);
        // 开始网络监控
        await this.networkMonitor.startMonitoring();
    }

    async clearPerplexityCookies(page) {
        const client = await page.target().createCDPSession();
        await client.send('Network.clearBrowserCookies');
        await client.send('Network.clearBrowserCache');
        const cookies = await page.cookies('https://www.perplexity.ai');
        for (const cookie of cookies) {
            await page.deleteCookie(cookie);
        }
        console.log('已自动清理 cookie');
    }

    async checkAccountStatus(page) {
        if (process.env.USE_MANUAL_LOGIN !== "true" && process.env.INCOGNITO_MODE === "true") {
            try {
                await page.waitForSelector('div[class*="inline-flex w-full cursor-pointer select-none items-center justify-start gap-sm rounded-full"]', { timeout: 2000 });

                // 检查无痕模式图标
                const isIncognito = await page.evaluate(() => {
                    const incognitoElement = document.querySelector('div[class*="inline-flex w-full cursor-pointer select-none items-center justify-start gap-sm rounded-full"]');
                    return incognitoElement && incognitoElement.innerHTML.includes('viewBox="0 0 24 24"');
                });

                if (isIncognito) {
                    return { isPro: false, username: 'Incognito User', isIncognito: true };
                } else {
                    return { isPro: false, username: null, isIncognito: false };
                }
            } catch (error) {
                return { isPro: false, username: null, isIncognito: false };
            }
        } else {
            try {
                await page.waitForSelector('div[class*="relative flex items-center gap-x-xs"]', { timeout: 2000 });

                const isPro = await page.evaluate(() => {
                    const svgElement = document.querySelector('div[class*="relative flex aspect-square"] svg');
                    return svgElement && svgElement.innerHTML.includes('fill-super dark:fill-superDark');
                });

                const username = await page.evaluate(() => {
                    const usernameElement = document.querySelector('div[class*="relative flex items-center gap-x-xs"] div');
                    return usernameElement ? usernameElement.textContent.trim() : null;
                });

                return { isPro, username, isIncognito: false };
            } catch (error) {
                return { isPro: false, username: null, isIncognito: false };
            }
        }
    }


    async waitForManualLogin(page) {
        return new Promise(async (resolve) => {
            let isResolved = false;

            const checkLoginCompletion = async () => {
                if (isResolved) return;

                try {
                    const accountStatus = await this.checkAccountStatus(page);
                    if (accountStatus.username) {
                        console.log(`登录成功: ${accountStatus.username}`);
                        const cookies = await page.cookies();
                        const sessionCookie = this.extractPerplexitySessionCookie(cookies);
                        isResolved = true;
                        resolve({ sessionCookie, accountStatus });
                    }
                } catch (error) {
                    // 如果检查失败，继续等待
                }
            };

            // 监听 DOM 变化
            await page.evaluate(() => {
                const observer = new MutationObserver((mutations) => {
                    for (let mutation of mutations) {
                        if (mutation.type === 'childList' || mutation.type === 'subtree') {
                            window.dispatchEvent(new CustomEvent('domChanged'));
                            break;
                        }
                    }
                });

                observer.observe(document.body, {
                    childList: true,
                    subtree: true,
                });
            });

            // 监听 DOM 变化
            await page.exposeFunction('notifyDomChanged', checkLoginCompletion);
            await page.evaluate(() => {
                window.addEventListener('domChanged', window.notifyDomChanged);
            });

            // 监听导航完成
            page.on('load', checkLoginCompletion);

            setTimeout(() => {
                if (!isResolved) {
                    console.log('登录等待超时');
                    resolve({ sessionCookie: null, accountStatus: null });
                }
            }, 300000);

            // 初始检查
            await checkLoginCompletion();
        });
    }

    async validateSession(page) {
        const accountStatus = await this.checkAccountStatus(page);
        if (accountStatus.username || accountStatus.isIncognito) {
            if (accountStatus.isIncognito) {
                console.log('无痕模式验证成功');
            } else {
                console.log(`账号 ${accountStatus.username} 登录有效${accountStatus.isPro ? '（Pro 账号）' : ''}`);
            }
            return true;
        } else {
            console.log('账号验证失败');
            return false;
        }
    }

    extractPerplexitySessionCookie(cookies) {
        let sessionCookie = [];

        const sessionToken = cookies.find(c => c.name === '__Secure-next-auth.session-token');
        if (sessionToken) {
            sessionCookie.push(sessionToken);
        }

        if (sessionCookie.length === 0) {
            console.error('无法提取有效的会话 cookie');
            return null;
        }

        return sessionCookie;
    }

    async getCompletion({ username, messages, stream = false, proxyModel }) {
        if (this.networkMonitor.isNetworkBlocked()) {
            throw new Error("网络异常，请稍后再试");
        }
        const session = this.sessions[username];
        if (!session || !session.valid) {
            throw new Error(`用户 ${username} 的会话无效`);
        }

        const { page } = session;
        const emitter = new EventEmitter();

        // 转换纯文本
        let previousMessages = messages.map(msg => msg.content).join("\n\n");

        // 生成必要的参数
        const messagePayload = {
            version: "2.13",
            source: "default",
            language: "en-GB",
            timezone: "Europe/London",
            search_focus: "writing",
            frontend_uuid: uuidV4(),
            mode: "concise",
            is_related_query: false,
            is_default_related_query: false,
            visitor_id: uuidV4(),
            user_nextauth_id: uuidV4(),
            frontend_context_uuid: uuidV4(),
            prompt_source: "user",
            query_source: "home",
        };

        await page.addScriptTag({ url: 'https://cdn.socket.io/4.4.1/socket.io.min.js' });

        const ioExists = await page.evaluate(() => typeof io !== 'undefined');
        if (!ioExists) {
            throw new Error("socket.io 客户端脚本加载失败");
        }

        // 移除之前 console
        page.removeAllListeners('console');

        page.on('console', msg => {
            const text = msg.text();
            console.log(text);
        });

        // 唯一的回调函数名
        const callbackName = `nodeCallback_${uuidV4()}`;

        // 在浏览器上下文中建立 WebSocket 连接并发送消息
        await page.exposeFunction(callbackName, (event, data) => {
            if (event === "completion") {
                const { id, text } = data;
                emitter.emit("completion", id, text);
            } else if (event === "end") {
                emitter.emit("end");
            } else if (event === "error") {
                console.error("Error from page.evaluate:", data);
                emitter.emit("error", data);
            }
        });

        await page.evaluate(
            (previousMessages, messagePayload, callbackName, stream) => {
                try {
                    if (typeof io === 'undefined') {
                        window[callbackName]("error", "Socket.io 客户端未定义，请检查脚本是否正确加载。");
                        return;
                    }

                    if (window.socket) {
                        // 如果已有 socket 连接
                        window.socket.disconnect();
                        window.socket = null;
                    }

                    // 累积接收到的 chunk（用于非流）
                    let accumulatedChunks = '';

                    const socket = io("wss://www.perplexity.ai/", {
                        path: "/socket.io",
                        transports: ["websocket"],
                    });

                    window.socket = socket;

                    // 定义监听器函数
                    function onQueryProgress(data) {
                        try {
                            if (data.text) {
                                const textData = JSON.parse(data.text);
                                const chunk = textData.chunks[textData.chunks.length - 1];
                                if (chunk) {
                                    if (stream) {
                                        // 实时发送 chunk
                                        console.log(chunk); // 直接输出 chunk 内容
                                        window[callbackName]("completion", { id: messagePayload.frontend_uuid, text: chunk });
                                    } else {
                                        // 累积 chunk
                                        accumulatedChunks += chunk;
                                    }
                                }
                            }
                            // 检查是否为最后一条消息
                            if (data.final) {
                                if (!stream) {
                                    // 非流发送完整的响应
                                    console.log(accumulatedChunks);
                                    window[callbackName]("completion", { id: messagePayload.frontend_uuid, text: accumulatedChunks });
                                }
                                console.log("请求结束");
                                window[callbackName]("end");

                                // 清理资源
                                socket.off("query_progress", onQueryProgress);
                                socket.disconnect();
                                window.socket = null;
                                delete window[callbackName];
                            }
                        } catch (err) {
                            console.error("Error processing query_progress data:", err);
                            window[callbackName]("error", err.toString());
                        }
                    }

                    // 添加监听器
                    socket.on("query_progress", onQueryProgress);

                    socket.on("connect", () => {
                        // 使用回调处理确认响应
                        socket.emit("perplexity_ask", previousMessages, messagePayload, (response) => {
                        });
                    });
                    socket.on("error", (error) => {
                        console.error("Socket error:", error);
                        window[callbackName]("error", error.toString());
                    });

                    socket.on("connect_error", (error) => {
                        console.error("Socket connect_error:", error);
                        window[callbackName]("error", error.toString());
                    });

                    socket.on("connect_timeout", (timeout) => {
                        console.error("Socket connect_timeout:", timeout);
                        window[callbackName]("error", "Connection timed out");
                    });
                } catch (err) {
                    console.error("Error in page.evaluate:", err);
                    window[callbackName]("error", err.toString());
                }
            },
            previousMessages,
            messagePayload,
            callbackName,
            stream
        );

        const cancel = () => {
            page.evaluate((callbackName) => {
                if (window.socket) {
                    window.socket.disconnect();
                    window.socket = null;
                }
                if (window[callbackName]) {
                    delete window[callbackName];
                }
            }, callbackName).catch(console.error);
        };

        // 触发 'start'
        emitter.emit("start", messagePayload.frontend_uuid);

        return { completion: emitter, cancel };
    }
}

export default PerplexityProvider;