// ==UserScript==
// @name        A.C.A.S (Advanced Chess Assistance System)
// @name:en     A.C.A.S (Advanced Chess Assistance System)
// @name:fi     A.C.A.S (Edistynyt shakkiavustusjärjestelmä)
// @name:zh-CN  A.C.A.S（高级国际象棋辅助系统）
// @name:es     A.C.A.S (Sistema Avanzado de Asistencia al Ajedrez)
// @name:hi     A.C.A.S (उन्नत शतरंज सहायता प्रणाली)
// @name:ar     A.C.A.S (نظام المساعدة المتقدم في الشطرنج)
// @name:pt     A.C.A.S (Sistema Avançado de Assistência ao Xadrez)
// @name:ja     A.C.A.S（先進的なチェス支援システム）
// @name:de     A.C.A.S (Fortgeschrittenes Schach-Hilfesystem)
// @name:fr     A.C.A.S (Système Avancé d'Assistance aux Échecs)
// @name:it     A.C.A.S (Sistema Avanzato di Assistenza agli Scacchi)
// @name:ko     A.C.A.S (고급 체스 보조 시스템)
// @name:nl     A.C.A.S (Geavanceerd Schaakondersteuningssysteem)
// @name:pl     A.C.A.S (Zaawansowany System Pomocy Szachowej)
// @name:tr     A.C.A.S (Gelişmiş Satranç Yardım Sistemi)
// @name:vi     A.C.A.S (Hệ Thống Hỗ Trợ Cờ Vua Nâng Cao)
// @name:uk     A.C.A.S (Система передової допомоги в шахах)
// @name:ru     A.C.A.S (Система расширенной помощи в шахматах)
// @description        Enhance your chess performance with a cutting-edge real-time move analysis and strategy assistance system
// @description:en     Enhance your chess performance with a cutting-edge real-time move analysis and strategy assistance system
// @description:fi     Paranna shakkipelisi suorituskykyä huippuluokan reaaliaikaisen siirtoanalyysin ja strategisen avustusjärjestelmän avulla
// @description:zh-CN  利用尖端实时走法分析和策略辅助系统，提升您的国际象棋水平
// @description:es     Mejora tu rendimiento en ajedrez con un sistema de análisis de movimientos en tiempo real y asistencia estratégica de vanguardia
// @description:hi     अपने शतरंज प्रदर्शन को उन्नत करें, एक कटिंग-एज रियल-टाइम मूव विश्लेषण और रणनीति सहायता प्रणाली के साथ
// @description:ar     قم بتحسين أداءك في الشطرنج مع تحليل حركات اللعب في الوقت الحقيقي ونظام مساعدة استراتيجية حديث
// @description:pt     Melhore seu desempenho no xadrez com uma análise de movimentos em tempo real e um sistema avançado de assistência estratégica
// @description:ja     最新のリアルタイムのムーブ分析と戦略支援システムでチェスのパフォーマンスを向上させましょう
// @description:de     Verbessern Sie Ihre Schachleistung mit einer hochmodernen Echtzeitzug-Analyse- und Strategiehilfe-System
// @description:fr     Améliorez vos performances aux échecs avec une analyse de mouvement en temps réel de pointe et un système d'assistance stratégique
// @description:it     Migliora le tue prestazioni agli scacchi con un sistema all'avanguardia di analisi dei movimenti in tempo reale e assistenza strategica
// @description:ko     최첨단 실시간 움직임 분석 및 전략 지원 시스템으로 체스 성과 향상
// @description:nl     Verbeter je schaakprestaties met een geavanceerd systeem voor realtime zetanalyse en strategische ondersteuning
// @description:pl     Popraw swoje osiągnięcia w szachach dzięki zaawansowanemu systemowi analizy ruchów w czasie rzeczywistym i wsparciu strategicznemu
// @description:tr     Keskinleşmiş gerçek zamanlı hareket analizi ve strateji yardım sistemiyle satranç performansınızı artırın
// @description:vi     Nâng cao hiệu suất cờ vua của bạn với hệ thống phân tích nước đi và hỗ trợ chiến thuật hiện đại
// @description:uk     Покращуйте свою шахову гру з використанням передової системи аналізу ходів в режимі реального часу та стратегічної підтримки
// @description:ru     Слава Украине
// @homepageURL https://hakorr.github.io/A.C.A.S
// @supportURL  https://github.com/Hakorr/A.C.A.S/tree/main#why-doesnt-it-work
// @match       https://www.chess.com/*
// @match       https://lichess.org/*
// @match       https://playstrategy.org/*
// @match       https://www.pychess.org/*
// @match       https://chess.org/*
// @match       https://papergames.io/*
// @match       https://vole.wtf/kilobytes-gambit/
// @match       https://hakorr.github.io/A.C.A.S/*
// @match       http://localhost/*
// @grant       GM_getValue
// @grant       GM_setValue
// @grant       GM_deleteValue
// @grant       GM_listValues
// @grant       GM_registerMenuCommand
// @grant       GM_openInTab
// @grant       GM_addStyle
// @grant       unsafeWindow
// @run-at      document-start
// @version     2.0.3
// @namespace   HKR
// @author      HKR
// @require     https://greasyfork.org/scripts/470418-commlink-js/code/CommLinkjs.js
// @require     https://greasyfork.org/scripts/470417-universalboarddrawer-js/code/UniversalBoardDrawerjs.js
// @downloadURL none
// ==/UserScript==

/*
     e            e88~-_            e           ,d88~~\
    d8b          d888   \          d8b          8888
   /Y88b         8888             /Y88b         `Y88b
  /  Y88b        8888            /  Y88b         `Y88b,
 /____Y88b  d88b Y888   / d88b  /____Y88b  d88b    8888
/      Y88b Y88P  "88_-~  Y88P /      Y88b Y88P \__88P'

Advanced Chess Assistance System (A.C.A.S) v2 | Q3 2023

[WARNING]
- Please be advised that the use of A.C.A.S may violate the rules and lead to disqualification or banning from tournaments and online platforms.
- The developers of A.C.A.S and related systems will NOT be held accountable for any consequences resulting from its use.
- We strongly advise to use A.C.A.S only in a controlled environment ethically.*/

// DANGER ZONE - DO NOT PROCEED IF YOU DON'T KNOW WHAT YOU'RE DOING //
/*\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*/
//////////////////////////////////////////////////////////////////////
// DANGER ZONE - DO NOT PROCEED IF YOU DON'T KNOW WHAT YOU'RE DOING //

const backendURL = 'https://hakorr.github.io/A.C.A.S/'; // FOR DEVELOPMENT USE: 'http://localhost/A.C.A.S/';

const domain = window.location.hostname.replace('www.', '');
const tempValueIndicator = '-temp-value-';

const dbValues = {
    AcasConfig: 'AcasConfig',
    playerColor: instanceID => 'playerColor' + tempValueIndicator + instanceID,
    turn: instanceID => 'turn' + tempValueIndicator + instanceID,
    fen: instanceID => 'fen' + tempValueIndicator + instanceID
};

function createInstanceVariable(dbValue) {
    return {
        set: (instanceID, value) => GM_setValue(dbValues[dbValue](instanceID), { value, 'date': Date.now() }),
        get: instanceID => {
            const data = GM_getValue(dbValues[dbValue](instanceID));

            if(data?.date) {
                data.date = Date.now();

                GM_setValue(dbValues[dbValue](instanceID), data);
            }

            return data?.value;
        }
    }
}

const instanceVars = {
    playerColor: createInstanceVariable('playerColor'),
    turn: createInstanceVariable('turn'),
    fen: createInstanceVariable('fen')
};

if(window?.location?.href?.includes(backendURL)) {
    // expose variables and functions
    unsafeWindow.USERSCRIPT = {
        'GM_info': GM_info,
        'GM_getValue': val => GM_getValue(val),
        'GM_setValue': (val, data) => GM_setValue(val, data),
        'GM_deleteValue': val => GM_deleteValue(val),
        'GM_listValues': val => GM_listValues(val),
        'tempValueIndicator': tempValueIndicator,
        'dbValues': dbValues,
        'instanceVars': instanceVars,
        'CommLinkHandler': CommLinkHandler,
    };

    return;
}

// DANGER ZONE - DO NOT PROCEED IF YOU DON'T KNOW WHAT YOU'RE DOING //
/*\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*/
//////////////////////////////////////////////////////////////////////
// DANGER ZONE - DO NOT PROCEED IF YOU DON'T KNOW WHAT YOU'RE DOING //

function getUniqueID() {
    return ([1e7]+-1e3+4e3+-8e3+-1e11).replace(/[018]/g, c =>
        (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
    )
}

const commLinkInstanceID = getUniqueID();

const blacklistedURLs = [
    'https://www.chess.com/play',
    'https://lichess.org/',
    'https://chess.org/',
    'https://papergames.io/en/chess',
    'https://playstrategy.org/',
    'https://www.pychess.org/',
    'https://hakorr.github.io/A.C.A.S/',
    'https://hakorr.github.io/A.C.A.S/why/',
    'https://hakorr.github.io/A.C.A.S/tos/',
    'http://localhost/A.C.A.S/'
];

const configKeys = {
    'engineElo': 'engineElo',
    'moveSuggestionAmount': 'moveSuggestionAmount',
    'arrowOpacity': 'arrowOpacity',
    'displayMovesOnExternalSite': 'displayMovesOnExternalSite',
    'showMoveGhost': 'showMoveGhost',
    'showOpponentMoveGuess': 'showOpponentMoveGuess',
    'maxMovetime': 'maxMovetime',
    'chessVariant': 'chessVariant',
    'chessFont': 'chessFont',
    'useChess960': 'useChess960'
};

const config = {};

Object.values(configKeys).forEach(key => {
    config[key] = {
        get:  () => getGmConfigValue(key, commLinkInstanceID),
        set: null
    };
});

const debugModeActivated = false;

let BoardDrawer = null;
let chessBoardElem = null;
let lastBasicFen = null;
let chesscomVariantBoardCoordsTable = null;
let activeSiteMoveHighlights = [];
let inactiveGuiMoveMarkings = [];

let lastBoardRanks = null;
let lastBoardFiles = null;

let lastBoardSize = null;
let lastPieceSize = null;

let lastBoardOrientation = null;

const domainsWithoutDifferentBoardDimensionsArr = ['chess.org', 'lichess.org', 'papergames.io', 'vole.wtf'];

const arrowStyles = {
    'best': `
        fill: limegreen;
        opacity: ${getConfigValue(configKeys.arrowOpacity)/100 || '0.9'};
        stroke: rgb(0 0 0 / 50%);
        stroke-width: 2px;
        stroke-linejoin: round;
    `,
    'secondary': `
        fill: dodgerblue;
        opacity: ${getConfigValue(configKeys.arrowOpacity)/100 || '0.7'};
        stroke: rgb(0 0 0 / 50%);
        stroke-width: 2px;
        stroke-linejoin: round;
    `,
    'opponent': `
        fill: crimson;
        stroke: rgb(0 0 0 / 25%);
        stroke-width: 2px;
        stroke-linejoin: round;
        display: none;
        opacity: ${getConfigValue(configKeys.arrowOpacity)/100 || '0.3'};
    `
};

const CommLink = new CommLinkHandler(`frontend_${commLinkInstanceID}`, {
    'singlePacketResponseWaitTime': 1500,
    'maxSendAttempts': 3,
    'statusCheckInterval': 1,
    'silentMode': true
});

// manually register a command so that the variables are dynamic
CommLink.commands['createInstance'] = async () => {
    return await CommLink.send('mum', 'createInstance', {
        'domain': domain,
        'instanceID': commLinkInstanceID,
        'chessVariant': getChessVariant(),
        'playerColor': getPlayerColorVariable()
    });
}

CommLink.registerSendCommand('ping', { commlinkID: 'mum', data: 'ping' });
CommLink.registerSendCommand('pingInstance', { data: 'ping' });
CommLink.registerSendCommand('log');
CommLink.registerSendCommand('updateBoardOrientation');
CommLink.registerSendCommand('updateBoardFen');
CommLink.registerSendCommand('calculateBestMoves');

CommLink.registerListener(`backend_${commLinkInstanceID}`, packet => {
    try {
        switch(packet.command) {
            case 'ping':
                return `pong (took ${Date.now() - packet.date}ms)`;
            case 'getFen':
                return getFen();
            case 'removeSiteMoveMarkings':
                boardUtils.removeBestMarkings();
                return true;
            case 'markMoveToSite':
                boardUtils.markMove(packet.data);
                return true;
        }
    } catch(e) {
        return null;
    }
});

function filterInvisibleElems(elementArr, inverse) {
    return [...elementArr].filter(elem => {
        const style = getComputedStyle(elem);
        const bounds = elem.getBoundingClientRect();

        const isHidden =
            style.visibility === 'hidden' ||
            style.display === 'none' ||
            style.opacity === '0' ||
            bounds.width == 0 ||
            bounds.height == 0;

        return inverse ? isHidden : !isHidden;
    });
}

function getElementSize(elem) {
    const rect = elem.getBoundingClientRect();

    if(rect.width !== 0 && rect.height !== 0) {
        return { width: rect.width, height: rect.height };
    }

    const computedStyle = window.getComputedStyle(elem);
    const width = parseFloat(computedStyle.width);
    const height = parseFloat(computedStyle.height);

    return { width, height };
}

function extractElemTransformData(elem) {
    const computedStyle = window.getComputedStyle(elem);
    const transformMatrix = new DOMMatrix(computedStyle.transform);

    const x = transformMatrix.e;
    const y = transformMatrix.f;

    return [x, y];
}

function getElemCoordinatesFromTransform(elem) {
    if (!lastBoardSize) {
        lastBoardSize = getElementSize(chessBoardElem);
    }

    if (!lastBoardRanks) {
        const [files, ranks] = getBoardDimensions();

        lastBoardRanks = ranks;
        lastBoardFiles = files;
    }

    const boardOrientation = getPlayerColorVariable();

    const [x, y] = extractElemTransformData(elem);

    const boardDimensions = lastBoardSize;
    const squareDimensions = boardDimensions.width / lastBoardRanks;

    const normalizedX = Math.round(x / squareDimensions);
    const normalizedY = Math.round(y / squareDimensions);

    if (boardOrientation === 'w') {
        const flippedY = lastBoardFiles - normalizedY - 1;

        return [normalizedX, flippedY];
    } else {
        const flippedX = lastBoardRanks - normalizedX - 1;

        return [flippedX, normalizedY];
    }
}


function createChesscomVariantBoardCoordsTable() {
    chesscomVariantBoardCoordsTable = {};

    const boardElem = getBoardElem();
    const [boardWidth, boardHeight] = getBoardDimensions();
    const boardOrientation = getBoardOrientation();

    const squareElems = getSquareElems(boardElem);

    let squareIndex = 0;

    for(let x = 0; x < boardWidth; x++) {
        for(let y = boardHeight; y > 0; y--) {
            const squareElem = squareElems[squareIndex];
            const id = squareElem?.id;

            const xIdx = x;
            const yIdx = y - 1;

            if(id) {
                chesscomVariantBoardCoordsTable[id] = [xIdx, yIdx];
            }

            squareIndex++;
        }
    }
}

function chessCoordinatesToIndex(coord) {
    const x = coord.charCodeAt(0) - 97;
    let y = null;

    const lastHalf = coord.slice(1);

    if(lastHalf === ':') {
        y = 9;
    } else {
        y = Number(coord.slice(1)) - 1;
    }

    return [x, y];
}

function getGmConfigValue(key, instanceID) {
    const config = GM_getValue(dbValues.AcasConfig);

    const instanceValue = config?.instance?.[instanceID]?.[key];
    const globalValue = config?.global?.[key];

    if(instanceValue !== undefined) {
        return instanceValue;
    }

    if(globalValue !== undefined) {
        return globalValue;
    }

    return null;
}

function getConfigValue(key) {
    return config[key]?.get();
}

function setConfigValue(key, val) {
    return config[key]?.set(val);
}

function squeezeEmptySquares(fenStr) {
    return fenStr.replace(/1+/g, match => match.length);
}

function getPlayerColorVariable() {
    return instanceVars.playerColor.get(commLinkInstanceID);
}

function getFenPieceColor(pieceFenStr) {
    return pieceFenStr == pieceFenStr.toUpperCase() ? 'w' : 'b';
}

function getFenPieceOppositeColor(pieceFenStr) {
    return getFenPieceColor(pieceFenStr) == 'w' ? 'b' : 'w';
}

function convertPieceStrToFen(str) {
    if(!str || str.length !== 2) {
        return null;
    }

    const firstChar = str[0].toLowerCase();
    const secondChar = str[1];

    if(firstChar === 'w') {
        return secondChar.toUpperCase();
    } else if (firstChar === 'b') {
        return secondChar.toLowerCase();
    }

    return null;
}

function getBoardElem() {
    const pathname = window.location.pathname;

    switch(domain) {
        case 'chess.com': {
            if(pathname?.includes('/variants')) {
                return document.querySelector('#board');
            }

            return document.querySelector('chess-board');
        }

        case 'lichess.org': {
            return document.querySelector('cg-board');
        }

        case 'playstrategy.org': {
            return document.querySelector('cg-board');
        }

        case 'pychess.org': {
            return document.querySelector('cg-board');
        }

        case 'chess.org': {
            return document.querySelector('.cg-board');
        }

        case 'papergames.io': {
            return document.querySelector('#chessboard');
        }

        case 'vole.wtf': {
            return document.querySelector('#board');
        }
    }

    return null;
}

function getChessPieceElem(getAll) {
    const pathname = window.location.pathname;
    const boardElem = getBoardElem();

    const querySelector = (getAll ? query => [...boardElem?.querySelectorAll(query)] : boardElem?.querySelector?.bind(boardElem));

    switch(domain) {
        case 'chess.com': {
            if(pathname?.includes('/variants')) {
                const filteredPieceElems = filterInvisibleElems(document.querySelectorAll('#board *[data-piece]'))
                    .filter(elem => Number(elem?.dataset?.player) <= 2);

                return getAll ? filteredPieceElems : filteredPieceElems[0];
            }

            return querySelector('.piece');
        }

        case 'lichess.org': {
            return querySelector('piece:not(.ghost)');
        }

        case 'playstrategy.org': {
            return querySelector('piece[class*="-piece"]:not(.ghost)');
        }

        case 'pychess.org': {
            return querySelector('piece[class*="-piece"]:not(.ghost)');
        }

        case 'chess.org': {
            return querySelector('piece:not(.ghost)');
        }

        case 'papergames.io': {
            return querySelector('*[data-piece][data-square]');
        }

        case 'vole.wtf': {
            return querySelector('*[data-t][data-l][data-p]:not([data-p="0"]');
        }
    }

    return null;
}

function getSquareElems(element) {
    const pathname = window.location.pathname;

    switch(domain) {
        case 'chess.com': {
            if(pathname?.includes('/variants')) {
                return [...element.querySelectorAll('.square-4pc.ui-droppable')]
                    .filter(elem => {
                        const pieceElem = elem.querySelector('[data-player]');
                        const playerNum = Number(pieceElem?.dataset?.player);

                        return (!playerNum || playerNum <= 2);
                    });
            }

            break;
        }
    }

    return null;
}

function isMutationNewMove(mutationArr) {
    const pathname = window.location.pathname;

    switch(domain) {
        case 'chess.com': {
            if(pathname?.includes('/variants')) {
                return mutationArr.find(m => m.attributeName == 'class') ? true : false;
            }

            if(mutationArr.length == 1)
                return false;

            const modifiedHoverSquare = mutationArr.find(m => m?.target?.classList?.contains('hover-square')) ? true : false;
            const modifiedHighlight = mutationArr.find(m => m?.target?.classList?.contains('highlight')) ? true : false;
            const modifiedElemPool = mutationArr.find(m => m?.target?.classList?.contains('element-pool')) ? true : false;

            return (mutationArr.length >= 4 && !modifiedHoverSquare)
                || mutationArr.length >= 7
                || modifiedHighlight
                || modifiedElemPool;
        }

        case 'lichess.org': {
            return mutationArr.length >= 4
                || mutationArr.find(m => m.type === 'childList') ? true : false
                || mutationArr.find(m => m?.target?.classList?.contains('last-move')) ? true : false;
        }

        case 'playstrategy.org': {
            return mutationArr.length >= 4
                || mutationArr.find(m => m.type === 'childList') ? true : false
                || mutationArr.find(m => m?.target?.classList?.contains('last-move')) ? true : false;
        }

        case 'pychess.org': {
            return mutationArr.length >= 4
                || mutationArr.find(m => m.type === 'childList') ? true : false
                || mutationArr.find(m => m?.target?.classList?.contains('last-move')) ? true : false;
        }

        case 'chess.org': {
            return mutationArr.length >= 4
                || mutationArr.find(m => m.type === 'childList') ? true : false
                || mutationArr.find(m => m?.target?.classList?.contains('last-move')) ? true : false;
        }

        case 'papergames.io': {
            return mutationArr.length >= 12;
        }

        case 'vole.wtf': {
            return mutationArr.length >= 12;
        }
    }

    return false;
}

function getChessVariant() {
    const pathname = window.location.pathname;

    switch(domain) {
        case 'chess.com': {
            if(pathname?.includes('/variants')) {
                const variant = pathname.match(/variants\/([^\/]*)/)?.[1]
                    .replaceAll('-chess', '')
                    .replaceAll('-', '');

                const replacementTable = {
                    'doubles-bughouse': 'bughouse',
                    'paradigm-chess30': 'paradigm'
                };

                return replacementTable[variant] || variant;
            }

            break;
        }

        case 'lichess.org': {
            const variantLinkElem = document.querySelector('.variant-link');

            if(variantLinkElem) {
                let variant = variantLinkElem?.innerText?.toLowerCase()?.replaceAll(' ', '-');

                const replacementTable = {
                    'correspondence': 'chess',
                    'koth': 'kingofthehill',
                    'three-check': '3check'
                };

                return replacementTable[variant] || variant;
            }

            break;
        }

        case 'playstrategy.org': {
            const variantLinkElem = document.querySelector('.variant-link');

            if(variantLinkElem) {
                let variant = variantLinkElem?.innerText
                    ?.toLowerCase()
                    ?.replaceAll(' ', '-');

                const replacementTable = {
                    'correspondence': 'chess',
                    'koth': 'kingofthehill',
                    'three-check': '3check',
                    'five-check': '5check',
                    'no-castling': 'nocastle'
                };

                return replacementTable[variant] || variant;
            }

            break;
        }

        case 'pychess.org': {
            const variantLinkElem = document.querySelector('#main-wrap .tc .user-link');

            if(variantLinkElem) {
                let variant = variantLinkElem?.innerText
                    ?.toLowerCase()
                    ?.replaceAll(' ', '')
                    ?.replaceAll('-', '');

                const replacementTable = {
                    'correspondence': 'chess',
                    'koth': 'kingofthehill',
                    'nocastling': 'nocastle',
                    'gorogoro+': 'gorogoro',
                    'oukchaktrang': 'cambodian'
                };

                return replacementTable[variant] || variant;
            }

            break;
        }

        case 'chess.org': {
            const variantNum = unsafeWindow?.GameConfig?.instance?.variant;
            let variant = GameConfig?.VARIANT_NAMES?.[variantNum]?.toLowerCase();

            if(variant) {
                const replacementTable = {
                    'standard': 'chess'
                };

                return replacementTable[variant] || variant;
            }

            break;
        }

        case 'papergames.io': {
            return 'chess';
        }

        case 'vole.wtf': {
            return 'chess';
        }
    }

    return 'chess';
}

function getBoardOrientation() {
    const pathname = window.location.pathname;

    switch(domain) {
        case 'chess.com': {
            if(pathname?.includes('/variants')) {
                const playerNumberStr = document.querySelector('.playerbox-bottom [data-player]')?.dataset?.player;

                return playerNumberStr == '0' ? 'w' : 'b';
            }

            const boardElem = getBoardElem();

            return boardElem?.classList.contains('flipped') ? 'b' : 'w';
        }

        case 'lichess.org': {
            const filesElem = document.querySelector('coords.files');

            return filesElem?.classList?.contains('black') ? 'b' : 'w';
        }

        case 'playstrategy.org': {
            const cgWrapElem = document.querySelector('.cg-wrap');

            return cgWrapElem.classList?.contains('orientation-p1') ? 'w' : 'b';
        }

        case 'pychess.org': {
            const cgWrapElem = document.querySelector('.cg-wrap');

            return cgWrapElem.classList?.contains('orientation-black') ? 'b' : 'w';
        }

        case 'chess.org': {
            const filesElem = document.querySelector('coords.files');

            return filesElem?.classList?.contains('black') ? 'b' : 'w';
        }

        case 'papergames.io': {
            const boardElem = getBoardElem();

            if(boardElem) {
                const firstRankText = [...boardElem.querySelector('.coordinates').childNodes]?.[0].textContent;

                return firstRankText == 'h' ? 'b' : 'w';
            }
        }

        case 'vole.wtf': {
            return 'w';
        }
    }

    return null;
}

function getPieceElemFen(pieceElem) {
    const pathname = window.location.pathname;

    const pieceNameToFen = {
        'pawn': 'p',
        'knight': 'n',
        'bishop': 'b',
        'rook': 'r',
        'queen': 'q',
        'king': 'k'
    };

    switch(domain) {
        case 'chess.com': {
            let pieceColor = null;
            let pieceName = null;

            if(pathname?.includes('/variants')) {
                pieceColor = pieceElem?.dataset?.player == '0' ? 'w' : 'b';
                pieceName = pieceElem?.dataset?.piece;
            } else {
                const pieceStr = [...pieceElem.classList].find(x => x.match(/^(b|w)[prnbqk]{1}$/));

                [pieceColor, pieceName] = pieceStr.split('');
            }

            return pieceColor == 'w' ? pieceName.toUpperCase() : pieceName.toLowerCase();
        }

        case 'lichess.org': {
            const pieceColor = pieceElem?.classList?.contains('white') ? 'w' : 'b';
            const elemPieceName = [...pieceElem?.classList]?.find(className => Object.keys(pieceNameToFen).includes(className));

            if(pieceColor && elemPieceName) {
                const pieceName = pieceNameToFen[elemPieceName];

                return pieceColor == 'w' ? pieceName.toUpperCase() : pieceName.toLowerCase();
            }

            break;
        }

        case 'playstrategy.org': {
            const playerColor = getPlayerColorVariable();
            const pieceColor = pieceElem?.classList?.contains('ally') ? playerColor : (playerColor == 'w' ? 'b' : 'w');

            let pieceName = null;

            [...pieceElem?.classList]?.forEach(className => {
                if(className?.includes('-piece')) {
                    const elemPieceName = className?.split('-piece')?.[0];

                    if(elemPieceName && elemPieceName?.length === 1) {
                        pieceName = elemPieceName;
                    }
                }
            });

            if(pieceColor && pieceName) {
                return pieceColor == 'w' ? pieceName.toUpperCase() : pieceName.toLowerCase();
            }

            break;
        }

        case 'pychess.org': {
            const playerColor = getPlayerColorVariable();
            const pieceColor = pieceElem?.classList?.contains('ally') ? playerColor : (playerColor == 'w' ? 'b' : 'w');

            let pieceName = null;

            [...pieceElem?.classList]?.forEach(className => {
                if(className?.includes('-piece')) {
                    const elemPieceName = className?.split('-piece')?.[0];

                    if(elemPieceName && elemPieceName?.length === 1) {
                        pieceName = elemPieceName;
                    }
                }
            });

            if(pieceColor && pieceName) {
                return pieceColor == 'w' ? pieceName.toUpperCase() : pieceName.toLowerCase();
            }

            break;
        }

        case 'chess.org': {
            const pieceColor = pieceElem?.classList?.contains('white') ? 'w' : 'b';
            const elemPieceName = [...pieceElem?.classList]?.find(className => Object.keys(pieceNameToFen).includes(className));

            if(pieceColor && elemPieceName) {
                const pieceName = pieceNameToFen[elemPieceName];

                return pieceColor == 'w' ? pieceName.toUpperCase() : pieceName.toLowerCase();
            }

            break;
        }

        case 'papergames.io': {
            return convertPieceStrToFen(pieceElem?.dataset?.piece);
        }

        case 'vole.wtf': {
            const pieceNum = Number(pieceElem?.dataset?.p);
            const pieceFenStr = 'pknbrq';

            if(pieceNum > 8) {
                return pieceFenStr[pieceNum - 9].toUpperCase();
            } else {
                return pieceFenStr[pieceNum - 1];
            }
        }
    }

    return null;
}


// this function gets called a lot, needs to be optimized
function getPieceElemCoords(pieceElem) {
    const pathname = window.location.pathname;

    switch(domain) {
        case 'chess.com': {
            if(pathname?.includes('/variants')) {
                const squareElem = pieceElem.parentElement;
                const squareId = squareElem.id;

                if(!chesscomVariantBoardCoordsTable) {
                    createChesscomVariantBoardCoordsTable();
                }

                return chesscomVariantBoardCoordsTable[squareId];
            }

            return pieceElem.classList.toString()
                ?.match(/square-(\d)(\d)/)
                ?.slice(1)
                ?.map(x => Number(x) - 1);
        }

        case 'lichess.org': {
            const key = pieceElem?.cgKey;

            if(!key) break;

            return chessCoordinatesToIndex(key);
        }

        case 'playstrategy.org': {
            const key = pieceElem?.cgKey;

            if(!key) break;

            return chessCoordinatesToIndex(key);
        }

        case 'pychess.org': {
            const key = pieceElem?.cgKey;

            if(!key) break;

            return chessCoordinatesToIndex(key);
        }

        case 'chess.org': {
            return getElemCoordinatesFromTransform(pieceElem);
        }

        case 'papergames.io': {
            const key = pieceElem?.dataset?.square;

            if(!key) break;

            return chessCoordinatesToIndex(key);
        }

        case 'vole.wtf': {
            return [Number(pieceElem?.dataset?.l), 7 - Number(pieceElem?.dataset?.t)];
        }
    }

    return null;
}

function getBoardDimensions() {
    const pathname = window.location.pathname;

    switch(domain) {
        case 'chess.com': {
            if(pathname?.includes('/variants')) {
                const rankElems = chessBoardElem?.querySelectorAll('.rank');
                const visibleRankElems = filterInvisibleElems(rankElems)
                    .filter(rankElem => [...rankElem.childNodes]
                        .find(elem => {
                            const pieceElem = elem.querySelector('[data-player]');
                            const playerNum = Number(pieceElem?.dataset?.player);

                            return playerNum <= 2;
                        }));


                if(visibleRankElems.length) {
                    const rankElem = visibleRankElems[0];
                    const squareElems = getSquareElems(rankElem);

                    const ranks = visibleRankElems?.length;
                    const files = squareElems?.length;

                    return [ranks, files];
                }
            }

            break;
        }

        default: {
            if(domainsWithoutDifferentBoardDimensionsArr?.includes(domain)) break;

            const boardDimensions = getElementSize(chessBoardElem);

            lastBoardSize = getElementSize(chessBoardElem);

            const boardWidth = boardDimensions?.width;
            const boardHeight = boardDimensions.height;

            const boardPiece = getChessPieceElem();

            if(boardPiece) {
                const pieceDimensions = getElementSize(boardPiece);

                lastPieceSize = getElementSize(boardPiece);

                const boardPieceWidth = pieceDimensions?.width;
                const boardPieceHeight = pieceDimensions?.height;

                const boardRanks = Math.floor(boardWidth / boardPieceWidth);
                const boardFiles = Math.floor(boardHeight / boardPieceHeight);

                const ranksInAllowedRange = 0 < boardRanks && boardRanks <= 69;
                const filesInAllowedRange = 0 < boardFiles && boardFiles <= 69;

                if(ranksInAllowedRange && filesInAllowedRange) {
                    lastBoardRanks = boardRanks;
                    lastBoardFiles = boardFiles;

                    return [boardRanks, boardFiles];
                }
            }

            break;
        }
    }

    lastBoardRanks = 8;
    lastBoardFiles = 8;

    return [8, 8];
}

function getFen(onlyBasic) {
    const [boardRanks, boardFiles] = getBoardDimensions();

    if(debugModeActivated) console.warn('getFen()', 'onlyBasic:', onlyBasic, 'Ranks:', boardRanks, 'Files:', boardFiles);

    const board = Array.from({ length: boardFiles }, () => Array(boardRanks).fill(1));

    function getBasicFen() {
        const pieceElems = getChessPieceElem(true);
        const isValidPieceElemsArray = Array.isArray(pieceElems) || pieceElems instanceof NodeList;

        if(isValidPieceElemsArray) {
            pieceElems.forEach(pieceElem => {
                const pieceFenCode = getPieceElemFen(pieceElem);
                const pieceCoordsArr = getPieceElemCoords(pieceElem);

                if(debugModeActivated) console.warn('pieceElem', pieceElem, 'pieceFenCode', pieceFenCode, 'pieceCoordsArr', pieceCoordsArr);

                try {
                    const [xIdx, yIdx] = pieceCoordsArr;

                    board[boardFiles - (yIdx + 1)][xIdx] = pieceFenCode;
                } catch(e) {
                    if(debugModeActivated) console.error(e);
                }
            });
        }

        return squeezeEmptySquares(board.map(x => x.join('')).join('/'));
    }

    const basicFen = getBasicFen();

    if(onlyBasic) {
        return basicFen;
    }

    return `${basicFen} ${getPlayerColorVariable()} - - - -`;
}

const boardUtils = {
    markMove: moveObj => {
        if(!getConfigValue(configKeys.displayMovesOnExternalSite)) return;

        const [from, to] = moveObj.player;
        const [opponentFrom, opponentTo] = moveObj.opponent;
        const ranking = moveObj.ranking;

        const existingExactSameMoveObj = activeSiteMoveHighlights.find(obj => {
            const [activeFrom, activeTo] = obj.player;
            const [activeOpponentFrom, activeOpponentTo] = obj.opponent;

            return from == activeFrom
                && to == activeTo
                && opponentFrom == activeOpponentFrom
                && opponentTo == activeOpponentTo;
        });

        activeSiteMoveHighlights.map(obj => {
            const [activeFrom, activeTo] = obj.player;

            const existingSameMoveObj = from == activeFrom && to == activeTo;

            if(existingSameMoveObj) {
                obj.promotedRanking = 1;
            }

            return obj;
        });

        const exactSameMoveDoesNotExist = typeof existingExactSameMoveObj !== 'object';

        if(exactSameMoveDoesNotExist) {

            const showOpponentMoveGuess = getConfigValue(configKeys.showOpponentMoveGuess);

            const opponentMoveGuessExists = typeof opponentFrom == 'string';

            const arrowStyle = ranking == 1 ? arrowStyles.best : arrowStyles.secondary;

            let opponentArrowElem = null;

            // create player move arrow element
            const arrowElem = BoardDrawer.createShape('arrow', [from, to],
                { style: arrowStyle }
            );

            // create opponent move arrow element
            if(opponentMoveGuessExists && showOpponentMoveGuess) {
                opponentArrowElem = BoardDrawer.createShape('arrow', [opponentFrom, opponentTo],
                    { style: arrowStyles.opponent }
                );

                const squareListener = BoardDrawer.addSquareListener(from, type => {
                    if(!opponentArrowElem) {
                        squareListener.remove();
                    }

                    switch(type) {
                        case 'enter':
                            opponentArrowElem.style.display = 'inherit';
                            break;
                        case 'leave':
                            opponentArrowElem.style.display = 'none';
                            break;
                    }
                });
            }

            activeSiteMoveHighlights.push({
                ...moveObj,
                'opponentArrowElem': opponentArrowElem,
                'playerArrowElem': arrowElem
            });
        }

        boardUtils.removeOldMarkings();
        boardUtils.paintMarkings();
    },
    removeOldMarkings: () => {
        const markingLimit = getConfigValue(configKeys.moveSuggestionAmount);
        const showGhost = getConfigValue(configKeys.showMoveGhost);

        const exceededMarkingLimit = activeSiteMoveHighlights.length > markingLimit;

        if(exceededMarkingLimit) {
            const amountToRemove = activeSiteMoveHighlights.length - markingLimit;

            for(let i = 0; i < amountToRemove; i++) {
                const oldestMarkingObj = activeSiteMoveHighlights[0];

                activeSiteMoveHighlights = activeSiteMoveHighlights.slice(1);

                if(oldestMarkingObj?.playerArrowElem?.style) {
                    oldestMarkingObj.playerArrowElem.style.fill = 'grey';
                    oldestMarkingObj.playerArrowElem.style.opacity = '0';
                    oldestMarkingObj.playerArrowElem.style.transition = 'opacity 2.5s ease-in-out';
                }

                if(oldestMarkingObj?.opponentArrowElem?.style) {
                    oldestMarkingObj.opponentArrowElem.style.fill = 'grey';
                    oldestMarkingObj.opponentArrowElem.style.opacity = '0';
                    oldestMarkingObj.opponentArrowElem.style.transition = 'opacity 2.5s ease-in-out';
                }

                if(showGhost) {
                    inactiveGuiMoveMarkings.push(oldestMarkingObj);
                } else {
                    oldestMarkingObj.playerArrowElem?.remove();
                    oldestMarkingObj.opponentArrowElem?.remove();
                }
            }
        }

        if(showGhost) {
            inactiveGuiMoveMarkings.forEach(markingObj => {
                const activeDuplicateArrow = activeSiteMoveHighlights.find(x => {
                    const samePlayerArrow = x.player?.toString() == markingObj.player?.toString();
                    const sameOpponentArrow = x.opponent?.toString() == markingObj.opponent?.toString();

                    return samePlayerArrow && sameOpponentArrow;
                });

                const duplicateExists = activeDuplicateArrow ? true : false;

                const removeArrows = () => {
                    inactiveGuiMoveMarkings = inactiveGuiMoveMarkings.filter(x => x.playerArrowElem != markingObj.playerArrowElem);

                    markingObj.playerArrowElem?.remove();
                    markingObj.opponentArrowElem?.remove();
                }

                if(duplicateExists) {
                    removeArrows();
                } else {
                    setTimeout(removeArrows, 2500);
                }
            });
        }
    },
    paintMarkings: () => {
        const newestBestMarkingIndex = activeSiteMoveHighlights.findLastIndex(obj => obj.ranking == 1);
        const newestPromotedBestMarkingIndex = activeSiteMoveHighlights.findLastIndex(obj => obj?.promotedRanking == 1);
        const lastMarkingIndex = activeSiteMoveHighlights.length - 1;

        const isLastMarkingBest = newestBestMarkingIndex == -1 && newestPromotedBestMarkingIndex == -1;
        const bestIndex = isLastMarkingBest ? lastMarkingIndex : Math.max(...[newestBestMarkingIndex, newestPromotedBestMarkingIndex]);

        let bestMoveMarked = false;

        activeSiteMoveHighlights.forEach((markingObj, idx) => {
            const isBestMarking = idx == bestIndex;

            if(isBestMarking) {
                markingObj.playerArrowElem.style.cssText = arrowStyles.best;

                const playerArrowElem = markingObj.playerArrowElem
                const opponentArrowElem = markingObj.opponentArrowElem;

                // move best arrow element on top (multiple same moves can hide the best move)
                const parentElem = markingObj.playerArrowElem.parentElement;

                parentElem.appendChild(playerArrowElem);

                if(opponentArrowElem) {
                    parentElem.appendChild(opponentArrowElem);
                }

                bestMoveMarked = true;
            } else {
                markingObj.playerArrowElem.style.cssText = arrowStyles.secondary;
            }
        });
    },
    removeBestMarkings: () => {
        activeSiteMoveHighlights.forEach(markingObj => {
            markingObj.opponentArrowElem?.remove();
            markingObj.playerArrowElem?.remove();
        });

        activeSiteMoveHighlights = [];
    },
    setBoardOrientation: orientation => {
        if(BoardDrawer) {
            if(debugModeActivated) console.warn('setBoardOrientation', orientation);

            BoardDrawer.setOrientation(orientation);
        }
    },
    setBoardDimensions: dimensionArr => {
        if(BoardDrawer) {
            if(debugModeActivated) console.warn('setBoardDimensions', dimensionArr);

            BoardDrawer.setBoardDimensions(dimensionArr);
        }
    }
};

function onNewMove(mutationArr) {
    if(debugModeActivated) console.warn('NEW MOVE DETECTED!');

    chesscomVariantBoardCoordsTable = null;

    boardUtils.setBoardDimensions(getBoardDimensions());

    const lastPlayerColor = getPlayerColorVariable();

    updatePlayerColor();

    const playerColor = getPlayerColorVariable();
    const orientationChanged = playerColor != lastPlayerColor;

    if(orientationChanged) {
        CommLink.commands.log(`Player color (e.g. board orientation) changed from ${lastPlayerColor} to ${playerColor}!`);

        chesscomVariantBoardCoordsTable = null;

        instanceVars.turn.set(commLinkInstanceID, playerColor);

        CommLink.commands.log(`Turn updated to ${playerColor}!`);
    }

    const currentFullFen = getFen();
    const currentBasicFen = currentFullFen?.split(' ')?.[0];

    const fenChanged = currentBasicFen != lastBasicFen;

    if(fenChanged) {
        lastBasicFen = currentBasicFen;

        boardUtils.removeBestMarkings();

        /*
        if(!orientationChanged) {
            const allChessPieceElems = getChessPieceElem(true);

            const attributeMutationArr = mutationArr.filter(m => allChessPieceElems.includes(m.target));
            const movedChessPieceElem = attributeMutationArr?.[0]?.target; // doesn't work for chess.com variants

            if(movedChessPieceElem) {
                const newTurn = getFenPieceOppositeColor(getPieceElemFen(movedChessPieceElem));

                if(newTurn?.length === 1) {
                    instanceVars.turn.set(commLinkInstanceID, newTurn);

                    CommLink.commands.log(`Turn updated to ${newTurn}!`);
                }
            }
        }
        */

        instanceVars.fen.set(commLinkInstanceID, currentFullFen);

        CommLink.commands.updateBoardFen(currentFullFen);
        CommLink.commands.calculateBestMoves(currentFullFen);
    }
}

function observeNewMoves() {
    let lastProcessedFen = null;

    const boardObserver = new MutationObserver(mutationArr => {
        if(debugModeActivated) console.log(mutationArr);

        if(isMutationNewMove(mutationArr))
        {
            if(debugModeActivated) console.warn('Mutation is a new move:', mutationArr);

            if(domain === 'chess.org')
            {
                setTimeout(() => onNewMove(mutationArr), 250);
            }
            else
            {
                onNewMove(mutationArr);
            }
        }
    });

    boardObserver.observe(chessBoardElem, { childList: true, subtree: true, attributes: true });
}

async function updatePlayerColor() {
    const boardOrientation = getBoardOrientation();

    const boardOrientationChanged = lastBoardOrientation !== boardOrientation;
    const boardOrientationDiffers = BoardDrawer && BoardDrawer?.orientation !== boardOrientation;

    if(boardOrientationChanged || boardOrientationDiffers) {
        lastBoardOrientation = boardOrientation;

        instanceVars.playerColor.set(commLinkInstanceID, boardOrientation);
        instanceVars.turn.set(commLinkInstanceID, boardOrientation);

        boardUtils.setBoardOrientation(boardOrientation);

        await CommLink.commands.updateBoardOrientation(boardOrientation);
    }
}

async function isAcasBackendReady() {
    const res = await CommLink.commands.ping();

    return res ? true : false;
}

async function start() {
    await CommLink.commands.createInstance(commLinkInstanceID);

    const pathname = window.location.pathname;
    const adjustSizeByDimensions = domain === 'chess.com' && pathname?.includes('/variants');

    const boardOrientation = getBoardOrientation();

    instanceVars.playerColor.set(commLinkInstanceID, boardOrientation);
    instanceVars.turn.set(commLinkInstanceID, boardOrientation);
    instanceVars.fen.set(commLinkInstanceID, getFen());

    if(getConfigValue(configKeys.displayMovesOnExternalSite)) {
        BoardDrawer = new UniversalBoardDrawer(chessBoardElem, {
            'window': window,
            'boardDimensions': getBoardDimensions(),
            'playerColor': getPlayerColorVariable(),
            'zIndex': 500,
            'prepend': true,
            'debugMode': debugModeActivated,
            'adjustSizeByDimensions': adjustSizeByDimensions ? true : false,
            'adjustSizeConfig': {
                'noLeftAdjustment': true
            }
        });
    }

    await updatePlayerColor();

    observeNewMoves();

    CommLink.setIntervalAsync(async () => {
        await CommLink.commands.createInstance(commLinkInstanceID);
    }, 1000);
}

function startWhenBackendReady() {
    const interval = CommLink.setIntervalAsync(async () => {
        if(await isAcasBackendReady()) {
            start();

            interval.stop();
        } else {
            GM_openInTab(backendURL, true);

            if(await isAcasBackendReady()) {
                start();

                interval.stop();
            }
        }
    }, 1000);
}

function initializeIfSiteReady() {
    const boardElem = getBoardElem();
    const firstPieceElem = getChessPieceElem();

    const bothElemsExist = boardElem && firstPieceElem;
    const boardElemChanged = chessBoardElem != boardElem;

    if(bothElemsExist && boardElemChanged) {
        chessBoardElem = boardElem;

        if(!blacklistedURLs.includes(window.location.href)) {
            startWhenBackendReady();
        }
    }
}

if(typeof GM_registerMenuCommand == 'function') {
    GM_registerMenuCommand('Open A.C.A.S', e => {
        if(chessBoardElem) {
            startWhenBackendReady();
        }
    }, 's');
}

setInterval(initializeIfSiteReady, 1000);