async function delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

const pathnameRegex = /^\/\w{2}-\w{2}\/n?iv/;
const MAX_SIGNIN_ATTEMPTS = 1;
const PAGE_WAIT_TIME = 5000;

let config = {
    activate: null,
    username: null,
    password: null,
    frequency: null,
    countdown: null,
    apptId: null,
    apptDate: null,
    signinAttempts: null,
};
let minute = 60;
let isRunning = false;


function isSignInPage() {
    return Boolean(window.location.pathname.match(/^\/\w{2}-\w{2}\/n?iv\/users\/sign_in/));
}

function isLoggedOutPage() {
    return Boolean(window.location.pathname.match(/^\/\w{2}-\w{2}\/n?iv$/));
}

function isDashboardPage() {
    return Boolean(window.location.pathname.match(/^\/\w{2}-\w{2}\/n?iv\/groups\/\d+/));
}

function isAppointmentPage() {
    return Boolean(window.location.pathname.match(/^\/\w{2}-\w{2}\/n?iv\/schedule\/\d+\/appointment$/));
}

function isConfirmationPage() {
    return Boolean(window.location.pathname.match(/^\/\w{2}-\w{2}\/n?iv\/schedule\/\d+\/appointment\/instructions$/));
}

function isNotEnglishPage() {
    return Boolean(isSignInPage()
            || isLoggedOutPage()
            || isDashboardPage()
            || isAppointmentPage()
            || isConfirmationPage()
        ) && !window.location.pathname.match(/^\/en-/);
}

async function switchToEnglishPage() {
    console.log('Changing page to English');
    await chrome.storage.local.set({ "__status": "switching to English" });
    window.location.href(window.location.pathname.replace(/^\/\w{2}-{2}/, '/en-us'));
    await delay(PAGE_WAIT_TIME);
    // Should be on English page
}

async function goToSignInPage() {
    console.log('Going to sign in page')
    await chrome.storage.local.set({ "__status": "going to sign in page" });
    document.querySelector(".homeSelectionsContainer a[href*='/sign_in']").click();
    await delay(PAGE_WAIT_TIME);
    return isSignInPage();
}

async function enterCredentials() {
    document.getElementById("user_email").value = config.username;
    document.getElementById("user_password").value = config.password;
    let policyConfirmed = document.querySelector('[for="policy_confirmed"]');
    if (!policyConfirmed.getElementsByTagName('input')[0].checked) {
        policyConfirmed.click();
    }
    document.querySelector("#sign_in_form input[type=submit]").click();

    await delay(PAGE_WAIT_TIME);
    return isDashboardPage();
}

async function getAppointmentId() {
    let appointments = document.querySelectorAll("p.consular-appt [href]")
    if (appointments.length > 1) {
        console.log("Multiple appointments found, taking the first one");
    }

    let apptId = appointments[0].href.replace(/\D/g, "");
    return apptId;
}

async function checkDates() {
    console.log('checkDates start');
    config.countdown = config.frequency * minute;
    await chrome.storage.local.set({ "__countdown": config.countdown });
    console.log('checkDates done');
}

async function runner() {
    if (isRunning) {
        return;
    }
    isRunning = true;
    // console.log('runner start');

    let prev_config = Object.assign({}, config);

    let result = await new Promise(resolve => chrome.storage.local.get(null, resolve));
    config.activate = result['__activate'] || false;
    config.username = result['__username'] || "";
    config.password = result['__password'] || "";
    config.frequency = result['__frequency'] || 1;
    config.countdown = result['__countdown'] || 0;
    config.signinAttempts = result['__signinAttempts'] || 0;
    config.apptId = result['__apptId'] || null;
    config.apptDate = result['__apptDate'] || null;

    if (prev_config.activate === null) {
        console.log('Reading config: ' + JSON.stringify(config));
        isRunning = false;
        return;
    }

    let configChanged = false;
    for (let key in config) {
        if (config.hasOwnProperty(key) && config[key] !== prev_config[key]) {
            console.log(`Config change: ${key}, ${prev_config[key]} => ${config[key]}`);
            configChanged = true;

            // reduce countdown if frequency is reduced
            if (key === 'frequency') {
                let max_countdown = config[key] * minute;
                if (config.countdown > max_countdown) {
                    config.countdown = max_countdown;
                    await chrome.storage.local.set({ "__countdown": config.countdown });
                }
            }

            if (key === 'activate') {
                if (config[key]) {
                    console.log('Activating extension');
                    config.countdown = 5;
                    await chrome.storage.local.set({ "__countdown": config.countdown });
                } else {
                    console.log('Deactivating extension');
                    // reset countdown when deactivating the extension
                    config.countdown = 0;
                    await chrome.storage.local.set({ "__countdown": config.countdown });
                    await chrome.storage.local.set({ "__status": "inactive" });
                }
            }

            // clear signin attempts when credentials are changed
            if (key === 'username' && config[key]
                    || key === 'password' && config[key]) {
                config.signinAttempts = 0;
                await chrome.storage.local.set({ "__signinAttempts": config.signinAttempts });
            }
        }
    }
    if (configChanged) {
        // print whole config
        console.log(JSON.stringify(config));
    }

    if (!config.activate) {
        isRunning = false;
        return;
    }

    if (config.username === "" || config.password === "") {
        console.log('Username or password is empty');
        await chrome.storage.local.set({ "__status": "missing credentials" });
        isRunning = false;
        return;
    }

    if (config.frequency <= 0) {
        console.log('Frequency is 0 or negative');
        await chrome.storage.local.set({ "__status": "invalid frequency" });
        isRunning = false;
        return;
    }

    if (config.countdown > 0) {
        config.countdown -= 1;
        console.log(`Countdown: ${config.countdown}`);
        await chrome.storage.local.set({ "__countdown": config.countdown });
        await chrome.storage.local.set({ "__status": `waiting, ${config.countdown}s` });
        isRunning = false;
        return;
    }

    if (isNotEnglishPage()) {
        await switchToEnglishPage();
    }

    if (isLoggedOutPage()) {
        if (!await goToSignInPage()) {
            console.log('Failed to go to sign in page');
            await chrome.storage.local.set({ "__status": "failed to go to sign in page" });
            isRunning = false;
            return;
        };

    } else if (isSignInPage()) {
        // Prevent brute forcing
        if (config.signinAttempts >= MAX_SIGNIN_ATTEMPTS) {
            await chrome.storage.local.set({ "__status": "too many sign in attempts" });
            isRunning = false;
            return;
        }
    
        // Sign in
        console.log('Signing in attempt: ' + config.signinAttempts)
        await chrome.storage.local.set({ "__status": "signing in #" + config.signinAttempts });
        let signedIn = await enterCredentials();
        config.signinAttempts += 1;
        await chrome.storage.local.set({ "__signinAttempts": config.signinAttempts });
        if (!signedIn) {
            console.log('Sign in failed');
            await chrome.storage.local.set({ "__status": "sign in failed" });    
            isRunning = false;
            return;
        };
    
    } else if (isDashboardPage()) {
        // reset signin attempts when successfully logged in
        config.signinAttempts = 0;
        await chrome.storage.local.set({ "__status": "fetching appointment info" });
        await chrome.storage.local.set({ "__signinAttempts": config.signinAttempts });

        // get appointmentId
        if (!config.apptId) {
            config.apptId = await getAppointmentId();
            if (config.apptId) {
                console.log(`Appointment ID: ${apptId}`);
                await chrome.storage.local.set({ "__apptId": apptId });            
            } else {
                console.log('No appointments found');
                await chrome.storage.local.set({ "__status": "no appointment found" });
                isRunning = false;
                return;
            }
        }

        // get current appointment date
        let apptInfo = document.querySelector("p.consular-appt [href*='" + config.apptId + "']").parentNode.parentNode.parentNode
        if (!apptInfo.querySelector("h4").innerText.match(/Attend Appointment/)) {
            console.log('Appointment not available');
            await chrome.storage.local.set({ "__status": "appointment not available" });
            isRunning = false;
            return;
        }
        let apptDate = new Date(apptInfo.querySelector("p.consular-appt").innerText.match(/\d{1,2} \w+, \d{4}/)[0]);
        apptDate = apptDate.toISOString().slice(0, 10);
        if (config.apptDate && apptDate != config.apptDate) {
            config.apptDate = apptDate;
            await chrome.storage.local.set({ "__apptDate": apptDate });
        }

        // go to appointment page
        let apptLink = apptInfo.querySelector("p.consular-appt [href]").getAttribute("href").replace("/addresses/consulate", "/appointment");
        window.location.href = apptLink;
        await delay(PAGE_WAIT_TIME);
    }
    
    // console.log('runner done');
    isRunning = false;
}

setInterval(runner, 1000);