/**
 * @author Usman Naeem
 */
var account_currency_list = null;

var position_size_calculator_item_value = null;
var position_size_calculator_account_currency_value = 'USD';
var position_size_calculator_target_pips_value = 20;
var position_size_calculator_target_amount_value = 100;
var position_size_calculator_type_lots = true;
var position_size_calculator_type_units = false;

var pip_value_calculator_item_value = null;
var pip_value_calculator_account_currency_value = 'USD';
var pip_value_calculator_pips_value = 1;
var pip_value_calculator_quantity_value = 1;
var pip_value_calculator_quantity_lots = true;
var pip_value_calculator_quantity_units = false;

function enableCalculatorsPage() {
    addLoader();
    addHeader(true);
    setPage(calculators_page);
    addFooter();
    const messageboxElement = getElement("calculators_message_box");
    messageboxElement.innerHTML = "";

    closeCalculators(null, true);

    //
    load_user().then(() => {
        if (account_currency_list === null) {
            loadAccountCurrencies().then(() => {
                set_calculator_item_element('position_size_calculator_item');
                set_calculator_item_element('pip_value_calculator_item');
                //
                set_calculator_account_currency_element('position_size_calculator_account_currency');
                set_calculator_account_currency_element('pip_value_calculator_account_currency');
            });
        }

        //
        restorePositionSizeFields();
        restorePipValueFields();

        //
        removeLoader();
    }).catch(error => {
        handleError(error, "calculators_message_box", true);
        enableLoginPage();
        return;
    });
}


function enablePositionSizeCalculator() {
    closePipValueCalculator();
    const position_size_calculator = getElement('position_size_calculator');
    position_size_calculator.style.display = "block";
}
function closePositionSizeCalculator() {
    const position_size_calculator = getElement('position_size_calculator');
    position_size_calculator.style.display = "none";
    position_size_calculator.style.setProperty("display", "none", "important");
}

function enablePipValueSizeCalculator() {
    closePositionSizeCalculator();
    const pip_value_calculator = getElement('pip_value_calculator');
    pip_value_calculator.style.display = "block";
}
function closePipValueCalculator() {
    const pip_value_calculator = getElement('pip_value_calculator');
    pip_value_calculator.style.display = "none";
    pip_value_calculator.style.setProperty("display", "none", "important");
}

function closeCalculators(e, force) {
    const id = event.target.id;
    if (force || (id && id === 'calculator_list_div_container')) {
        closePositionSizeCalculator();
        closePipValueCalculator();
    }
}

function set_calculator_item_element(select_id) {
    const select_element = getElement(select_id);
    select_element.innerHTML = "";

    analyzed_items.forEach(analyzedItem => {
        var optionElement = document.createElement('option');
        optionElement.value = analyzedItem;
        optionElement.innerHTML = analyzedItem;
        optionElement.selected = false;
        if (select_id === 'position_size_calculator_item') {
            if (position_size_calculator_item_value === null) {
                position_size_calculator_item_value = optionElement.value;
                optionElement.selected = true;
            }
        }
        if (select_id === 'pip_value_calculator_item') {
            if (pip_value_calculator_item_value === null) {
                pip_value_calculator_item_value = optionElement.value;
                optionElement.selected = true;
            }
        }
        select_element.appendChild(optionElement);
    });
}

function set_calculator_account_currency_element(select_id) {
    const select_element = getElement(select_id);
    select_element.innerHTML = "";

    account_currency_list.forEach(account_currency => {
        var optionElement = document.createElement('option');
        optionElement.value = account_currency;
        optionElement.innerHTML = account_currency;
        optionElement.selected = false;
        if (select_id === 'position_size_calculator_account_currency') {
            if (position_size_calculator_account_currency_value === null) {
                position_size_calculator_account_currency_value = optionElement.value;
            }
            if(position_size_calculator_account_currency_value === optionElement.value) {
                optionElement.selected = true;
            }
        }
        if (select_id === 'pip_value_calculator_account_currency') {
            if (pip_value_calculator_account_currency_value === null) {
                pip_value_calculator_account_currency_value = optionElement.value;
            }
            if(pip_value_calculator_account_currency_value === optionElement.value) {
                optionElement.selected = true;
            }
        }
        select_element.appendChild(optionElement);
    });
}

function positionSizeScalculatorFieldChanged() {
    recordPositionSizeFields();
    const positionSizeScalculatorResult = getElement('position_size_calculator_result');
    positionSizeScalculatorResult.innerHTML = "";
}

function pipValueCalculatorFieldChanged() {
    recordPipValueFields();
    const pipValueScalculatorResult = getElement('pip_value_calculator_result');
    pipValueScalculatorResult.innerHTML = "";
}

function recordPositionSizeFields() {
    const position_size_calculator_item_Element = getElement("position_size_calculator_item");
    position_size_calculator_item_value = position_size_calculator_item_Element.value;

    const position_size_calculator_account_currency_Element = getElement("position_size_calculator_account_currency");
    position_size_calculator_account_currency_value = position_size_calculator_account_currency_Element.value;

    const position_size_calculator_target_pips_Element = getElement("position_size_calculator_target_pips");
    position_size_calculator_target_pips_value = position_size_calculator_target_pips_Element.value;

    const position_size_calculator_target_amount_Element = getElement("position_size_calculator_target_amount");
    position_size_calculator_target_amount_value = position_size_calculator_target_amount_Element.value;

    const positionSizeCalculatorPositionTypeLotsElement = getElement('position_size_calculator_position_type_lots');
    position_size_calculator_type_lots = positionSizeCalculatorPositionTypeLotsElement.checked;

    const positionSizeCalculatorPositionTypeUnitsElement = getElement('position_size_calculator_position_type_units');
    position_size_calculator_type_units = positionSizeCalculatorPositionTypeUnitsElement.checked;
}

function restorePositionSizeFields() {
    const position_size_calculator_item_Element = getElement("position_size_calculator_item");
    position_size_calculator_item_Element.value = position_size_calculator_item_value;

    const position_size_calculator_account_currency_Element = getElement("position_size_calculator_account_currency");
    position_size_calculator_account_currency_Element.value = position_size_calculator_account_currency_value;

    const position_size_calculator_target_pips_Element = getElement("position_size_calculator_target_pips");
    position_size_calculator_target_pips_Element.value = position_size_calculator_target_pips_value;

    const position_size_calculator_target_amount_Element = getElement("position_size_calculator_target_amount");
    position_size_calculator_target_amount_Element.value = position_size_calculator_target_amount_value;

    const positionSizeCalculatorPositionTypeLotsElement = getElement('position_size_calculator_position_type_lots');
    positionSizeCalculatorPositionTypeLotsElement.checked = position_size_calculator_type_lots;

    const positionSizeCalculatorPositionTypeUnitsElement = getElement('position_size_calculator_position_type_units');
    positionSizeCalculatorPositionTypeUnitsElement.checked = position_size_calculator_type_units;
}

function recordPipValueFields() {
    const pip_value_calculator_item_Element = getElement("pip_value_calculator_item");
    pip_value_calculator_item_value = pip_value_calculator_item_Element.value;

    const pip_value_calculator_account_currency_Element = getElement("pip_value_calculator_account_currency");
    pip_value_calculator_account_currency_value = pip_value_calculator_account_currency_Element.value;

    const pip_value_calculator_pips_Element = getElement("pip_value_calculator_pips");
    pip_value_calculator_pips_value = pip_value_calculator_pips_Element.value;

    const pip_value_calculator_quantity_Element = getElement("pip_value_calculator_quantity");
    pip_value_calculator_quantity_value = pip_value_calculator_quantity_Element.value;

    const pip_value_calculator_quantity_lots_Element = getElement('pip_value_calculator_quantity_lots');
    pip_value_calculator_quantity_lots = pip_value_calculator_quantity_lots_Element.checked;

    const pip_value_calculator_quantity_units_Element = getElement('pip_value_calculator_quantity_units');
    pip_value_calculator_quantity_units = pip_value_calculator_quantity_units_Element.checked;
}

function restorePipValueFields() {
    const pip_value_calculator_account_currency_Element = getElement("pip_value_calculator_account_currency");
    pip_value_calculator_account_currency_Element.value = pip_value_calculator_account_currency_value;

    const pip_value_calculator_pips_Element = getElement("pip_value_calculator_pips");
    pip_value_calculator_pips_Element.value = pip_value_calculator_pips_value;

    const pip_value_calculator_quantity_Element = getElement("pip_value_calculator_quantity");
    pip_value_calculator_quantity_Element.value = pip_value_calculator_quantity_value;

    const pip_value_calculator_quantity_lots_Element = getElement('pip_value_calculator_quantity_lots');
    pip_value_calculator_quantity_lots_Element.checked = pip_value_calculator_quantity_lots;

    const pip_value_calculator_quantity_units_Element = getElement('pip_value_calculator_quantity_units');
    pip_value_calculator_quantity_units_Element.checked = pip_value_calculator_quantity_units;
}

async function loadAccountCurrencies() {
    try {
        const calculatorMessageboxElement = getElement("calculators_message_box");
        calculatorMessageboxElement.innerHTML = "";

        const url = "GetSupportedAccountCurrencies";
        await callWebserviceGET(url, calculatorMessageboxElement, null).then((json) => {
            if (json) {
                if (json.code !== 200) {
                    calculatorMessageboxElement.innerHTML = getErrorMessage(json.message);
                } else {
                    account_currency_list = new Array();
                    json.supported_account_currencies.forEach(accountCurrency => {
                        account_currency_list.push(accountCurrency);
                    });
                    account_currency_list.sort();
                }
            }
        }).catch((error) => {
            handleError("Failed to get supported account currencies " + error, "calculators_message_box", false);
            console.log(error);
        });
    } catch (error) {
        console.log(error);
        handleError("Failed to get supported account currencies " + error, "calculators_message_box", false);
    }
}
async function calculatePositionSize() {
    const positionSizeScalculatorResult = getElement('position_size_calculator_result');
    positionSizeScalculatorResult.innerHTML = "";
    const buttonElement = getElement("position_size_calculator_btn");
    if (buttonElement.textContent === wait_text) {
        return;
    }
    const buttonText = buttonElement.textContent;

    try {
        const calculatorMessageboxElement = getElement("calculators_message_box");
        calculatorMessageboxElement.innerHTML = "";

        const position_size_calculator_item_Element = getElement("position_size_calculator_item");
        const item = position_size_calculator_item_Element.value;
        if (item === '') {
            calculatorMessageboxElement.innerHTML = "item is required";
            positionSizeScalculatorResult.innerHTML = "item is required";
            return;
        }

        const position_size_calculator_account_currency_Element = getElement("position_size_calculator_account_currency");
        const account_currency = position_size_calculator_account_currency_Element.value;

        const position_size_calculator_target_pips_Element = getElement("position_size_calculator_target_pips");
        const target_pips = position_size_calculator_target_pips_Element.value;
        if (target_pips === '') {
            calculatorMessageboxElement.innerHTML = "Pips is required";
            positionSizeScalculatorResult.innerHTML = "Pips is required";
            return;
        }

        const position_size_calculator_target_amount_Element = getElement("position_size_calculator_target_amount");
        const target_amount = position_size_calculator_target_amount_Element.value;
        if (target_amount === '') {
            calculatorMessageboxElement.innerHTML = "Quantity is required";
            positionSizeScalculatorResult.innerHTML = "Quantity is required";
            return;
        }

        const positionSizeCalculatorPositionTypeUnitsElement = getElement('position_size_calculator_position_type_units');
        const unit_based = positionSizeCalculatorPositionTypeUnitsElement.checked;

        var wait_text = "Please Wait";
        buttonElement.textContent = wait_text;

        const url = "CalculatePositionSize?item=" + encodeURIComponent(item) + "&account_currency=" + encodeURIComponent(account_currency) + "&target_pips=" + encodeURIComponent(target_pips) + "&target_amount=" + encodeURIComponent(target_amount) + "&unit_based=" + encodeURIComponent(unit_based);
        await callWebserviceGET(url, calculatorMessageboxElement, null).then((json) => {
            buttonElement.textContent = buttonText;
            if (json) {
                if (json.code !== 200) {
                    calculatorMessageboxElement.innerHTML = getErrorMessage(json.message);
                    positionSizeScalculatorResult.innerHTML = json.message;
                } else {
                    positionSizeScalculatorResult.innerHTML = "position size  " + json.position_size + "  " + (unit_based ? "units" : "lots");
                    positionSizeScalculatorResult.innerHTML = (unit_based ? "Units: " : "Lots: ") + "  " + json.position_size;
                }
            }
        }).catch((error) => {

            buttonElement.textContent = buttonText;
            handleError("Failed to calculate position size " + error, "calculators_message_box", false);
            console.log(error);
        });
    } catch (error) {
        buttonElement.textContent = buttonText;
        console.log(error);
        handleError("Failed to calculate position size " + error, "calculators_message_box", false);
    }
}

async function calculatePipValue() {
    const pipValueScalculatorResult = getElement('pip_value_calculator_result');
    pipValueScalculatorResult.innerHTML = "";
    const buttonElement = getElement("pip_value_calculator_btn");
    if (buttonElement.textContent === wait_text) {
        return;
    }
    const buttonText = buttonElement.textContent;

    try {
        const calculatorMessageboxElement = getElement("calculators_message_box");
        calculatorMessageboxElement.innerHTML = "";

        const pip_value_calculator_item_Element = getElement("pip_value_calculator_item");
        const item = pip_value_calculator_item_Element.value;
        if (item === '') {
            calculatorMessageboxElement.innerHTML = "item is required";
            pipValueScalculatorResult.innerHTML = "item is required";
            return;
        }

        const pip_value_calculator_account_currency_Element = getElement("pip_value_calculator_account_currency");
        const account_currency = pip_value_calculator_account_currency_Element.value;

        const pip_value_calculator_pips_Element = getElement("pip_value_calculator_pips");
        const pips = pip_value_calculator_pips_Element.value;
        if (pips === '') {
            calculatorMessageboxElement.innerHTML = "Pips is required";
            pipValueScalculatorResult.innerHTML = "Pips is required";
            return;
        }

        const pip_value_calculator_quantity_Element = getElement("pip_value_calculator_quantity");
        const quantity = pip_value_calculator_quantity_Element.value;
        if (quantity === '') {
            calculatorMessageboxElement.innerHTML = "Quantity is required";
            pipValueScalculatorResult.innerHTML = "Quantity is required";
            return;
        }

        const pip_value_calculator_quantity_lots_Element = getElement('pip_value_calculator_quantity_lots');
        const pip_value_calculator_quantity_units_Element = getElement('pip_value_calculator_quantity_units');

        const unit_based = pip_value_calculator_quantity_units_Element.checked;

        var wait_text = "Please Wait";
        buttonElement.textContent = wait_text;

        const url = "CalculatePipValue?item=" + encodeURIComponent(item) + "&account_currency=" + encodeURIComponent(account_currency) + "&pips=" + encodeURIComponent(pips) + "&" + (unit_based ? "units" : "lots") + "=" + encodeURIComponent(quantity);
        await callWebserviceGET(url, calculatorMessageboxElement, null).then((json) => {
            buttonElement.textContent = buttonText;
            if (json) {
                if (json.code !== 200) {
                    calculatorMessageboxElement.innerHTML = getErrorMessage(json.message);
                    pipValueScalculatorResult.innerHTML = json.message;
                } else {
                    pipValueScalculatorResult.innerHTML = json.pip_value + " " + account_currency;
                }
            }
        }).catch((error) => {
            buttonElement.textContent = buttonText;
            handleError("Failed to calculate position size " + error, "calculators_message_box", false);
            console.log(error);
        });
    } catch (error) {
        buttonElement.textContent = buttonText;
        console.log(error);
        handleError("Failed to calculate position size " + error, "calculators_message_box", false);
    }
}