let elements = {
    radioA: document.getElementById('radioButtonA'),
    radioB: document.getElementById('radioButtonB'),
    fieldsetA: document.getElementById('inputTypeFieldsetA'),
    fieldsetB: document.getElementById('inputTypeFieldsetB'),
    imageA: document.getElementById('schemeImageA'),
    imageB: document.getElementById('schemeImageB'),

    inputsForm: document.getElementById('inputsForm'),

    equalSideLength: document.getElementById('equalSideLength'),
    equalSideLengthErr: document.getElementById('equalSideLengthErr'),
    baseAngle: document.getElementById('baseAngle'),
    baseAngleErr: document.getElementById('baseAngleErr'),
    baseSideLength: document.getElementById('baseSideLength'),
    baseSideLengthErr: document.getElementById('baseSideLengthErr'),
    baseAdjacentAngle: document.getElementById('baseAdjacentAngle'),
    baseAdjacentAngleErr: document.getElementById('baseAdjacentAngleErr'),

    outputsFieldset: document.getElementById('outputsFieldset'),
    outputValuesErr: document.getElementById('outputValuesErr'),
    outputR: document.getElementById('outputValuesR'),
    outputH: document.getElementById('outputValuesH'),
    outputL: document.getElementById('outputValuesL'),
    calculateButton: document.getElementById('calculateButton'),
    clearButton: document.getElementById('clearButton'),
    outputsTable: document.getElementById('outputsTable')
}
console.log("loaded js!");

let currentModeIsA = true;
let outputFields = {};

let inputsA = {
    l: null,
    angle: null
};

let inputsB = {
    l: null,
    angle: null
};

function highlightErrorElement(errorFieldIndex, add = true) {
    let fields = [
        elements.equalSideLength,
        elements.baseAngle,
        elements.baseSideLength,
        elements.baseAdjacentAngle,
        outputsFieldset
    ];
    if (fields[errorFieldIndex]) {
        if (add) {
            fields[errorFieldIndex].classList.add("bad-input-highlight");
        }
        else {
            fields[errorFieldIndex].classList.remove("bad-input-highlight");
        }
    }

}

function setErrTooltip(errorFieldIndex, tooltip) {
    let errElem = [
        elements.equalSideLengthErr,
        elements.baseAngleErr,
        elements.baseSideLengthErr,
        elements.baseAdjacentAngleErr,
        elements.outputValuesErr
    ][errorFieldIndex];
    if (errElem) {
        highlightErrorElement(errorFieldIndex, tooltip !== "");

        if (tooltip !== "") {
            errElem.classList.remove("hidden");;
        }
        else {
            errElem.classList.add("hidden");;
        }
        if (errorFieldIndex == 4) {
            tooltip += "<br>"
        }
        errElem.innerHTML = tooltip;
    }


}

function deg2rad(degrees) {
    return degrees * (Math.PI / 180);
}

function getCalculations() {
    let heights = [];//base related, side realted
    let lengths = [];// base side
    let radius = 0;
    let baseAngle = 0;
    let sideAngle = 0;
    if (currentModeIsA) {
        lengths[0] = 2 * Math.sin(deg2rad(inputsA.angle) / 2) * inputsA.l;
        lengths[1] = inputsA.l;
        baseAngle = inputsA.angle;
        sideAngle = (180 - baseAngle) / 2;
    }
    else {
        lengths[0] = inputsB.l;
        lengths[1] = inputsB.l / (2 * Math.cos(deg2rad(inputsB.angle)));
        sideAngle = inputsB.angle;
        baseAngle = 180 - 2 * sideAngle;
    }
    radius = Math.sqrt(((2 * lengths[1]) - lengths[0]) / ((2 * lengths[1]) - lengths[0])) * lengths[0] / 2;


    heights[0] = lengths[1] * Math.sin(deg2rad(sideAngle));
    heights[1] = lengths[0] * Math.sin(deg2rad(baseAngle));
    return {
        radius: radius,
        heights: heights,
        lengths: lengths
    };
}

function updateCheckboxes() {
    outputFields["radius"] = elements.outputR.checked;
    outputFields["heights"] = elements.outputH.checked;
    outputFields["lengths"] = elements.outputL.checked;
    let ret = !outputFields.radius && !outputFields.heights && !outputFields.lengths;
    if (ret) {
        setErrTooltip(4, "Выберите хотя бы один параметр для вывода.");
    } else {
        setErrTooltip(4, "");
    }
    updateCalculateButton();
}

function updateCalculateButton() {
    let ret = false;
    if (currentModeIsA) {
        ret = inputsA["l"] !== null && inputsA["angle"] !== null
    }
    else {
        ret = inputsB["l"] !== null && inputsB["angle"] !== null
    }
    ret &= elements.outputR.checked || elements.outputH.checked || elements.outputL.checked;

    elements.calculateButton.disabled = !ret;
}

function switchInputs(selectA) {
    if (selectA) {
        elements.imageA.classList.remove("hidden");
        elements.imageB.classList.add("hidden");
        elements.fieldsetA.classList.remove("hidden");
        elements.fieldsetB.classList.add("hidden");
    }
    else {
        elements.imageA.classList.add("hidden");
        elements.imageB.classList.remove("hidden");
        elements.fieldsetA.classList.add("hidden");
        elements.fieldsetB.classList.remove("hidden");
    }
    updateCalculateButton();
}

function displayTable(calcResults) {
    let table = elements.outputsTable;
    table.innerHTML = ""; // Clear previous content

    let header = "<tr><th>Параметр</th><th>Значение</th></tr>";
    let rows = "";

    if (outputFields.radius) {
        rows += `<tr><td>R</td><td>${calcResults.radius.toFixed(3)}</td></tr>`;
    }
    if (outputFields.heights) {
        rows += `<tr><td>h1</td><td>${calcResults.heights[0].toFixed(3)}</td></tr>`;
        rows += `<tr><td>h2</td><td>${calcResults.heights[1].toFixed(3)}</td></tr>`;
    }
    if (outputFields.lengths) {
        rows += `<tr><td>A</td><td>${calcResults.lengths[0].toFixed(3)}</td></tr>`;
        rows += `<tr><td>B</td><td>${calcResults.lengths[1].toFixed(3)}</td></tr>`;
    }
    table.innerHTML = header + rows;

    if (rows === "") {
        table.innerHTML = `<h3>Выберите параметры для вычислений, сейчас таблица пустая</h3>`;
    }

    table.classList.remove("hidden");

}

function clearCurrentInputs() {
    if (currentModeIsA) {
        elements.equalSideLength.value = null;
        elements.baseAngle.value = null;
        setErrTooltip(0, "");
        setErrTooltip(1, "");
        inputsA = {
            l: null,
            angle: null
        };
    }
    else {
        inputsB = {
            l: null,
            angle: null
        };
        setErrTooltip(2, "");
        setErrTooltip(3, "");
        elements.baseSideLength.value = null;
        elements.baseAdjacentAngle.value = null;
    }
    elements.outputsTable.classList.add("hidden");
    updateCalculateButton()
}

function check180Angle(angleString) {
    let angle = parseFloat(angleString);
    if (isNaN(angle)) {
        return "Введите корректное число";
    }
    if (angle <= 0) {
        return "Угол должен быть больше 0";
    }
    if (angle >= 180) {
        return "Угол должен быть меньше 180";
    }
    return "";
}

function check90Angle(angleString) {
    let angle = parseFloat(angleString);
    if (isNaN(angle)) {
        return "Введите корректное число";
    }
    if (angle <= 0) {
        return "Угол должен быть больше 0";
    }
    if (angle >= 90) {
        return "Угол должен быть меньше 90";
    }
    return "";
}

function checkLength(lengthString) {
    let length = parseFloat(lengthString);
    if (!isFinite(length)) {
        return "Введите корректное число";
    }
    if (length <= 0) {
        return "Длина должна быть больше 0";
    }
    return "";
}

function handleSwitchInputs(event) {
    if (event.target.id[event.target.id.length - 1].toLowerCase() == "a") {
        currentModeIsA = true;
        switchInputs(true);
        console.log("Switching inputs to A");
    }
    else {
        currentModeIsA = false;
        switchInputs(false);
        console.log("Switching inputs to B");
    }
}

function handleInputsUpdate(event) {
    switch (event.target.id) {
        case "equalSideLength":
            {
                const err = checkLength(event.target.value);
                setErrTooltip(0, err);
                if (err === "") {
                    inputsA.l = parseFloat(event.target.value);
                } else {
                    inputsA.l = null;
                }
            }
            break;
        case "baseAngle":
            {
                const err = check180Angle(event.target.value);
                setErrTooltip(1, err);
                if (err === "") {
                    inputsA.angle = parseFloat(event.target.value);
                } else {
                    inputsA.angle = null;
                }
            }
            break;
        case "baseSideLength":
            {
                const err = checkLength(event.target.value);
                setErrTooltip(2, err);
                if (err === "") {
                    inputsB.l = parseFloat(event.target.value);
                } else {
                    inputsB.l = null;
                }
            }
            break;
        case "baseAdjacentAngle":
            {
                const err = check90Angle(event.target.value);
                setErrTooltip(3, err);
                if (err === "") {
                    inputsB.angle = parseFloat(event.target.value);
                } else {
                    inputsB.angle = null;
                }
            }
            break;
        default:
            console.log(event.target.id)
            break;
    }
    updateCalculateButton();

}

function handleFieldsetEvent(event) {
    if (event.target.type === 'radio') {
        handleSwitchInputs(event);
    } else if (event.target.type === 'number') {
        handleInputsUpdate(event);
    }
}
elements.inputsForm.addEventListener('change', handleFieldsetEvent);
elements.inputsForm.addEventListener('input', handleFieldsetEvent);

elements.outputsFieldset.addEventListener('change', (event) => {
    if (event.target.type === 'checkbox') {
        updateCheckboxes();
    }
});

elements.clearButton.addEventListener('click', (event) => {
    event.preventDefault();
    clearCurrentInputs()
});

elements.calculateButton.addEventListener('click', (event) => {
    event.preventDefault();
    displayTable(getCalculations());
});


// чтобы не сконфузило
updateCheckboxes();
switchInputs(elements.radioA.checked);