import * as common from '/pages/src/common.mjs';

// --- ÉTAT GLOBAL (Persistance locale à vie) ---
// Tes sélections tactiques (Coureurs dangereux, teams assignées) sont sauvegardées pour toujours
let db = {
    teams: JSON.parse(localStorage.getItem('nicolastel_teams')) || ["Indépendant", "GHOST [A]"],
    markedTeams: JSON.parse(localStorage.getItem('nicolastel_marked_teams')) || [],
    markedRiders: JSON.parse(localStorage.getItem('nicolastel_marked_riders')) || [], 
    riderTeams: JSON.parse(localStorage.getItem('nicolastel_rider_teams')) || {}, 
    rules: JSON.parse(localStorage.getItem('nicolastel_rules')) || { scoreType: 'desc', topX: 4, totalRiders: 60 }
};

// --- MÉMOIRE VOLATILE ---
// S'efface à chaque ouverture. Contient les coureurs importés du jour.
let activeRiders = []; 

export async function main() {
    // ----------------------------------------------------
    // INJECTION DYNAMIQUE DE L'INTERFACE (MODE SANGSUE ZENMASTER)
    // ----------------------------------------------------
    const importCards = document.querySelectorAll('.config-card');
    if (importCards.length > 0) {
        importCards[0].innerHTML = `
            <h3 style="margin-top: 0; color: #fc6719; font-size: 16px;">📥 1. IMPORTATION DES DONNÉES</h3>
            <div style="font-size: 11px; color: #aaa; margin-bottom: 15px; line-height: 1.4;">
                Utilisez le mod <b>Points Leaderboard de Zenmaster</b> pour importer votre course.<br>
                Cliquez ensuite sur le bouton ci-dessous pour aspirer toutes ses données (Équipes et Coureurs) et préparer votre tactique !
            </div>

            <button id="btn-sync-zenmaster" style="width: 100%; background: #fc6719; color: white; border: none; padding: 12px; border-radius: 4px; font-weight: bold; cursor: pointer; transition: 0.2s; font-size: 12px; box-shadow: 0 2px 5px rgba(0,0,0,0.5);">🔄 SYNCHRONISER AVEC ZENMASTER</button>

            <div style="text-align: center; margin-top: 15px; padding-top: 15px; border-top: 1px solid #333;">
                <button id="btn-auto-capture" style="width: 100%; padding: 8px; background: #328dd1; color: white; border: none; border-radius: 4px; font-size: 11px; font-weight: bold; cursor: pointer;">📡 PLAN B : SCANNER LE SAS EN JEU</button>
            </div>
        `;
    }

    initTabs();
    renderAll();

    // ----------------------------------------------------
    // LA MAGIE : LECTURE DE LA BASE DE DONNÉES DE ZENMASTER
    // (Exactement la même logique que coureur.mjs !)
    // ----------------------------------------------------
    const btnSync = document.getElementById('btn-sync-zenmaster');
    if (btnSync) {
        btnSync.addEventListener('click', async () => {
            btnSync.innerText = "⏳ LECTURE DES DONNÉES...";
            btnSync.style.opacity = "0.7";
            btnSync.style.pointerEvents = "none";

            activeRiders = []; // On efface la mémoire volatile avant d'importer
            let count = 0;

            try {
                if (!indexedDB.databases) throw new Error("IndexedDB non supporté par le navigateur.");
                
                const dbs = await indexedDB.databases();
                
                // On cherche les bases de données créées par le mod Zenmaster
                let dbNamesToScan = dbs.map(db => db.name).filter(name => 
                    name.toLowerCase().includes('team') || 
                    name.toLowerCase().includes('point') ||
                    name.toLowerCase().includes('zen')
                );

                if (dbNamesToScan.length === 0) {
                    dbNamesToScan = ['teams', 'points-leaderboard', 'zenTeams'];
                }

                for (let dbName of dbNamesToScan) {
                    const dbInstance = await new Promise((resolve) => {
                        const req = indexedDB.open(dbName);
                        req.onsuccess = () => resolve(req.result);
                        req.onerror = () => resolve(null);
                        // J'AI SUPPRIMÉ LE req.onupgradeneeded QUI FAISAIT CRASHER LE BOUTON !
                    });

                    if (!dbInstance) continue;

                    // On parcourt tous les tiroirs de la base
                    for (let storeName of dbInstance.objectStoreNames) {
                        const data = await new Promise((resolve) => {
                            try {
                                const tx = dbInstance.transaction(storeName, 'readonly');
                                const store = tx.objectStore(storeName);
                                const req = store.getAll();
                                req.onsuccess = () => resolve(req.result);
                                req.onerror = () => resolve(null);
                            } catch(e) { resolve(null); }
                        });

                        // Si on trouve des données, on filtre pour récupérer les coureurs
                        if (data && data.length > 0) {
                            const isAssignments = data.some(d => d.zwid !== undefined || d.athleteId !== undefined || (d.id !== undefined && typeof d.id === 'number' && d.id > 1000));
                            
                            if (isAssignments) {
                                data.forEach(d => {
                                    // Cas classique (Liste de coureurs)
                                    let athId = Number(d.zwid || d.athleteId || d.id);
                                    
                                    if (athId && athId > 1000 && (d.team_name !== undefined || d.name !== undefined || d.tname !== undefined)) {
                                        if (!activeRiders.some(r => r.id === athId)) {
                                            
                                            let teamName = (d.team_name || d.tname || d.team || d.teamId || d.teamName || "Indépendant");
                                            if (typeof teamName !== 'string') teamName = "Indépendant";
                                            teamName = teamName.trim();

                                            let rName = d.name || d.riderName || d.fullName || `Coureur ${athId}`;

                                            // On pousse dans notre mémoire volatile
                                            activeRiders.push({
                                                id: athId,
                                                name: rName,
                                                originalTeam: teamName
                                            });
                                            
                                            // On sauvegarde automatiquement l'équipe si elle est nouvelle
                                            if (teamName !== "Indépendant" && !db.teams.includes(teamName)) {
                                                db.teams.push(teamName);
                                            }
                                            count++;
                                        }
                                    }
                                    
                                    // Cas spécifique Zenmaster (Groupes/Entrants encapsulés)
                                    if (d.entrants && Array.isArray(d.entrants)) {
                                        d.entrants.forEach(ent => {
                                            let entId = Number(ent.id || ent.athleteId || ent.zwid);
                                            if (entId && entId > 1000) {
                                                if (!activeRiders.some(r => r.id === entId)) {
                                                    let teamName = (ent.team || ent.teamName || ent.team_name || "Indépendant");
                                                    if (typeof teamName !== 'string') teamName = "Indépendant";
                                                    let rName = ent.name || ent.firstName ? `${ent.firstName} ${ent.lastName}` : `Coureur ${entId}`;
                                                    
                                                    activeRiders.push({ id: entId, name: rName, originalTeam: teamName });
                                                    
                                                    if (teamName !== "Indépendant" && !db.teams.includes(teamName)) {
                                                        db.teams.push(teamName);
                                                    }
                                                    count++;
                                                }
                                            }
                                        });
                                    }
                                });
                            }
                        }
                    }
                    dbInstance.close();
                }

                if (count > 0) {
                    save(); renderAll();
                    alert(`✅ SYNCHRONISATION RÉUSSIE !\n${count} coureurs ont été récupérés depuis la base de données de Zenmaster.`);
                } else {
                    alert("❌ Aucun coureur trouvé.\nAssurez-vous d'avoir d'abord importé la course (Bouton Open JSON) dans le mod de Zenmaster.");
                }
            } catch(e) {
                console.error("Erreur de synchronisation", e);
                alert("❌ Erreur technique inattendue lors de la lecture.");
            } finally {
                btnSync.innerText = "🔄 SYNCHRONISER AVEC ZENMASTER";
                btnSync.style.opacity = "1";
                btnSync.style.pointerEvents = "auto";
            }
        });
    }

    // ----------------------------------------------------
    // PLAN B : AUTO-CAPTURE (RADAR DANS LE SAS)
    // ----------------------------------------------------
    const btnAutoCapture = document.getElementById('btn-auto-capture');
    if (btnAutoCapture) {
        btnAutoCapture.onclick = () => {
            if (!common.athletes || common.athletes.size === 0) {
                alert("⚠️ Radar vide. Vous devez être dans le jeu avec Sauce pour capturer les coureurs autour de vous.");
                return;
            }
            
            // MÉMOIRE VOLATILE : On efface la liste avant de scanner
            activeRiders = [];
            let count = 0;

            const myId = common.athleteId;
            const me = common.athletes.get(myId);
            const mySubId = (me && me.state) ? (me.state.eventSubgroupId || me.state.subgroupId) : null;

            for (const [id, ath] of common.athletes.entries()) {
                if (ath && ath.athlete && ath.state) {
                    let subId = ath.state.eventSubgroupId || ath.state.subgroupId;
                    
                    if (!mySubId || String(subId) === String(mySubId)) {
                        if (!activeRiders.some(r => r.id === id)) {
                            let team = "Indépendant";
                            let rawT = ath.athlete.team;
                            if (Array.isArray(rawT)) rawT = rawT[0];
                            if (rawT && String(rawT).trim() !== "") team = rawT.trim();

                            const fInitial = ath.athlete.firstName ? ath.athlete.firstName.charAt(0) + '. ' : '';
                            const lName = ath.athlete.lastName || 'Inconnu';

                            activeRiders.push({
                                id: id,
                                name: fInitial + lName,
                                originalTeam: team
                            });

                            if (team !== "Indépendant" && !db.teams.includes(team)) {
                                db.teams.push(team);
                            }
                            count++;
                        }
                    }
                }
            }
            
            if (count > 0) {
                save(); renderAll();
                alert(`✅ Radar balayé !\n${count} coureurs détectés autour de vous ont été chargés dans la liste.`);
            } else {
                alert("ℹ️ Aucun coureur détecté autour de vous.");
            }
        };
    }

    // ----------------------------------------------------
    // GESTION DES ÉQUIPES MANUELLES
    // ----------------------------------------------------
    document.getElementById('btn-add-team').onclick = () => {
        const name = document.getElementById('new-team-name').value.trim();
        if (name && !db.teams.includes(name)) {
            db.teams.push(name);
            save(); renderAll();
            document.getElementById('new-team-name').value = '';
        }
    };

    // --- RECHERCHE ---
    const searchInput = document.getElementById('search-rider');
    if(searchInput) searchInput.oninput = (e) => renderRiders(e.target.value);

    // --- SAUVEGARDE DES RÈGLES ---
    const btnSaveAll = document.getElementById('btn-save-all');
    if(btnSaveAll) {
        btnSaveAll.onclick = () => {
            db.rules.scoreType = document.getElementById('rule-score-type').value;
            db.rules.topX = parseInt(document.getElementById('rule-top-x').value);
            db.rules.totalRiders = parseInt(document.getElementById('rule-total-riders').value);
            save();
            alert("✅ Règles tactiques sauvegardées !\nVos préférences sont partagées avec tous vos autres mods.");
        };
    }

    if (common.initInteractionListeners) {
        common.initInteractionListeners();
    }
}

// ----------------------------------------------------
// FONCTIONS DE RENDU ET SAUVEGARDE
// ----------------------------------------------------
function save() {
    localStorage.setItem('nicolastel_teams', JSON.stringify(db.teams));
    localStorage.setItem('nicolastel_marked_teams', JSON.stringify(db.markedTeams));
    localStorage.setItem('nicolastel_marked_riders', JSON.stringify(db.markedRiders));
    localStorage.setItem('nicolastel_rider_teams', JSON.stringify(db.riderTeams));
    localStorage.setItem('nicolastel_rules', JSON.stringify(db.rules));
}

function renderAll() {
    renderTeams();
    const searchInput = document.getElementById('search-rider');
    renderRiders(searchInput ? searchInput.value : "");
    const elScore = document.getElementById('rule-score-type');
    const elTop = document.getElementById('rule-top-x');
    const elTotal = document.getElementById('rule-total-riders');
    if(elScore) elScore.value = db.rules.scoreType;
    if(elTop) elTop.value = db.rules.topX;
    if(elTotal) elTotal.value = db.rules.totalRiders;
}

function renderTeams() {
    const body = document.getElementById('team-list-body');
    if(!body) return;
    body.innerHTML = db.teams.map(team => {
        const isDanger = db.markedTeams.includes(team);
        return `
            <tr class="row-team ${isDanger ? 'danger' : ''}">
                <td><span class="tag-danger" onclick="toggleTeamDanger('${team}')">${isDanger ? '🛑' : '⚠️'}</span></td>
                <td class="cell-team"><strong>${team}</strong></td>
                <td><span class="btn-delete" onclick="deleteTeam('${team}')">🗑️</span></td>
            </tr>
        `;
    }).join('');
}

function renderRiders(filter = "") {
    const body = document.getElementById('rider-list-body');
    if(!body) return;
    
    const filtered = activeRiders.filter(r => {
        const assignedTeam = db.riderTeams[r.id] || r.originalTeam;
        return r.name.toLowerCase().includes(filter.toLowerCase()) || assignedTeam.toLowerCase().includes(filter.toLowerCase());
    });
    
    body.innerHTML = filtered.map(rider => {
        // C'EST ICI LA MÉMOIRE PERMANENTE !
        const isDanger = db.markedRiders.includes(rider.id);
        const assignedTeam = db.riderTeams[rider.id] || rider.originalTeam;
        
        return `
            <tr class="row-rider ${isDanger ? 'danger' : ''}">
                <td><span class="tag-danger" onclick="toggleRiderDanger(${rider.id})">${isDanger ? '🛑' : '⚠️'}</span></td>
                <td class="cell-name">${rider.name}</td>
                <td>
                    <select onchange="assignTeam(${rider.id}, this.value)" style="width:100%; padding:4px; background:#222; color:white; border:1px solid #444;">
                        ${db.teams.map(t => `<option value="${t}" ${assignedTeam === t ? 'selected' : ''}>${t}</option>`).join('')}
                    </select>
                </td>
                <td><span class="btn-delete" onclick="removeRiderFromList(${rider.id})">🗑️</span></td>
            </tr>
        `;
    }).join('');
}

// ----------------------------------------------------
// ACTIONS DÉDIÉES À L'INTERFACE HTML
// ----------------------------------------------------
window.toggleTeamDanger = (name) => {
    if (db.markedTeams.includes(name)) db.markedTeams = db.markedTeams.filter(t => t !== name);
    else db.markedTeams.push(name);
    save(); renderAll();
};

window.deleteTeam = (name) => {
    if (confirm(`Supprimer définitivement l'équipe ${name} ?`)) {
        db.teams = db.teams.filter(t => t !== name);
        save(); renderAll();
    }
};

window.assignTeam = (id, teamName) => {
    db.riderTeams[id] = teamName; 
    save(); renderAll();
};

window.toggleRiderDanger = (id) => {
    if (db.markedRiders.includes(id)) {
        db.markedRiders = db.markedRiders.filter(x => x !== id);
    } else {
        db.markedRiders.push(id); 
    }
    save(); renderAll();
};

window.removeRiderFromList = (id) => {
    activeRiders = activeRiders.filter(x => x.id !== id);
    renderAll();
};

function initTabs() {
    document.querySelectorAll('.tab-btn').forEach(btn => {
        btn.onclick = () => {
            document.querySelectorAll('.tab-btn, .tab-content').forEach(el => el.classList.remove('active'));
            btn.classList.add('active');
            const target = document.getElementById(btn.dataset.tab);
            if(target) target.classList.add('active');
        };
    });
}