script.js

// Инициализация при загрузке страницы
document.addEventListener('DOMContentLoaded', function() {
    initializeEventListeners();
    setupInputNavigation();
});

// Настройка слушателей событий
function initializeEventListeners() {
    // Кнопка поиска
    document.getElementById('searchBtn').addEventListener('click', searchWords);
    
    // Кнопка очистки
    document.getElementById('clearBtn').addEventListener('click', clearAll);
    
    // Кнопка добавления маски
    document.getElementById('addMaskBtn').addEventListener('click', addExcludingMask);
    
    // Enter для поиска
    document.addEventListener('keypress', function(e) {
        if (e.key === 'Enter') {
            searchWords();
        }
    });
}

// Настройка навигации между полями
function setupInputNavigation() {
    const letterInputs = document.querySelectorAll('.letter-input');
    
    letterInputs.forEach((input, index) => {
        input.addEventListener('input', function(e) {
            if (this.value.length === 1) {
                // Переход к следующему полю
                const nextInput = findNextInput(this);
                if (nextInput) {
                    nextInput.focus();
                }
            }
        });
        
        input.addEventListener('keydown', function(e) {
            if (e.key === 'Backspace' && this.value === '') {
                // Переход к предыдущему полю при удалении
                const prevInput = findPrevInput(this);
                if (prevInput) {
                    prevInput.focus();
                }
            }
        });
    });
}

// Поиск следующего поля ввода
function findNextInput(currentInput) {
    const row = currentInput.parentElement;
    const inputs = Array.from(row.querySelectorAll('.letter-input'));
    const currentIndex = inputs.indexOf(currentInput);
    
    if (currentIndex < inputs.length - 1) {
        return inputs[currentIndex + 1];
    }
    return null;
}

// Поиск предыдущего поля ввода
function findPrevInput(currentInput) {
    const row = currentInput.parentElement;
    const inputs = Array.from(row.querySelectorAll('.letter-input'));
    const currentIndex = inputs.indexOf(currentInput);
    
    if (currentIndex > 0) {
        return inputs[currentIndex - 1];
    }
    return null;
}

// Добавление новой исключающей маски
function addExcludingMask() {
    const container = document.getElementById('excludingMasks');
    const maskCount = container.querySelectorAll('.excluding-mask-row').length;
    
    const newRow = document.createElement('div');
    newRow.className = 'input-row excluding-mask-row';
    
    for (let i = 0; i < 5; i++) {
        const input = document.createElement('input');
        input.type = 'text';
        input.className = 'letter-input red-border';
        input.maxLength = 1;
        input.dataset.mask = maskCount;
        input.dataset.position = i;
        newRow.appendChild(input);
    }
    
    container.appendChild(newRow);
    setupInputNavigation();
}

// Очистка всех полей
function clearAll() {
    // Очистка всех текстовых полей
    document.querySelectorAll('.letter-input, .text-input').forEach(input => {
        input.value = '';
    });
    
    // Скрытие результатов и ошибок
    document.getElementById('results').classList.remove('visible');
    document.getElementById('errorMessage').classList.remove('visible');
}

// Основная функция поиска слов
function searchWords() {
    try {
        // Получение данных из полей
        const mask = getMask();
        const knownLetters = getKnownLetters();
        const excludeLetters = getExcludeLetters();
        const excludingMasks = getExcludingMasks();
        
        // Поиск подходящих слов
        const results = findMatchingWords(mask, knownLetters, excludeLetters, excludingMasks);
        
        // Отображение результатов
        displayResults(results);
        
    } catch (error) {
        showError(error.message);
    }
}

// Получение маски слова
function getMask() {
    const maskInputs = document.querySelectorAll('#maskRow .letter-input');
    const mask = [];
    
    maskInputs.forEach(input => {
        const value = input.value.toUpperCase().trim();
        mask.push(value || '*');
    });
    
    return mask;
}

// Получение известных букв
function getKnownLetters() {
    const input = document.getElementById('knownLetters');
    const letters = input.value.toUpperCase().trim();
    return letters.split('').filter(char => /[А-ЯЁ]/.test(char));
}

// Получение исключенных букв
function getExcludeLetters() {
    const input = document.getElementById('excludeLetters');
    const letters = input.value.toUpperCase().trim();
    return letters.split('').filter(char => /[А-ЯЁ]/.test(char));
}

// Получение исключающих масок
function getExcludingMasks() {
    const rows = document.querySelectorAll('.excluding-mask-row');
    const masks = [];
    
    rows.forEach(row => {
        const inputs = row.querySelectorAll('.letter-input');
        const mask = [];
        let hasContent = false;
        
        inputs.forEach(input => {
            const value = input.value.toUpperCase().trim();
            if (value) hasContent = true;
            mask.push(value || '');
        });
        
        if (hasContent) {
            masks.push(mask);
        }
    });
    
    return masks;
}

// Поиск подходящих слов
function findMatchingWords(mask, knownLetters, excludeLetters, excludingMasks) {
    if (typeof WORDS === 'undefined' || !Array.isArray(WORDS)) {
        throw new Error('Словарь слов не загружен');
    }
    
    return WORDS.filter(word => {
        // Фильтрация только 5-буквенных слов
        if (word.length !== 5) {
            return false;
        }
        
        const wordUpper = word.toUpperCase();
        
        // Проверка маски
        if (!matchesMask(wordUpper, mask)) {
            return false;
        }
        
        // Проверка известных букв
        if (!containsAllLetters(wordUpper, knownLetters)) {
            return false;
        }
        
        // Проверка исключенных букв
        if (containsAnyLetter(wordUpper, excludeLetters)) {
            return false;
        }
        
        // Проверка исключающих масок
        if (matchesAnyExcludingMask(wordUpper, excludingMasks)) {
            return false;
        }
        
        // Проверка конфликтов между маской и известными буквами
        if (!validateKnownLettersPosition(wordUpper, mask, knownLetters)) {
            return false;
        }
        
        return true;
    });
}

// Проверка соответствия маске
function matchesMask(word, mask) {
    for (let i = 0; i < 5; i++) {
        if (mask[i] !== '*' && word[i] !== mask[i]) {
            return false;
        }
    }
    return true;
}

// Проверка наличия всех известных букв с учетом количества повторений
function containsAllLetters(word, letters) {
    // Подсчитываем количество каждой буквы в слове
    const wordLetterCount = {};
    for (const letter of word.split('')) {
        wordLetterCount[letter] = (wordLetterCount[letter] || 0) + 1;
    }
    
    // Подсчитываем количество каждой буквы в требуемых буквах
    const requiredLetterCount = {};
    for (const letter of letters) {
        requiredLetterCount[letter] = (requiredLetterCount[letter] || 0) + 1;
    }
    
    // Проверяем что каждая требуемая буква встречается нужное количество раз
    for (const letter in requiredLetterCount) {
        if ((wordLetterCount[letter] || 0) < requiredLetterCount[letter]) {
            return false;
        }
    }
    
    return true;
}

// Проверка наличия любой из исключенных букв
function containsAnyLetter(word, letters) {
    const wordLetters = word.split('');
    return letters.some(letter => wordLetters.includes(letter));
}

// Проверка соответствия исключающим маскам
function matchesAnyExcludingMask(word, masks) {
    return masks.some(mask => {
        for (let i = 0; i < 5; i++) {
            if (mask[i] && word[i] === mask[i]) {
                return true;
            }
        }
        return false;
    });
}

// Проверка что известные буквы не находятся в позициях маски
function validateKnownLettersPosition(word, mask, knownLetters) {
    for (let i = 0; i < 5; i++) {
        if (mask[i] !== '*') {
            // Если буква в маске совпадает с известной буквой
            if (knownLetters.includes(mask[i])) {
                // Проверяем что эта буква есть в слове еще раз
                const maskLetterCount = mask.filter(l => l === mask[i] && l !== '*').length;
                const wordLetterCount = word.split('').filter(l => l === mask[i]).length;
                
                // Если в маске указана буква, которая также в известных буквах,
                // значит она должна встречаться в слове больше одного раза
                if (wordLetterCount <= maskLetterCount) {
                    return false;
                }
            }
        }
    }
    return true;
}

// Отображение результатов
function displayResults(results) {
    const resultsDiv = document.getElementById('results');
    const errorDiv = document.getElementById('errorMessage');
    
    errorDiv.classList.remove('visible');
    
    if (results.length === 0) {
        resultsDiv.innerHTML = '<h3>Слова не найдены</h3><p>Попробуйте изменить критерии поиска.</p>';
        resultsDiv.classList.add('visible');
        return;
    }
    
    let html = '<h3>Найдено слов: ' + results.length + '</h3><ol>';
    
    results.slice(0, 100).forEach((word, index) => {
        const wikiUrl = `https://ru.wikipedia.org/wiki/${encodeURIComponent(word)}`;
        html += `
            <li>
                <span>${index + 1}.</span>
                <span class="result-word">
                    ${word.toUpperCase()}
                    <a href="${wikiUrl}" target="_blank" rel="nofollow noindex" class="help-icon-result" title="Открыть в Википедии">?</a>
                </span>
            </li>
        `;
    });
    
    html += '</ol>';
    
    if (results.length > 100) {
        html += '<p style="margin-top: 15px; color: #999;">Показаны первые 100 результатов</p>';
    }
    
    resultsDiv.innerHTML = html;
    resultsDiv.classList.add('visible');
}

// Отображение ошибки
function showError(message) {
    const errorDiv = document.getElementById('errorMessage');
    errorDiv.textContent = message;
    errorDiv.classList.add('visible');
    
    document.getElementById('results').classList.remove('visible');
}