// ==UserScript==
// @name         MZ - Training History
// @namespace    douglaskampl
// @version      4.2
// @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'];

    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 processTrainingHistory(series, getSeasonFn) {
        const bySeason = {};
        const skillTotals = {};
        const chips = extractChipsInfo(series);
        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 };
    }

    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, 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 potentialClass = '';
            let potentialIcon = '';

            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 ${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 } = 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,
                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">Season' + 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();
})();