// ==UserScript==
// @name         MZ - Training History
// @namespace    douglaskampl
// @version      4.1
// @description  Displays skill gains across MZ seasons
// @author       Douglas
// @match        https://www.managerzone.com/?p=players
// @match        https://www.managerzone.com/?p=players&pid=*
// @match        https://www.managerzone.com/?p=players&tid=*
// @match        https://www.managerzone.com/?p=transfer*
// @exclude      https://www.managerzone.com/?p=transfer_history*
// @icon         https://www.google.com/s2/favicons?sz=64&domain=managerzone.com
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_addStyle
// @grant        GM_getResourceText
// @require      https://cdnjs.cloudflare.com/ajax/libs/spin.js/2.3.2/spin.min.js
// @resource     trainingHistoryStyles https://u18mz.vercel.app/mz/userscript/other/trainingHistory_v4.css
// @run-at       document-idle
// @license      MIT
// @downloadURL none
// ==/UserScript==

(function () {
    'use strict';

    GM_addStyle(GM_getResourceText('trainingHistoryStyles'));

    const SKILL_MAP = {
        '1': 'Speed',
        '2': 'Stamina',
        '3': 'Play Intelligence',
        '4': 'Passing',
        '5': 'Shooting',
        '6': 'Heading',
        '7': 'Keeping',
        '8': 'Ball Control',
        '9': 'Tackling',
        '10': 'Aerial Passing',
        '11': 'Set Plays'
    };
    const ORDERED_SKILLS = ['Speed', 'Stamina', 'Play Intelligence', 'Passing', 'Shooting', 'Heading', 'Keeping', 'Ball Control', 'Tackling', 'Aerial Passing', 'Set Plays'];
    const MAXED_KEYWORDS = [
        'maximizado', 'maxed', 'max', 'max.', 'maks.', 'maksymalny', 'maksimum', 'maximum', 'maxad',
        'máximo', 'maxeado', 'maximal', 'maksimal', 'maksimalt', 'maximerad', 'maksimoi', 'maksimums',
        'maksimalus', 'maximális', 'massimo', 'maxat', 'максимум', 'μέγιστο', '最大', '최대', 'अधिकतम',
        'maksimalan', 'maxim', 'максимален', 'maksimaalne', 'máx.', 'maxed out', 'fullt utvecklad',
        'täysin kehittynyt', 'полностью развит', 'completamente desarrollado', 'voll entwickelt',
        'zablokowany', 'tam gelişmiş', 'gelişim tamamlandı', 'maximised', 'maximized', 'Tıkalı',
        '已达上限', '已满', '만렙', 'limite tercapai', 'đã đạt tối đa', 'הגיע למקסימום', 'وصل للحد الأقصى',
        'สุดขีด', 'rozvoj dokončen', 'maxat', 'maxad', 'maxat.', 'maxad.', 'maksimert', 'maximert',
        'maksimoitu', 'täynnä', 'pilnībā attīstīts', 'maksimaliai išvystytas', 'maxim dezvoltat',
        'tope', 'limite', 'τελείωσε', 'ביותר', 'gemaxt',
    ];

    let myTeamId = null;

    function isClubMember() {
        const headerUsernameStyle = document.querySelector('#header-username')?.getAttribute('style');
        return headerUsernameStyle && headerUsernameStyle.includes('background-image');
    }

    function getCurrentSeasonInfo() {
        const w = document.querySelector('#header-stats-wrapper');
        if (!w) return null;
        const dn = w.querySelector('h5.flex-grow-1.textCenter:not(.linked)');
        const ln = w.querySelector('h5.flex-grow-1.textCenter.linked');
        if (!dn || !ln) return null;
        const dm = dn.textContent.match(/(\d{1,2})[/-](\d{1,2})[/-](\d{4})/);
        if (!dm) return null;
        const d = dm[1];
        const m = dm[2];
        const y = dm[3];
        const currentDate = new Date([m, d, y].join('/'));
        const digits = ln.textContent.match(/\d+/g);
        if (!digits || digits.length < 3) return null;
        const season = parseInt(digits[0], 10);
        const day = parseInt(digits[2], 10);
        return { currentDate, season, day };
    }

    function getSeasonCalculator(cs) {
        if (!cs) return () => 0;
        const baseSeason = cs.season;
        const baseDate = cs.currentDate;
        const dayOffset = cs.day;
        const seasonStart = new Date(baseDate);
        seasonStart.setDate(seasonStart.getDate() - (dayOffset - 1));
        return d => {
            if (!(d instanceof Date)) return 0;
            let s = baseSeason;
            let ref = seasonStart.getTime();
            let diff = Math.floor((d.getTime() - ref) / 86400000);
            while (diff < 0) {
                s--;
                diff += 91;
            }
            while (diff >= 91) {
                s++;
                diff -= 91;
            }
            return s;
        };
    }

    function getPlayerContainerNode(n) {
        let c = n.closest('.playerContainer');
        if (!c) c = document.querySelector('.playerContainer');
        return c;
    }

    function parseSeriesData(txt) {
        const m = txt.match(/var series = (\[.*?\]);/);
        return m ? JSON.parse(m[1]) : null;
    }

    function extractChipsInfo(series) {
        const chips = [];
        if (!series) return chips;
        series.forEach(s => {
            s.data.forEach(pt => {
                if (pt.marker?.symbol.includes('training_camp_chip.png') && pt.name) {
                    const chipName = pt.name.replace(/<\/b>\t\t\t\n/g, ' ').trim();
                    const date = new Date(pt.x);
                    chips.push({
                        name: chipName,
                        date: date,
                        dateString: date.toLocaleDateString()
                    });
                }
            });
        });
        return chips;
    }

    function extractMaxingInfo(series, getSeasonFn) {
        const maxedSkills = {};
        if (!series) return maxedSkills;

        const maxedKeywordsLower = MAXED_KEYWORDS.map(k => k.toLowerCase());

        series.forEach(s => {
            s.data.forEach(pt => {
                if (pt.name && typeof pt.name === 'string') {
                    const nameLower = pt.name.toLowerCase();
                    if (maxedKeywordsLower.some(keyword => nameLower.includes(keyword))) {
                        const skillId = pt.y?.toString();
                        const skillName = SKILL_MAP[skillId];
                        if (skillName) {
                            const date = new Date(pt.x);
                            const season = getSeasonFn(date);
                            if (!maxedSkills[skillName] || season < maxedSkills[skillName]) {
                                maxedSkills[skillName] = season;
                            }
                        }
                    }
                }
            });
        });
        return maxedSkills;
    }

    function processTrainingHistory(series, getSeasonFn) {
        const bySeason = {};
        const skillTotals = {};
        const chips = extractChipsInfo(series);
        const maxedSkills = extractMaxingInfo(series, getSeasonFn);
        const chipsBySeason = {};

        let total = 0;
        let earliest = 9999;

        chips.forEach(chip => {
            const season = getSeasonFn(chip.date);
            if (!chipsBySeason[season]) chipsBySeason[season] = [];
            chipsBySeason[season].push(chip);
        });

        if (series) {
            series.forEach(s => {
                s.data.forEach((pt, i) => {
                    if (pt.marker?.symbol.includes('gained_skill.png') && s.data[i + 1]) {
                        const d = new Date(s.data[i + 1].x);
                        const sea = getSeasonFn(d);
                        if (!bySeason[sea]) bySeason[sea] = [];
                        const sid = s.data[i + 1].y.toString();
                        const sk = SKILL_MAP[sid] || 'Unknown';
                        bySeason[sea].push({ dateString: d.toLocaleDateString(), skillName: sk });
                        if (!skillTotals[sk]) skillTotals[sk] = 0;
                        skillTotals[sk]++;
                        total++;
                        if (sea < earliest) earliest = sea;
                    }
                });
            });
        }

        return { bySeason, skillTotals, total, earliestSeason: earliest, chips, chipsBySeason, maxedSkills };
    }

    function createModal(content, spin) {
        const ov = document.createElement('div');
        ov.className = 'mz-training-overlay';
        const mo = document.createElement('div');
        mo.className = 'mz-training-modal';
        const bd = document.createElement('div');
        bd.className = 'mz-training-modal-content';
        const sp = document.createElement('div');
        sp.style.height = '60px';
        sp.style.display = spin ? 'block' : 'none';
        bd.appendChild(sp);
        if (content) bd.innerHTML += content;
        const cl = document.createElement('div');
        cl.className = 'mz-training-modal-close';
        cl.innerHTML = '×';
        cl.onclick = () => ov.remove();
        mo.appendChild(cl);
        mo.appendChild(bd);
        ov.appendChild(mo);
        document.body.appendChild(ov);
        ov.addEventListener('click', e => {
            if (e.target === ov) ov.remove();
        });
        requestAnimationFrame(() => {
            ov.classList.add('show');
            mo.classList.add('show');
        });
        let spinnerInstance = null;
        if (spin) {
            spinnerInstance = new Spinner({ color: '#5555aa', lines: 12 });
            spinnerInstance.spin(sp);
        }
        return { modal: mo, spinnerEl: sp, spinnerInstance, overlay: ov };
    }

    function gatherCurrentSkills(container) {
        const rows = container.querySelectorAll('table.player_skills tr');
        const out = {};
        let i = 1;
        rows.forEach(r => {
            const valCell = r.querySelector('.skillval span');
            if (!valCell) return;
            const name = SKILL_MAP[i.toString()];
            if (name) {
                const v = parseInt(valCell.textContent.trim(), 10);
                out[name] = isNaN(v) ? 0 : v;
            }
            i++;
        });
        return out;
    }

    function getTotalBallsFromSkillMap(map) {
        return Object.values(map).reduce((a, b) => a + b, 0);
    }

    function fillSeasonGains(bySeason, earliestSeason, currentSeason, skillTotals) {
        const out = {};
        for (let s = earliestSeason; s <= currentSeason; s++) {
            out[s] = {};
            ORDERED_SKILLS.forEach(sk => { out[s][sk] = 0; });
            if (bySeason[s]) {
                bySeason[s].forEach(ev => {
                    if (skillTotals[ev.skillName]) {
                        if (!out[s][ev.skillName]) out[s][ev.skillName] = 0;
                        out[s][ev.skillName]++;
                    }
                });
            }
        }
        return out;
    }

    function parsePlayerAge(container) {
        const strongEls = container.querySelectorAll('strong');
        for (const el of strongEls) {
            const numberMatch = el.textContent.trim().match(/^(\d{1,2})$/);
            if (numberMatch) {
                const age = parseInt(numberMatch[1], 10);
                if (age >= 15 && age <= 45) return age;
            }
        }
        const allNums = container.textContent.match(/\b(\d{1,2})\b/g);
        if (allNums) {
            for (const numString of allNums) {
                const age = parseInt(numString, 10);
                if (age >= 15 && age <= 45) return age;
            }
        }
        return null;
    }

    function calculateHistoricalAge(params) {
        const { currentAge, currentSeason, targetSeason } = params;
        if (!currentAge) return null;
        const seasonDiff = currentSeason - targetSeason;
        return currentAge - seasonDiff;
    }

    function buildSeasonCheckpointData(earliestSeason, currentSeason, finalMap, seasonGains, container) {
        const out = [];
        const currentMap = {};
        const currentAge = parsePlayerAge(container);

        ORDERED_SKILLS.forEach(sk => {
            currentMap[sk] = finalMap[sk] || 0;
        });

        out.push({
            season: currentSeason,
            label: 'Current',
            distribution: { ...finalMap }
        });

        for (let s = currentSeason; s >= earliestSeason; s--) {
            if (seasonGains[s]) {
                Object.keys(seasonGains[s]).forEach(k => {
                    if (currentMap.hasOwnProperty(k)) {
                        currentMap[k] -= seasonGains[s][k];
                        if (currentMap[k] < 0) currentMap[k] = 0;
                    }
                });
            }

            const age = calculateHistoricalAge({ currentAge, currentSeason, targetSeason: s });
            const label = age !== null ? `${s} (${age})` : s.toString();
            const snapshot = { ...currentMap };

            out.unshift({ season: s, label, distribution: snapshot });
        }

        return out;
    }


    function makeSkillRows(params) {
        const { map, prevMap, arrivalMap, maxedSkills, currentSeasonForState, isCurrentState, scoutData } = params;
        let comparisonHtml = '';
        let arrivalGainHtml = '';
        let totalIncreaseFromPrev = 0;
        let totalGainSinceArrival = 0;

        ORDERED_SKILLS.forEach(k => {
            let v = map[k] || 0;
            if (v < 0) v = 0;
            if (v > 10) v = 10;

            let changeHTML = '';
            let gainSinceArrivalHTML = '';
            let maxedClass = '';
            let potentialClass = '';
            let potentialIcon = '';

            if (maxedSkills && maxedSkills[k] && currentSeasonForState >= maxedSkills[k]) {
                maxedClass = 'mz-skill-maxed';
            }

            if (scoutData) {
                if (k === scoutData.firstHpSkill || k === scoutData.secondHpSkill) {
                    potentialClass = `mz-skill-potential-hp${scoutData.hp}`;
                    potentialIcon = `<i class="fas fa-star mz-potential-icon mz-potential-icon-hp${scoutData.hp}"></i>`;
                } else if (k === scoutData.firstLpSkill || k === scoutData.secondLpSkill) {
                    potentialClass = `mz-skill-potential-lp${scoutData.lp}`;
                    potentialIcon = `<i class="fas fa-star mz-potential-icon mz-potential-icon-lp${scoutData.lp}"></i>`;
                }
            }

            if (prevMap) {
                const prevVal = prevMap[k] || 0;
                const change = v - prevVal;
                if (change > 0) {
                    changeHTML = `<span class="mz-skill-increase">(+${change})</span>`;
                    totalIncreaseFromPrev += change;
                }
            }

            if (arrivalMap) {
                const arrivalVal = arrivalMap[k] || 0;
                const gainSinceArrival = v - arrivalVal;
                if (gainSinceArrival > 0) {
                    gainSinceArrivalHTML = `<span class="mz-gain-since-arrival">(+${gainSinceArrival})</span>`;
                    totalGainSinceArrival += gainSinceArrival;
                }
            }

            const baseSkillRowHtml = `
            <div class="mz-state-skill ${maxedClass} ${potentialClass}">
                <div class="mz-skill-name">${potentialIcon}<strong>${k}</strong></div>
                <div class="mz-skill-val">
                    <img src="nocache-922/img/soccer/wlevel_${v}.gif" alt="">
                    (${v})
                </div>`;

            comparisonHtml += `${baseSkillRowHtml}
                <div class="mz-skill-change">${changeHTML}</div>
            </div>`;

            if (arrivalMap && isCurrentState) {
                arrivalGainHtml += `${baseSkillRowHtml}
                     <div class="mz-skill-change">${gainSinceArrivalHTML}</div>
                 </div>`;
            }
        });

        return { comparisonHtml, arrivalGainHtml, totalIncrease: totalIncreaseFromPrev, totalGainSinceArrival };
    }

    function buildStatesLayout(processedData, container, currentSeason, scoutData, transferData) {
        const { bySeason, skillTotals, earliestSeason, chipsBySeason, maxedSkills } = processedData;
        const finalMap = gatherCurrentSkills(container);
        const seasonGains = fillSeasonGains(bySeason, earliestSeason, currentSeason, skillTotals);
        const arr = buildSeasonCheckpointData(earliestSeason, currentSeason, finalMap, seasonGains, container);
        const arrivalMap = arr.length > 0 ? arr[0].distribution : null;

        let paginatedHtml = '<div class="mz-state-wrapper mz-paginated-view">';
        let allViewHtml = '<div class="mz-state-wrapper mz-all-view" style="display:none;">';

        const currentAge = parsePlayerAge(container);

        arr.forEach((o, index) => {
            const sum = getTotalBallsFromSkillMap(o.distribution);
            let headerText;
            const isCurrent = o.label === 'Current';
            const seasonNumber = isCurrent ? currentSeason : parseInt(o.label.split(' ')[0], 10);
            let stateSkillsHtml = '';

            const prevDistribution = index > 0 ? arr[index - 1].distribution : null;
            const useArrivalMapForComparison = isCurrent ? arrivalMap : null;

            const skillRowsResult = makeSkillRows({
                map: o.distribution,
                prevMap: prevDistribution,
                arrivalMap: useArrivalMapForComparison,
                maxedSkills: maxedSkills,
                currentSeasonForState: seasonNumber,
                isCurrentState: isCurrent,
                scoutData: scoutData
            });

            if (isCurrent) {
                headerText = `Current State - Season ${currentSeason}`;
                if (currentAge !== null) headerText += ` (Age: ${currentAge})`;
                stateSkillsHtml = `
                    <div class="mz-state-skills">
                        <h5>Changes vs Start of Season ${currentSeason}</h5>
                        ${skillRowsResult.comparisonHtml}
                        ${skillRowsResult.totalIncrease > 0 ? `<div class="mz-skill-total-increase"><span>(+${skillRowsResult.totalIncrease} total this season)</span></div>` : ''}
                    </div>
                    <div class="mz-state-skills mz-arrival-gains">
                        <h5>Gains Since Arrival (Season ${arr[0]?.season || '?'})</h5>
                        ${skillRowsResult.arrivalGainHtml}
                        ${skillRowsResult.totalGainSinceArrival > 0 ? `<div class="mz-skill-total-increase"><span>(+${skillRowsResult.totalGainSinceArrival} total since arrival)</span></div>` : ''}
                    </div>
                `;
            } else {
                const [seasonStr, ageStr] = o.label.split(' ');
                const agePart = ageStr ? ageStr.replace(/[()]/g, '') : '?';
                if (index === 0) {
                    headerText = `Arrival at Club - Start of Season ${seasonStr}`;
                    if (agePart !== '?') headerText += ` (Age: ${agePart})`;
                } else {
                    headerText = `Start of Season ${seasonStr}`;
                    if (agePart !== '?') headerText += ` (Age: ${agePart})`;
                }
                stateSkillsHtml = `
                     <div class="mz-state-skills">
                        ${index > 0 ? `<h5>Changes vs Start of Season ${arr[index - 1]?.season}</h5>` : ''}
                         ${skillRowsResult.comparisonHtml}
                         ${skillRowsResult.totalIncrease > 0 ? `<div class="mz-skill-total-increase"><span>(+${skillRowsResult.totalIncrease} total vs prev)</span></div>` : ''}
                     </div>
                 `;
            }

            let chipInfo = '';
            if (chipsBySeason[seasonNumber] && chipsBySeason[seasonNumber].length > 0 && !isCurrent) {
                const chipNames = chipsBySeason[seasonNumber].map(c => {
                    const simplifiedName = c.name.split('</b>')[1]?.trim() || c.name;
                    return simplifiedName;
                }).join(', ');
                chipInfo = `<div class="mz-chips-list">Chips used during S${seasonNumber}: ${chipNames}</div>`;
            }

            let transferInfo = '';
            if (transferData && transferData[seasonNumber] && transferData[seasonNumber].length > 0 && !isCurrent) {
                transferInfo = '<div class="mz-transfer-info">Transfers during S' + seasonNumber + ':<ul>';
                transferData[seasonNumber].forEach(t => {
                    transferInfo += `<li>${t.dateString}: ${t.fromTeamName} <i class="fa fa-arrow-right"></i> ${t.toTeamName} (${t.price || 'N/A'})</li>`;
                });
                transferInfo += '</ul></div>';
            }

            const colHtml = `<div class="mz-state-col" data-page="${index}" data-season="${seasonNumber}">
                    <h4>${headerText}</h4>
                    <div class="mz-state-info">Total Balls: <strong>${sum}</strong></div>
                    ${stateSkillsHtml}
                    ${chipInfo}
                    ${transferInfo}
                 </div>`;

            paginatedHtml += colHtml;
            allViewHtml += colHtml;
        });

        paginatedHtml += '</div>';
        allViewHtml += '</div>';

        let scoutHtml = '';
        if (scoutData) {
            const { trainingSpeed, hp, lp, firstHpSkill, secondHpSkill, firstLpSkill, secondLpSkill } = scoutData;
            const speedClass = `mz-speed-s${trainingSpeed}`;
            const hpClass = `mz-hp-h${hp}`;
            const lpClass = `mz-lp-l${lp}`;

            const speedText = trainingSpeed > 0 ? `S${trainingSpeed}` : 'N/A';
            const hpText = hp > 0 ? `HP${hp}` : 'N/A';
            const lpText = lp > 0 ? `LP${lp}` : 'N/A';

            let hpSkillsText = '';
            if (firstHpSkill) {
                hpSkillsText += `<span class="mz-potential-skill mz-skill-potential-hp${hp}">${firstHpSkill}</span>`;
                if (secondHpSkill) hpSkillsText += `, <span class="mz-potential-skill mz-skill-potential-hp${hp}">${secondHpSkill}</span>`;
            }
            hpSkillsText = hpSkillsText ? `(${hpSkillsText})` : '';

            let lpSkillsText = '';
            if (firstLpSkill) {
                lpSkillsText += `<span class="mz-potential-skill mz-skill-potential-lp${lp}">${firstLpSkill}</span>`;
                if (secondLpSkill) lpSkillsText += `, <span class="mz-potential-skill mz-skill-potential-lp${lp}">${secondLpSkill}</span>`;
            }
            lpSkillsText = lpSkillsText ? `(${lpSkillsText})` : '';

            scoutHtml = `
            <div class="mz-scout-info">
            <span class="${speedClass}">TrainingSpeed: ${speedText}</span> |
            <span class="${hpClass}">${hpText}</span>${hpSkillsText} |
            <span class="${lpClass}">${lpText}</span>${lpSkillsText}
            </div>`;
        }

        return scoutHtml + paginatedHtml + allViewHtml;
    }

    function generateEvolHTML(processedData, container, currentSeason) {
        const { bySeason, total, skillTotals, chips, chipsBySeason, earliestSeason } = processedData;
        let html = '';
        const currentAge = parsePlayerAge(container);
        const getSeason = getSeasonCalculator({ currentDate: new Date(), season: currentSeason, day: 1 });

        const sortedSeasons = Object.keys(bySeason)
        .map(x => parseInt(x, 10))
        .sort((a, b) => a - b);

        sortedSeasons.forEach(se => {
            const items = bySeason[se];
            const age = calculateHistoricalAge({ currentAge, currentSeason, targetSeason: se });
            const label = age !== null ? `Season ${se} (Age ${age})` : `Season ${se}`;

            let seasonChipsHtml = '';
            if (chipsBySeason[se] && chipsBySeason[se].length > 0) {
                seasonChipsHtml = '<div class="mz-chips-list">Chips: ';
                seasonChipsHtml += chipsBySeason[se].map(chip => {
                    const simplifiedName = chip.name.split('</b>')[1]?.trim() || chip.name;
                    return `${simplifiedName} (${chip.dateString})`;
                }).join(', ');
                seasonChipsHtml += '</div>';
            }

            html += `<div class="mz-training-season">
                <h3>${label} — ${items.length} Ball${items.length !== 1 ? 's' : ''} Earned</h3>
                ${seasonChipsHtml}
                <ul>`;
            items.forEach(it => {
                html += `<li><strong>${it.dateString}</strong> ${it.skillName}</li>`;
            });
            html += '</ul></div>';
        });

        html += `<hr><h3 class="mz-training-final-summary">Total balls earned: ${total}</h3>`;
        const fs = Object.entries(skillTotals)
        .filter(([, count]) => count > 0)
        .sort(([, countA], [, countB]) => countB - countA)
        .map(([skill, count]) => `${skill} (${count})`)
        .join(', ');
        html += `<h3 class="mz-training-skilltotals">${fs}</h3>`;

        const allChipsSorted = [...chips].sort((a, b) => a.date - b.date);
        if (allChipsSorted.length > 0) {
            html += `<h3 class="mz-training-final-summary">All Applied Chips</h3><ul class="mz-all-chips-list">`;
            allChipsSorted.forEach(chip => {
                const simplifiedName = chip.name.split('</b>')[1]?.trim() || chip.name;
                const chipSeason = getSeason(chip.date);
                html += `<li>S${chipSeason}: ${simplifiedName} (${chip.dateString})</li>`;
            });
            html += `</ul>`;
        }

        return html;
    }

    function generateTabsHTML(name, evo, st) {
        return `
        <h2 class="mz-training-title">${name}</h2>
        <div class="mz-training-tabs">
            <div class="mz-training-tab-row">
                <div class="mz-training-tab-buttons">
                    <button class="mz-training-tab-btn active" data-tab="states">Player Development</button>
                    <button class="mz-training-tab-btn" data-tab="evolution">Gains Log</button>
                </div>
                <div class="mz-pagination-controls">
                    <button class="mz-pagination-btn mz-prev-btn" disabled>←</button>
                    <span class="mz-pagination-indicator">1 / 1</span>
                    <button class="mz-pagination-btn mz-next-btn" disabled>→</button>
                    <button class="mz-pagination-toggle">Show All</button>
                </div>
            </div>
            <div class="mz-training-tab-content" data-content="evolution">${evo}</div>
            <div class="mz-training-tab-content active" data-content="states">${st}</div>
        </div>`;
    }

    function attachTabEvents(modal) {
        const tbs = modal.querySelectorAll('.mz-training-tab-btn');
        const cs = modal.querySelectorAll('.mz-training-tab-content');
        const paginationControls = modal.querySelector('.mz-pagination-controls');
        const statesContent = modal.querySelector('.mz-training-tab-content[data-content="states"]');

        if (!statesContent || !paginationControls) return;

        const updatePaginationVisibility = () => {
            const activeTab = modal.querySelector('.mz-training-tab-btn.active')?.getAttribute('data-tab');
            paginationControls.style.display = (activeTab === 'states') ? '' : 'none';
        };

        updatePaginationVisibility();

        tbs.forEach(btn => {
            btn.addEventListener('click', () => {
                tbs.forEach(x => x.classList.remove('active'));
                btn.classList.add('active');
                const t = btn.getAttribute('data-tab');

                cs.forEach(cc => {
                    cc.classList.toggle('active', cc.getAttribute('data-content') === t);
                });
                updatePaginationVisibility();
                if (t === 'states') {
                    initPaginationState(modal);
                }
            });
        });
    }


    async function fetchScoutData(pid) {
        try {
            const response = await fetch(`https://www.managerzone.com/ajax.php?p=players&sub=scout_report&pid=${pid}&sport=soccer`);
            if (!response.ok) throw new Error(`HTTP error ${response.status}`);
            const text = await response.text();

            const doc = new DOMParser().parseFromString(text, 'text/html');

            const defaultResult = { trainingSpeed: 0, hp: 0, lp: 0, firstHpSkill: '', secondHpSkill: '', firstLpSkill: '', secondLpSkill: '' };

            const paperContent = doc.querySelector('.paper-content');
            if (!paperContent) {

                return defaultResult;
            }

            const dlElement = paperContent.querySelector('dl');
            if (!dlElement) {

                return defaultResult;
            }

            const hpDd = dlElement.querySelector('dd i.fa-line-chart')?.closest('dd');
            const lpDd = dlElement.querySelector('dd i.fa-exclamation-triangle')?.closest('dd');
            const speedDd = dlElement.querySelector('dd i.fa-heartbeat')?.closest('dd');

            const getSkills = (dd) => {
                if (!dd) return [];
                return Array.from(dd.querySelectorAll('ul li.blurred span:last-child')).map(span => span.textContent.trim());
            };

            const getStars = (dd) =>
            dd ? dd.querySelectorAll('.stars i.fa-star.lit').length : 0;

            const hpSkills = getSkills(hpDd);
            const lpSkills = getSkills(lpDd);
            const hpStars = getStars(hpDd);
            const lpStars = getStars(lpDd);
            const speedStars = getStars(speedDd);

            return {
                hp: hpStars,
                lp: lpStars,
                trainingSpeed: speedStars,
                firstHpSkill: hpSkills[0] || '',
                secondHpSkill: hpSkills[1] || '',
                firstLpSkill: lpSkills[0] || '',
                secondLpSkill: lpSkills[1] || ''
            };
        } catch (error) {
            console.error("Failed to fetch or parse scout data:", error);
            return null;
        }
    }


    async function fetchTransferData(pid, getSeasonFn) {
        try {
            const response = await fetch(`https://www.managerzone.com/?p=players&pid=${pid}`);
            if (!response.ok) throw new Error(`HTTP error ${response.status}`);
            const text = await response.text();
            const doc = new DOMParser().parseFromString(text, 'text/html');
            const transferTable = doc.querySelector('table.hitlist');

            const transferDataHeader = transferTable?.querySelector('thead td strong');
            if (!transferTable || !transferDataHeader || !transferDataHeader.textContent.match(/Data|Date/i)) {

                return {};
            }

            const transfersBySeason = {};
            const rows = transferTable.querySelectorAll('tbody tr');

            rows.forEach(row => {
                const cells = row.querySelectorAll('td');
                if (cells.length < 5) return;

                const dateStrRaw = cells[0]?.textContent.trim();
                const actionOrFromTeamCell = cells[1];
                const toTeamCell = cells[3];
                const priceCell = cells[4];

                const dateMatch = dateStrRaw.match(/(\d{2})-(\d{2})-(\d{4})/);
                if (!dateMatch) return;

                const day = dateMatch[1];
                const month = dateMatch[2];
                const year = dateMatch[3];
                const transferDate = new Date(`${year}-${month}-${day}`);
                if (isNaN(transferDate)) return;

                const season = getSeasonFn(transferDate);

                const fromTeamLink = actionOrFromTeamCell.querySelector('a[href*="tid="]');
                const toTeamLink = toTeamCell.querySelector('a[href*="tid="]');

                let fromTeamName = 'Youth Academy';
                if (fromTeamLink) {
                    fromTeamName = fromTeamLink.textContent.trim();
                } else if (actionOrFromTeamCell.textContent.trim() !== '-') {
                    fromTeamName = actionOrFromTeamCell.textContent.trim();
                }


                const toTeamName = toTeamLink ? toTeamLink.textContent.trim() : toTeamCell.textContent.trim();

                const priceDiv = priceCell?.querySelector('div[title]');
                let price = priceDiv?.title || priceCell?.textContent.trim() || 'N/A';
                if (price === '-') price = 'N/A';


                if (!transfersBySeason[season]) {
                    transfersBySeason[season] = [];
                }

                transfersBySeason[season].push({
                    date: transferDate,
                    dateString: transferDate.toLocaleDateString(),
                    fromTeamName: fromTeamName,
                    toTeamName: toTeamName,
                    price: price
                });
            });

            Object.values(transfersBySeason).forEach(seasonTransfers => {
                seasonTransfers.sort((a, b) => a.date - b.date);
            });

            return transfersBySeason;
        } catch (error) {
            console.error("Failed to fetch or parse transfer data:", error);
            return {};
        }
    }

    async function fetchCombinedPlayerData(pid, node, getSeasonFn, csi) {
        const cont = getPlayerContainerNode(node);
        if (!cont) return;

        const curSeason = csi.season;
        const nmEl = cont.querySelector('.player_name');
        const nm = nmEl ? nmEl.textContent.trim() : 'Unknown Player';
        const { modal, spinnerEl, spinnerInstance } = createModal('', true);

        try {
            const [trainingResponse, scoutData, transferData] = await Promise.all([
                fetch(`https://www.managerzone.com/ajax.php?p=trainingGraph&sub=getJsonTrainingHistory&sport=soccer&player_id=${pid}`).then(res => res.ok ? res.text() : Promise.reject(`HTTP error ${res.status} for training data`)),
                fetchScoutData(pid),
                fetchTransferData(pid, getSeasonFn)
            ]);

            if (spinnerInstance) spinnerInstance.stop();
            spinnerEl.style.display = 'none';

            const series = parseSeriesData(trainingResponse);

            const processedTrainingData = processTrainingHistory(series, getSeasonFn);

            const transferSeasons = Object.keys(transferData).map(s => parseInt(s)).filter(s => !isNaN(s));
            let effectiveEarliestSeason = processedTrainingData.earliestSeason;

            if (transferSeasons.length > 0) {
                const earliestTransferSeason = Math.min(...transferSeasons);
                effectiveEarliestSeason = Math.max(1, Math.min(effectiveEarliestSeason, earliestTransferSeason));
            }

            if (effectiveEarliestSeason === 9999) {
                if (transferSeasons.length > 0) {
                    effectiveEarliestSeason = Math.max(1, Math.min(...transferSeasons));
                } else {
                    effectiveEarliestSeason = curSeason;
                }
            }
            processedTrainingData.earliestSeason = effectiveEarliestSeason;

            const evoHTML = generateEvolHTML(processedTrainingData, cont, curSeason);
            const stHTML = buildStatesLayout(processedTrainingData, cont, curSeason, scoutData, transferData);
            const finalHTML = generateTabsHTML(nm, evoHTML, stHTML);
            modal.querySelector('.mz-training-modal-content').innerHTML = finalHTML;

            setTimeout(() => {
                attachTabEvents(modal);
                initPaginationState(modal);
            }, 50);

        } catch (error) {
            console.error("Error fetching combined player data:", error);
            if (spinnerInstance) spinnerInstance.stop();
            if(spinnerEl) spinnerEl.style.display = 'none';
            const contentDiv = modal.querySelector('.mz-training-modal-content');
            if (contentDiv) {
                contentDiv.innerHTML = `<p>Failed to process player data. (${error.message || 'Unknown error'})</p><p>(Are you a club member? Is the player still active? Check console for details.)</p>`;
            }
        }
    }

    function initPaginationState(modal) {
        const statesContent = modal.querySelector('.mz-training-tab-content[data-content="states"]');
        if (!statesContent) return;

        const paginatedView = statesContent.querySelector('.mz-paginated-view');
        const allView = statesContent.querySelector('.mz-all-view');
        const paginationToggle = modal.querySelector('.mz-pagination-toggle');
        const paginationControls = modal.querySelector('.mz-pagination-controls');


        if (!paginatedView || !allView || !paginationToggle || !paginationControls) {
            if (paginationControls) paginationControls.style.display = 'none';
            return;
        }

        const stateColumns = paginatedView.querySelectorAll('.mz-state-col');

        if (!stateColumns.length) {
            if (paginationControls) paginationControls.style.display = 'none';
            return;
        } else {
            paginationControls.style.display = '';
        }

        paginatedView.style.display = '';
        allView.style.display = 'none';
        paginationToggle.textContent = 'Show All';

        let initialIndex = 0;

        stateColumns.forEach((col, index) => {
            col.style.display = index === initialIndex ? '' : 'none';
        });

        const paginationIndicator = modal.querySelector('.mz-pagination-indicator');
        const prevBtn = modal.querySelector('.mz-prev-btn');
        const nextBtn = modal.querySelector('.mz-next-btn');

        if (paginationIndicator) {
            paginationIndicator.textContent = `${initialIndex + 1} / ${stateColumns.length}`;
        }

        if (prevBtn) prevBtn.disabled = initialIndex === 0;
        if (nextBtn) nextBtn.disabled = initialIndex >= stateColumns.length - 1;

        detachPaginationEvents(modal);
        attachPaginationEvents(modal, initialIndex);
    }


    function detachPaginationEvents(modal) {
        const prevBtn = modal.querySelector('.mz-prev-btn');
        const nextBtn = modal.querySelector('.mz-next-btn');
        const toggleBtn = modal.querySelector('.mz-pagination-toggle');

        if (prevBtn) {
            const newPrevBtn = prevBtn.cloneNode(true);
            prevBtn.parentNode.replaceChild(newPrevBtn, prevBtn);
        }
        if (nextBtn) {
            const newNextBtn = nextBtn.cloneNode(true);
            nextBtn.parentNode.replaceChild(newNextBtn, nextBtn);
        }
        if (toggleBtn) {
            const newToggleBtn = toggleBtn.cloneNode(true);
            toggleBtn.parentNode.replaceChild(newToggleBtn, toggleBtn);
        }
    }

    function attachPaginationEvents(modal, initialIndex) {
        const statesContent = modal.querySelector('.mz-training-tab-content[data-content="states"]');
        if (!statesContent) return;

        const prevBtn = modal.querySelector('.mz-prev-btn');
        const nextBtn = modal.querySelector('.mz-next-btn');
        const paginationIndicator = modal.querySelector('.mz-pagination-indicator');
        const toggleBtn = modal.querySelector('.mz-pagination-toggle');
        const paginatedView = statesContent.querySelector('.mz-paginated-view');
        const allView = statesContent.querySelector('.mz-all-view');

        if (!paginatedView || !allView || !prevBtn || !nextBtn || !paginationIndicator || !toggleBtn) return;

        const stateColumns = Array.from(paginatedView.querySelectorAll('.mz-state-col'));
        const totalPages = stateColumns.length;
        let currentIndex = initialIndex;

        function updatePaginationUI() {
            if (totalPages === 0) {
                prevBtn.disabled = true;
                nextBtn.disabled = true;
                paginationIndicator.textContent = '0 / 0';
                toggleBtn.style.display = 'none';
                return;
            }
            toggleBtn.style.display = '';
            prevBtn.disabled = currentIndex === 0;
            nextBtn.disabled = currentIndex === totalPages - 1;
            paginationIndicator.textContent = `${currentIndex + 1} / ${totalPages}`;

            stateColumns.forEach((col, index) => {
                col.style.display = index === currentIndex ? '' : 'none';
            });
        }

        prevBtn.addEventListener('click', () => {
            if (paginatedView.style.display === 'none') return;
            if (currentIndex > 0) {
                currentIndex--;
                updatePaginationUI();
            }
        });

        nextBtn.addEventListener('click', () => {
            if (paginatedView.style.display === 'none') return;
            if (currentIndex < totalPages - 1) {
                currentIndex++;
                updatePaginationUI();
            }
        });

        toggleBtn.addEventListener('click', () => {
            const isPaginated = paginatedView.style.display !== 'none';

            paginatedView.style.display = isPaginated ? 'none' : '';
            allView.style.display = isPaginated ? '' : 'none';
            toggleBtn.textContent = isPaginated ? 'Show Paginated' : 'Show All';

            prevBtn.disabled = !isPaginated || currentIndex === 0;
            nextBtn.disabled = !isPaginated || currentIndex === totalPages - 1;

            if (!isPaginated) {
                updatePaginationUI();
            }
        });

        updatePaginationUI();
    }


    function hasVisibleSkills(container) {
        return container.querySelector('table.player_skills') !== null;
    }

    function insertButtons(getSeasonFn, csi) {
        const containers = document.querySelectorAll('.playerContainer');
        containers.forEach(cc => {
            if (!hasVisibleSkills(cc)) return;

            const age = parsePlayerAge(cc);

            const f = cc.querySelectorAll('.floatRight[id^="player_id_"]');
            f.forEach(ff => {
                const pidSpan = ff.querySelector('.player_id_span');
                if (!pidSpan) return;
                const pid = pidSpan.textContent.trim();
                if (!pid) return;

                const existingBtn = ff.querySelector('.my-training-btn');
                if (existingBtn) return;

                const b = document.createElement('button');
                b.className = 'my-training-btn';
                b.innerHTML = '<i class="fa-solid fa-chart-line"></i>';
                b.title = 'View Training History & Details';
                b.onclick = (e) => {
                    e.preventDefault();
                    fetchCombinedPlayerData(pid, ff, getSeasonFn, csi);
                };
                ff.appendChild(b);
            });
        });
    }

    function initTeamId() {
        const stored = GM_getValue('TEAM_ID');
        if (stored) {
            myTeamId = stored;
            return;
        }
        const usernameEl = document.querySelector('#header-username');
        if (!usernameEl) return;
        const username = usernameEl.textContent.trim();
        if (!username) return;

        fetch(`https://www.managerzone.com/xml/manager_data.php?sport_id=1&username=${encodeURIComponent(username)}`)
            .then(response => {
            if (!response.ok) throw new Error(`HTTP error ${response.status}`);
            return response.text();
        })
            .then(text => {
            const parser = new DOMParser();
            const doc = parser.parseFromString(text, 'text/xml');
            const teamNodes = doc.querySelectorAll('Team[sport="soccer"]');
            if (!teamNodes || !teamNodes.length) return;
            const tid = teamNodes[0].getAttribute('teamId');
            if (tid) {
                GM_setValue('TEAM_ID', tid);
                myTeamId = tid;
            }
        })
            .catch((error) => {console.error("Failed to init team ID:", error)});
    }

    function canRunUserscript() {
        return isClubMember();
    }

    function go() {
        initTeamId();

        if (!canRunUserscript()) {
            console.log("MZ Training History: Not a club member, script disabled.");
            return;
        }

        const csi = getCurrentSeasonInfo();
        if (!csi) {
            console.error("MZ Training History: Could not determine current season info.");
            return;
        }

        const getSeasonFn = getSeasonCalculator(csi);
        insertButtons(getSeasonFn, csi);

        const obs = new MutationObserver((mutations) => {
            let playerContainerChanged = false;
            for (const mutation of mutations) {
                if (mutation.type === 'childList') {
                    if (mutation.target.matches && (mutation.target.matches('.playerContainer') || mutation.target.querySelector('.playerContainer'))) {
                        playerContainerChanged = true;
                        break;
                    }
                    for (const node of mutation.addedNodes) {
                        if (node.nodeType === 1 && (node.matches('.playerContainer') || node.querySelector('.playerContainer'))) {
                            playerContainerChanged = true;
                            break;
                        }
                    }
                    if (playerContainerChanged) break;
                }
            }

            if (playerContainerChanged) {
                insertButtons(getSeasonFn, csi);
            }
        });
        obs.observe(document.body, { childList: true, subtree: true });
    }

    go();
})();