backend/src/services/lab8/task2.service.js - master - Centermant/web-nodejs

backend/src/services/lab8/task2.service.js
213 строк8 KB
Centermant
feat(lab8.1-8.2 final)
13 ноя 2025, 02:18
13 ноя 2025, 02:184e12d02
import fs from 'fs/promises';
import path from 'path';

const CUP_FILE_PATH = path.join(process.cwd(), 'data', 'lab8', 'task2', 'cup.txt');
const GROUPS_FILE_PATH = path.join(process.cwd(), 'data', 'lab8', 'task2', 'groups.json');
const STADIUMS_FILE_PATH = path.join(process.cwd(), 'data', 'lab8', 'task2', 'stadiums.json');

async function readCupFile() {
    try {
        const data = await fs.readFile(CUP_FILE_PATH, 'utf8');
        return data;
    } catch (err) {
        if (err.code === 'ENOENT') {
            console.error("Файл cup.txt не найден по пути:", CUP_FILE_PATH);
            throw new Error("Файл данных для задания 2 не найден.");
        }
        throw err;
    }
}

function parseCupData(fileContent) {
    const lines = fileContent.split('\n');
    const groups = {};
    const stadiums = {};

    // Сопоставление команд с группами
    const teamToGroupMap = {
        'Qatar': 'A', 'Ecuador': 'A', 'Senegal': 'A', 'Netherlands': 'A',
        'England': 'B', 'Iran': 'B', 'United States': 'B', 'Wales': 'B',
        'Argentina': 'C', 'Saudi Arabia': 'C', 'Mexico': 'C', 'Poland': 'C',
        'France': 'D', 'Australia': 'D', 'Denmark': 'D', 'Tunisia': 'D',
        'Spain': 'E', 'Costa Rica': 'E', 'Germany': 'E', 'Japan': 'E',
        'Belgium': 'F', 'Canada': 'F', 'Morocco': 'F', 'Croatia': 'F',
        'Brazil': 'G', 'Serbia': 'G', 'Switzerland': 'G', 'Cameroon': 'G',
        'Portugal': 'H', 'Ghana': 'H', 'Uruguay': 'H', 'South Korea': 'H',
    };

    for (const line of lines) {
        const trimmedLine = line.trim();
        
        // Пропускаем пустые строки, комментарии и строки, не начинающиеся с номера в скобках
        if (trimmedLine === '' || 
            trimmedLine.startsWith('#') || 
            !trimmedLine.match(/^\s*\(\d+\)/) ||
            trimmedLine.includes('[')) {
            continue;
        }

        try {
            const dateTimeMatch = trimmedLine.match(/([A-Za-z]{3} [A-Za-z]{3}\/\d{2})\s+(\d{2}:\d{2})/);
            if (!dateTimeMatch) continue;
            
            const date = dateTimeMatch[1];
            const time = dateTimeMatch[2];
            
            const stadiumMatch = trimmedLine.match(/@ (.+?),/);
            if (!stadiumMatch) continue;
            
            const stadium = stadiumMatch[1].trim();
            
            const scoreMatch = trimmedLine.match(/(\d+)-(\d+)/);
            if (!scoreMatch) continue;
            
            const goals1 = scoreMatch[1];
            const goals2 = scoreMatch[2];
            
            const teamParts = trimmedLine.split('@')[0].split(/\s+/).filter(Boolean);
            
            const teamIndexStart = teamParts.findIndex(part => part.includes(dateTimeMatch[0])) + 3;
            const teamIndexEnd = teamParts.findIndex(part => part.includes(`${goals1}-${goals2}`));
            
            if (teamIndexStart < 0 || teamIndexEnd < 0 || teamIndexStart >= teamIndexEnd) {
                continue;
            }
            
            let team1 = '';
            for (let i = teamIndexStart; i < teamIndexEnd; i++) {
                if (!teamParts[i].match(/\d+/) && !teamParts[i].includes('(')) {
                    team1 += (team1 ? ' ' : '') + teamParts[i];
                }
            }
            
            let team2 = '';
            for (let i = teamIndexEnd + 1; i < teamParts.length; i++) {
                if (!teamParts[i].match(/\d+/) && !teamParts[i].includes('(') && !teamParts[i].includes(')')) {
                    team2 += (team2 ? ' ' : '') + teamParts[i];
                }
            }
            
            team1 = team1.trim();
            team2 = team2.trim();
            
            if (!team1 || !team2) continue;
            
            const groupLetter = teamToGroupMap[team1] || teamToGroupMap[team2] || 'Unknown';
            if (groupLetter === 'Unknown') {
                console.warn(`Не удалось определить группу для матча: ${team1} vs ${team2}`);
                continue;
            }
            
            // Формируем строку для вывода
            const score = `${goals1}-${goals2}`;
            const result = determineMatchResult(parseInt(goals1), parseInt(goals2));
            const matchDisplayString = `${team1} ${score} (${goals1}-${goals2}) ${team2}`;
            
            if (!groups[date]) {
                groups[date] = {};
            }
            if (groups[date][time]) {
                let newTimeKey = time;
                let suffix = 2;
                while (groups[date][newTimeKey]) {
                    newTimeKey = `${time}-${suffix}`;
                    suffix++;
                }
                groups[date][newTimeKey] = matchDisplayString;
            } else {
                groups[date][time] = matchDisplayString;
            }
            
            if (!stadiums[stadium]) {
                stadiums[stadium] = {};
            }
            if (!stadiums[stadium][date]) {
                stadiums[stadium][date] = {};
            }
            if (stadiums[stadium][date][time]) {
                let newTimeKey = time;
                let suffix = 2;
                while (stadiums[stadium][date][newTimeKey]) {
                    newTimeKey = `${time}-${suffix}`;
                    suffix++;
                }
                stadiums[stadium][date][newTimeKey] = {
                    group: groupLetter,
                    teams: `${team1} vs ${team2}`,
                    score: score,
                    result: result
                };
            } else {
                stadiums[stadium][date][time] = {
                    group: groupLetter,
                    teams: `${team1} vs ${team2}`,
                    score: score,
                    result: result
                };
            }
        } catch (e) {
            console.error('Ошибка при обработке строки матча:', trimmedLine, e);
            continue;
        }
    }
    
    return { groups, stadiums };
}

function determineMatchResult(goals1, goals2) {
    if (goals1 > goals2) return 'win1';
    if (goals2 > goals1) return 'win2';
    return 'draw';
}

async function writeJsonFiles(groups, stadiums) {
    const dirPath = path.dirname(GROUPS_FILE_PATH);
    await fs.mkdir(dirPath, { recursive: true });

    await fs.writeFile(GROUPS_FILE_PATH, JSON.stringify(groups, null, 2), 'utf8');
    await fs.writeFile(STADIUMS_FILE_PATH, JSON.stringify(stadiums, null, 2), 'utf8');
}

async function processCupData() {
    try {
        const fileContent = await readCupFile();
        const { groups, stadiums } = parseCupData(fileContent);
        console.log("Найдено матчей для групп:", Object.keys(groups).length);
        console.log("Найдено стадионов:", Object.keys(stadiums).length);
        await writeJsonFiles(groups, stadiums);
        console.log("Файлы groups.json и stadiums.json успешно созданы.");
    } catch (error) {
        console.error("Ошибка при обработке данных для задания 2:", error);
        throw error;
    }
}

async function getGroupsData() {
    try {
        const data = await fs.readFile(GROUPS_FILE_PATH, 'utf8');
        return JSON.parse(data);
    } catch (err) {
        if (err.code === 'ENOENT') {
            return {};
        }
        throw err;
    }
}

async function getStadiumsData() {
    try {
        const data = await fs.readFile(STADIUMS_FILE_PATH, 'utf8');
        return JSON.parse(data);
    } catch (err) {
        if (err.code === 'ENOENT') {
            return {};
        }
        throw err;
    }
}

export default {
    processCupData,
    getGroupsData,
    getStadiumsData
};