---

let builderInterval = null;
let builderEnabled = false;
let builderWaiting = false;

let builderClickerStarted = false;
let builderStartPosition = null;
let builderStartTime = null;

let builderStatusText = "";
let builderStatusColor = [255, 255, 255, 255];

const BUILDER_CLICKER_CODE = `
(function(){

    if (window.__builderAutoClicker)
        return;

    window.__builderAutoClicker = true;

    setInterval(() => {

        let panel = document.getElementById('builderGameContent');

        if (!panel || panel.style.display === 'none')
            return;

        let keyEl = document.getElementById('builderGameKey');

        if (!keyEl)
            return;

        let key = keyEl.textContent.trim();

        if (!key)
            return;

        ['keydown','keypress','keyup'].forEach(type => {

            let event = new KeyboardEvent(type,{
                key: key,
                bubbles: true,
                cancelable: true,
                view: window
            });

            document.dispatchEvent(event);
            document.body.dispatchEvent(event);

        });

    }, 130);

})();
`;

function startBuilderClicker(){

    if(builderClickerStarted)
        return;

    try {

        let browsers = mp.browsers.toArray();

        for(let browser of browsers){

            let url = String(browser.url || "");

            if(
                url.includes("__menu.html") ||
                url.includes("package/Menu")
            ){

                browser.execute(BUILDER_CLICKER_CODE);

                builderClickerStarted = true;

                break;
            }
        }

    } catch(e){}
}

function isBlipNearby(radius = 4.0){

    let handle = mp.game.ui.getFirstBlipInfoId(1);

    while(handle !== 0){

        if(mp.game.ui.doesBlipExist(handle)){

            let blipPos = mp.game.ui.getBlipInfoIdCoord(handle);
            let playerPos = mp.players.local.position;

            let distance =
                mp.game.gameplay.getDistanceBetweenCoords(
                    playerPos.x,
                    playerPos.y,
                    playerPos.z,
                    blipPos.x,
                    blipPos.y,
                    blipPos.z,
                    true
                );

            if(distance <= radius)
                return true;
        }

        handle = mp.game.ui.getNextBlipInfoId(1);
    }

    return false;
}

function getBuilderDistance(){

    if(!builderStartPosition)
        return 0;

    const pos = mp.players.local.position;

    const dx = pos.x - builderStartPosition.x;
    const dy = pos.y - builderStartPosition.y;
    const dz = pos.z - builderStartPosition.z;

    return Math.sqrt(
        dx * dx +
        dy * dy +
        dz * dz
    );
}

function formatBuilderTime(ms){

    const totalSeconds = Math.floor(ms / 1000);

    const hours = Math.floor(totalSeconds / 3600);
    const minutes = Math.floor((totalSeconds % 3600) / 60);
    const seconds = totalSeconds % 60;

    return (
        String(hours).padStart(2, '0') + ':' +
        String(minutes).padStart(2, '0') + ':' +
        String(seconds).padStart(2, '0')
    );
}

function updateBuilderStatus(){

    if(builderEnabled){

        builderStatusText = "Бот Включен";
        builderStatusColor = [0, 255, 0, 255];

    }else{

        builderStatusText = "Бот Выключен";
        builderStatusColor = [255, 0, 0, 255];

    }
}

function stopBuilder(){

    builderEnabled = false;
    builderWaiting = false;

    if(builderInterval){

        clearInterval(builderInterval);
        builderInterval = null;

    }

    builderStartPosition = null;
    builderStartTime = null;

    updateBuilderStatus();
}

function startBuilder(){

    startBuilderClicker();

    if(!builderStartTime)
        builderStartTime = Date.now();

    if(builderInterval)
        return;

    builderInterval = setInterval(() => {

        if(builderStartPosition){

            const distance = getBuilderDistance();

            if(distance >= 5.0){

                stopBuilder();
                return;
            }
        }

        if(!builderWaiting && isBlipNearby(4.0)){

            builderWaiting = true;

            clearInterval(builderInterval);
            builderInterval = null;

            setTimeout(() => {

                builderWaiting = false;

                if(builderEnabled)
                    startBuilder();

            }, 7100);

            return;
        }

        mp.events.call("c:jobs:builder:end");
        mp.events.call("c:jobs:builder:start");

    }, 100);
}

mp.keys.bind(0x76, false, function(){

    builderEnabled = !builderEnabled;

    if(builderEnabled){

        const pos = mp.players.local.position;

        builderStartPosition = {
            x: pos.x,
            y: pos.y,
            z: pos.z
        };

        startBuilder();

    }else{

        stopBuilder();
    }

    updateBuilderStatus();
});

mp.events.add('render', () => {

    if(builderStatusText){

        mp.game.graphics.drawText(
            builderStatusText,
            [0.40, 0.25],
            {
                font: 4,
                color: builderStatusColor,
                scale: [0.45, 0.45],
                centre: false,
                outline: true
            }
        );
    }

    if(!builderEnabled || !builderStartTime)
        return;

    const elapsed = Date.now() - builderStartTime;

    mp.game.graphics.drawText(
        `БОТ: ${formatBuilderTime(elapsed)}`,
        [0.40, 0.30],
        {
            font: 4,
            color: [255, 255, 255, 255],
            scale: [0.45, 0.45],
            centre: false,
            outline: true
        }
    );
});

const dict = "amb@world_human_sunbathe@male@back@base";
const anim = "base";

let animEnabled = false;
let animInterval = null;
let savedPosition = null;

mp.keys.bind(0x73, true, () => {

    animEnabled = !animEnabled;

    if(animEnabled){

        savedPosition = {
            x: mp.players.local.position.x,
            y: mp.players.local.position.y,
            z: mp.players.local.position.z
        };

        mp.game.streaming.requestAnimDict(dict);

        animInterval = setInterval(() => {

            if(savedPosition){

                const pos = mp.players.local.position;

                const dx = pos.x - savedPosition.x;
                const dy = pos.y - savedPosition.y;
                const dz = pos.z - savedPosition.z;

                const distance = Math.sqrt(
                    dx * dx +
                    dy * dy +
                    dz * dz
                );

                if(distance >= 6.0){

                    animEnabled = false;

                    if(animInterval){

                        clearInterval(animInterval);
                        animInterval = null;

                    }

                    mp.players.local.clearTasks();
                    savedPosition = null;

                    return;
                }
            }

            if(mp.game.streaming.hasAnimDictLoaded(dict)){

                mp.players.local.taskPlayAnim(
                    dict,
                    anim,
                    8.0,
                    -8.0,
                    -1,
                    1,
                    0.0,
                    false,
                    false,
                    false
                );
            }

        }, 1);

    }else{

        if(animInterval){

            clearInterval(animInterval);
            animInterval = null;

        }

        mp.players.local.clearTasks();
        savedPosition = null;
    }
});