import fs from 'fs';
import configs from '../../system/config.js';
import { delay, getPathProfile, safeClosePage } from '../../system/utils.js';
import { ApiBid } from '../api-bid.js';

export class LawsonsApiBid extends ApiBid {
    reloadInterval = null;
    constructor({ ...prev }) {
        super(prev);
    }

    waitVerifyData = async () =>
        new Promise((rev, rej) => {
            // Tạo timeout để reject sau 1 phút nếu không có phản hồi
            const timeout = setTimeout(() => {
                global.socket.off(`verify-code.${this.origin_url}`); // Xóa listener tránh rò rỉ bộ nhớ
                rej(new Error(`[${this.id}] Timeout: No verification code received within 2 minute.`));
            }, 120 * 1000); // 60 giây

            global.socket.on(`verify-code.${this.origin_url}`, async (data) => {
                console.log(`📢 [${this.id}] VERIFY CODE:`, data);
                clearTimeout(timeout); // Hủy timeout vì đã nhận được mã
                global.socket.off(`verify-code.${this.origin_url}`); // Xóa listener tránh lặp lại
                rev(data); // Resolve với dữ liệu nhận được
            });
        });

    async isLogin() {
        if (!this.page_context) return false;

        const filePath = getPathProfile(this.origin_url);

        return !(await this.page_context.$('#emailLogin')) && fs.existsSync(filePath);
    }

    waitVerifyData = async () =>
        new Promise((rev, rej) => {
            // Tạo timeout để reject sau 1 phút nếu không có phản hồi
            const timeout = setTimeout(() => {
                global.socket.off(`verify-code.${this.origin_url}`); // Xóa listener tránh rò rỉ bộ nhớ
                rej(new Error(`[${this.id}] Timeout: No verification code received within 1 minute.`));
            }, 60 * 1000); // 60 giây

            global.socket.on(`verify-code.${this.origin_url}`, async (data) => {
                console.log(`📢 [${this.id}] VERIFY CODE:`, data);
                clearTimeout(timeout); // Hủy timeout vì đã nhận được mã
                global.socket.off(`verify-code.${this.origin_url}`); // Xóa listener tránh lặp lại
                rev(data); // Resolve với dữ liệu nhận được
            });
        });

    async enterOTP(otp) {
        try {
            // Selector cho tất cả các input OTP
            const inputSelector = '.MuiDialog-container .container input';

            // Chờ cho các input OTP xuất hiện
            await this.page_context.waitForSelector(inputSelector, { timeout: 8000 });

            // Lấy tất cả các input OTP
            const inputs = await this.page_context.$$(inputSelector);

            // Kiểm tra nếu có đúng 6 trường input
            if (inputs.length === 6 && otp.length === 6) {
                // Nhập mỗi ký tự của OTP vào các input tương ứng
                for (let i = 0; i < 6; i++) {
                    await inputs[i].type(otp[i], { delay: 100 });
                }
                console.log(`✅ OTP entered successfully: ${otp}`);
            } else {
                console.error('❌ Invalid OTP or input fields count');
            }
        } catch (error) {
            console.error('❌ Error entering OTP:', error);
        }
    }

    async waitToTwoVerify() {
        try {
            if (!this.page_context) return false;

            // Selector của các phần tử trên trang
            const button = '.form-input-wrapper.form-group > .btn.btn-primary'; // Nút để tiếp tục quá trình xác minh
            const remember = '.PrivateSwitchBase-input'; // Checkbox "Remember me"
            const continueButton =
                '.MuiButtonBase-root.MuiButton-root.MuiButton-contained.MuiButton-containedPrimary.MuiButton-sizeMedium.MuiButton-containedSizeMedium.MuiButton-colorPrimary.MuiButton-root'; // Nút "Continue"

            // Chờ cho nút xác minh xuất hiện
            console.log(`🔎 [${this.id}] Waiting for the button with selector: ${button}`);
            await this.page_context.waitForSelector(button, { timeout: 8000 });

            console.log(`✅ [${this.id}] Button found, clicking the first button.`);

            // Lấy phần tử của nút và log nội dung của nó
            const firstButton = await this.page_context.$(button); // Lấy phần tử đầu tiên
            const buttonContent = await firstButton.evaluate((el) => el.textContent); // Lấy nội dung của nút
            console.log(`🔎 [${this.id}] Button content: ${buttonContent}`);

            // Chờ 2s cho button sẵn sàn
            await delay(2000);
            // Click vào nút xác minh
            await firstButton.click();
            console.log(`✅ [${this.id}] Button clicked.`);

            // Nhận mã OTP để nhập vào form
            const { name, code } = await this.waitVerifyData();
            console.log(`🔎 [${this.id}] Waiting for OTP input, received code: ${code}`);

            // Nhập mã OTP vào form
            await this.enterOTP(code);
            console.log(`✅ [${this.id}] OTP entered successfully.`);

            // Chờ cho checkbox "Remember me" xuất hiện
            await this.page_context.waitForSelector(remember, { timeout: 8000 });
            console.log(`🔎 [${this.id}] Waiting for remember me checkbox with selector: ${remember}`);

            // Click vào checkbox "Remember me"
            await this.page_context.click(remember, { delay: 92 });
            console.log(`✅ [${this.id}] Remember me checkbox clicked.`);

            // Chờ cho nút "Continue" xuất hiện
            await this.page_context.waitForSelector(continueButton, { timeout: 8000 });
            console.log(`🔎 [${this.id}] Waiting for continue button with selector: ${continueButton}`);

            // Click vào nút "Continue"
            await this.page_context.click(continueButton, { delay: 100 });
            console.log(`✅ [${this.id}] Continue button clicked.`);

            // Chờ cho trang tải hoàn tất sau khi click "Continue"
            await this.page_context.waitForNavigation({ waitUntil: 'domcontentloaded' });
            console.log(`✅ [${this.id}] Navigation completed.`);

            return true;
        } catch (error) {
            console.error(`❌ [${this.id}] Error:`, error);
            return false;
        }
    }

    async handleLogin() {
        const page = this.page_context;

        global.IS_CLEANING = false;

        const filePath = getPathProfile(this.origin_url);

        await page.waitForNavigation({ waitUntil: 'domcontentloaded' });

        // 🛠 Check if already logged in (login input should not be visible or profile exists)
        if (!(await page.$('#emailLogin')) && fs.existsSync(filePath)) {
            console.log(`✅ [${this.id}] Already logged in, skipping login process.`);
            return;
        }

        if (fs.existsSync(filePath)) {
            console.log(`🗑 [${this.id}] Deleting existing file: ${filePath}`);
            fs.unlinkSync(filePath);
        }

        const children = this.children.filter((item) => item.page_context);
        console.log(`🔍 [${this.id}] Found ${children.length} child pages to close.`);

        if (children.length > 0) {
            console.log(`🛑 [${this.id}] Closing child pages...`);
            await Promise.all(
                children.map((item) => {
                    console.log(`➡ [${this.id}] Closing child page with context: ${item.page_context}`);
                    return safeClosePage(item);
                }),
            );

            console.log(`➡ [${this.id}] Closing main page context: ${this.page_context}`);
            await safeClosePage(this);
        }

        console.log(`🔑 [${this.id}] Starting login process...`);

        try {
            // ⌨ Enter email
            console.log(`✍ [${this.id}] Entering email:`, this.username);
            await page.type('#emailLogin', this.username, { delay: 100 });

            // ⌨ Enter password
            console.log(`✍ [${this.id}] Entering password...`);
            await page.type('#passwordLogin', this.password, { delay: 150 });

            // 🚀 Click the login button
            console.log(`🔘 [${this.id}] Clicking the "Login" button`);
            await page.click('#signInBtn', { delay: 92 });

            const result = await this.waitToTwoVerify();

            // ⏳ Wait for navigation after login
            if (!result) {
                console.log(`⏳ [${this.id}] Waiting for navigation after login...`);
                await page.waitForNavigation({ timeout: 8000, waitUntil: 'domcontentloaded' });
            }

            if (this.page_context.url() == this.url) {
                // 📂 Save session context to avoid re-login
                await this.saveContext();
                console.log(`✅ [${this.id}] Login successful!`);
            } else {
                console.log(`❌ [${this.id}] Login Failure!`);
            }
        } catch (error) {
            console.error(`❌ [${this.id}] Error during login process:`, error.message);
        } finally {
            global.IS_CLEANING = true;
        }
    }

    action = async () => {
        try {
            const page = this.page_context;

            page.on('response', async (response) => {
                const request = response.request();
                if (request.redirectChain().length > 0) {
                    if (response.url().includes(configs.WEB_CONFIGS.LAWSONS.LOGIN_URL)) {
                        await this.handleLogin();
                    }
                }
            });

            await page.goto(this.url, { waitUntil: 'networkidle2' });

            await page.bringToFront();

            // Set userAgent
            await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36');
        } catch (error) {
            console.log('Error [action]: ', error.message);
        }
    };

    listen_events = async () => {
        if (this.page_context) return;

        await this.puppeteer_connect();
        await this.action();

        this.reloadInterval = setInterval(async () => {
            try {
                if (this.page_context && !this.page_context.isClosed()) {
                    console.log(`🔄 [${this.id}] Reloading page...`);
                    await this.page_context.reload({ waitUntil: 'networkidle2' });
                    console.log(`✅ [${this.id}] Page reloaded successfully.`);
                } else {
                    console.log(`❌ [${this.id}] Page context is closed. Stopping reload.`);
                    clearInterval(this.reloadInterval);
                }
            } catch (error) {
                console.error(`🚨 [${this.id}] Error reloading page:`, error.message);
            }
        }, 60000); // 1p reload
    };
}