/**
 * parser.js — Парсинг и сверка данных
 *
 * Определение типа файла, извлечение ведомостей и транзакций,
 * сопоставление по водителям + гос. номерам, расчёт расхождений.
 */

import { readExcel } from './utils.js';

/* ================================================================
   КОНСТАНТЫ
   ================================================================ */

/** Заголовок, по которому распознаётся ведомость */
const VEDOMOST_HEADER = 'ВЕДОМОСТЬ ПРИЕМА НАЛИЧНЫХ СРЕДСТВ';

/** Столбцы, по которым распознаётся выгрузка транзакций */
const TRANSACTION_COLS = ['CONDUCTOR', 'DATE', 'TARIF_SUM'];

/** Латинские буквы, которые заменяются на кириллические в гос. номерах */
const LATIN_TO_CYRILLIC = {
    'A': 'А', 'B': 'В', 'C': 'С', 'E': 'Е', 'H': 'Н',
    'K': 'К', 'M': 'М', 'O': 'О', 'P': 'Р', 'T': 'Т',
    'X': 'Х', 'Y': 'У'
};

/** Порог схожести ФИО для нечёткого сравнения (0..1) */
const FUZZY_THRESHOLD = 0.88;

/* ================================================================
   ТИПИЗАЦИЯ ФАЙЛОВ
   ================================================================ */

/**
 * Определить тип файла: 'vedomost' | 'transaction' | null
 * @param {string} filename
 * @param {string[][]} firstSheet - первый лист книги
 * @returns {string|null}
 */
export function detectFileType(filename, firstSheet) {
    // 1. Проверка по заголовку ведомости
    if (hasHeader(firstSheet, VEDOMOST_HEADER)) {
        return 'vedomost';
    }

    // 2. Проверка по названию файла
    const lower = filename.toLowerCase();
    if (lower.includes('transaction') || lower.includes('transactions') || lower.includes('выгрузка')) {
        return 'transaction';
    }

    // 3. Проверка по столбцам транзакций (первые 3 строки)
    if (hasTransactionColumns(firstSheet)) {
        return 'transaction';
    }

    // 4. Если есть знакомые заголовки — ведомость
    if (hasHeader(firstSheet, 'ВЕДОМОСТЬ')) {
        return 'vedomost';
    }

    return null;
}

/**
 * Проверить, содержит ли лист указанный заголовок
 */
function hasHeader(sheetData, header) {
    if (!sheetData || sheetData.length === 0) return false;
    // Проверяем первые 20 строк
    for (let i = 0; i < Math.min(sheetData.length, 20); i++) {
        const row = sheetData[i];
        if (!row) continue;
        const joined = row.filter(c => c != null).map(String).join(' ').toUpperCase();
        if (joined.includes(header.toUpperCase())) return true;
    }
    return false;
}

/**
 * Проверить, содержит ли лист столбцы транзакций
 */
function hasTransactionColumns(sheetData) {
    if (!sheetData || sheetData.length === 0) return false;
    // Проверяем первые 5 строк
    for (let i = 0; i < Math.min(sheetData.length, 5); i++) {
        const row = sheetData[i];
        if (!row) continue;
        const cells = row.map(c => String(c).toUpperCase().trim());
        const hasConductor = cells.some(c => c.includes('CONDUCTOR'));
        const hasDate = cells.some(c => c.includes('DATE'));
        const hasTarif = cells.some(c => c.includes('TARIF_SUM') || c.includes('TARIF'));
        if (hasConductor && hasDate && hasTarif) return true;
    }
    return false;
}

/* ================================================================
   НОРМАЛИЗАЦИЯ ДАННЫХ
   ================================================================ */

/**
 * Нормализовать гос. номер: заменить латиницу на кириллицу, удалить лишнее
 * @param {string} plate
 * @returns {string}
 */
export function normalizePlate(plate) {
    if (!plate) return '';
    let s = String(plate).toUpperCase().trim();
    // Замена латинских букв на кириллические
    s = s.split('').map(ch => LATIN_TO_CYRILLIC[ch] || ch).join('');
    // Удаление пробелов, дефисов и непечатных символов, кроме букв и цифр
    s = s.replace(/[^А-ЯЁA-Z0-9]/gi, '');
    return s;
}

/**
 * Нормализовать ФИО: верхний регистр, Ё→Е, обрезка
 * @param {string} name
 * @returns {string}
 */
export function normalizeName(name) {
    if (!name) return '';
    return String(name)
        .toUpperCase()
        .trim()
        .replace(/Ё/g, 'Е')
        .replace(/\s+/g, ' ');
}

/**
 * Нечёткое сравнение ФИО (расстояние Левенштейна → схожесть)
 * @param {string} a
 * @param {string} b
 * @returns {number} 0..1
 */
export function nameSimilarity(a, b) {
    if (!a || !b) return 0;
    const s1 = normalizeName(a);
    const s2 = normalizeName(b);
    if (s1 === s2) return 1;
    if (s1.length === 0 || s2.length === 0) return 0;
    const dist = levenshtein(s1, s2);
    const maxLen = Math.max(s1.length, s2.length);
    return 1 - dist / maxLen;
}

/**
 * Расстояние Левенштейна
 */
function levenshtein(a, b) {
    const m = a.length, n = b.length;
    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
    for (let i = 0; i <= m; i++) dp[i][0] = i;
    for (let j = 0; j <= n; j++) dp[0][j] = j;
    for (let i = 1; i <= m; i++) {
        for (let j = 1; j <= n; j++) {
            dp[i][j] = a[i - 1] === b[j - 1]
                ? dp[i - 1][j - 1]
                : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
        }
    }
    return dp[m][n];
}

/* ================================================================
   ПАРСИНГ ВЕДОМОСТИ
   ================================================================ */

/**
 * Распарсить ведомость и вернуть структурированные данные
 * @param {string[][]} sheetData - массив строк листа
 * @returns {Object} - { docNumber, date, cashier, sections: { city, suburb }, drivers: [] }
 */
export function parseVedomost(sheetData) {
    if (!sheetData || sheetData.length === 0) return null;

    const result = {
        docNumber: '',
        date: '',
        cashier: '',
        sections: { city: [], suburb: [] },
        drivers: []
    };

    let currentSection = null; // 'city' | 'suburb'
    let headerFound = false;
    let tableStarted = false;
    let tableEnded = false;

    for (let i = 0; i < sheetData.length; i++) {
        const row = sheetData[i];
        if (!row || row.length === 0) continue;

        const cells = row.map(c => String(c).trim());

        // Поиск заголовка ведомости
        if (!headerFound) {
            const joined = cells.join(' ').toUpperCase();
            if (joined.includes(VEDOMOST_HEADER)) {
                headerFound = true;
            }
            continue;
        }

        // Номер документа и дата
        if (!result.docNumber) {
            const numIdx = cells.findIndex(c => c.toUpperCase().includes('ДОКУМЕНТ'));
            if (numIdx >= 0) {
                result.docNumber = cells[numIdx + 1] || '';
                // Дата может быть в той же строке или следующей
                const dateIdx = cells.findIndex(c => /^\d{2}[./-]\d{2}[./-]\d{4}$/.test(c));
                if (dateIdx >= 0) result.date = cells[dateIdx];
            }
        }

        // Дата (если не нашли выше)
        if (!result.date) {
            const dateMatch = cells.find(c => /^\d{2}[./-]\d{2}[./-]\d{4}$/.test(c));
            if (dateMatch) result.date = dateMatch;
        }

        // Кассир
        if (!result.cashier) {
            const cashIdx = cells.findIndex(c => c.toUpperCase().includes('КАССИР'));
            if (cashIdx >= 0) {
                // Ищем ФИО после слова "Кассир"
                const nameIdx = cashIdx + 1;
                if (nameIdx < cells.length && cells[nameIdx].length > 2) {
                    result.cashier = cells[nameIdx];
                }
            }
        }

        // Определение секции (Город / Пригород)
        const joinedRow = cells.join(' ').toUpperCase();
        if (joinedRow.includes('ГОРОД') || joinedRow.includes('ГОР.') || (joinedRow.includes('ГОР') && !joinedRow.includes('ПРИГОР'))) {
            currentSection = 'city';
            tableStarted = false; // Таблица начинается после заголовка секции
            continue;
        }
        if (joinedRow.includes('ПРИГОРОД') || joinedRow.includes('ПРИГ.')) {
            currentSection = 'suburb';
            tableStarted = false;
            continue;
        }

        // Пропуск пустых и служебных строк
        if (cells.every(c => c === '')) {
            if (tableStarted) tableEnded = true; // Пустая строка = конец таблицы
            continue;
        }

        // Определение начала таблицы с водителями
        const headerRow = cells.join(' ').toUpperCase();
        if (headerRow.includes('ФИО') || headerRow.includes('Ф.И.О') || headerRow.includes('ВОДИТЕЛЬ') ||
            headerRow.includes('ФАМИЛИЯ') || (headerRow.includes('ФИО') && (headerRow.includes('СУММА') || headerRow.includes('МАРШРУТ')))) {
            tableStarted = true;
            tableEnded = false;
            continue;
        }

        // Если таблица началась, закончилась и мы снова видим непустую строку — возможно новая секция
        if (tableEnded && !tableStarted) continue;

        // Парсинг строки водителя (только внутри таблицы)
        if (tableStarted && !tableEnded && currentSection) {
            const driver = parseDriverRow(cells, currentSection);
            if (driver) {
                result.drivers.push(driver);
                result.sections[currentSection].push(driver);
            }
        }
    }

    return result;
}

/**
 * Распарсить строку водителя из ведомости
 * @param {string[]} cells
 * @param {string} section - 'city' | 'suburb'
 * @returns {Object|null}
 */
function parseDriverRow(cells, section) {
    if (!cells || cells.length < 2) return null;

    // Фильтр: отбрасываем совсем пустые строки
    const nonEmpty = cells.filter(c => c.trim() !== '');
    if (nonEmpty.length < 2) return null;

    // Пропускаем итоговые строки
    const joined = cells.join(' ').toUpperCase();
    if (joined.includes('ИТОГО') || joined.includes('ВСЕГО') || joined.includes('ПО РАЗДЕЛУ')) {
        return null;
    }

    // Ищем ФИО — обычно первая колонка
    const fio = cells[0] || '';
    if (fio.length < 3 || /^\d+$/.test(fio)) return null;

    // Ищем гос. номер — паттерн: буква + 3 цифры + 2 буквы + 2-3 цифры (регион)
    let plate = '';
    let plateIdx = -1;
    for (let j = 0; j < cells.length; j++) {
        const cleaned = cells[j].replace(/[\s-]/g, '').toUpperCase();
        if (/^[А-ЯA-Z]{1}\d{3}[А-ЯA-Z]{2}\d{2,3}$/.test(cleaned) ||
            /^[А-ЯA-Z]{1}\d{3}[А-ЯA-Z]{2}$/.test(cleaned)) {
            plate = cleaned;
            plateIdx = j;
            break;
        }
    }

    // Ищем маршрут (номер маршрута)
    let route = '';
    for (let j = 1; j < cells.length; j++) {
        const c = cells[j].trim();
        if (/^\d{1,3}$/.test(c) && c !== plate) {
            route = c;
            break;
        }
    }

    // Ищем сумму — последнее число или после ключевых слов
    let sum = 0;
    for (let j = cells.length - 1; j >= 0; j--) {
        const c = cells[j].trim().replace(/\s/g, '').replace(',', '.');
        const num = parseFloat(c);
        if (!isNaN(num) && num > 0) {
            // Проверяем, что это не номер маршрута и не индекс
            if (j !== plateIdx && j !== 0) {
                sum = num;
                break;
            }
        }
    }

    return {
        fio: normalizeName(fio),
        plate: normalizePlate(plate),
        section,
        route,
        sum,             // "Сдано" — итого на сумму
        cash: 0,         // будет заполнено позже
        nonCash: 0
    };
}

/* ================================================================
   ПАРСИНГ ТРАНЗАКЦИЙ
   ================================================================ */

/**
 * Распарсить выгрузку транзакций
 * @param {string[][]} sheetData
 * @returns {Object[]} - массив транзакций
 */
export function parseTransactions(sheetData) {
    if (!sheetData || sheetData.length === 0) return [];

    // Найдём строку заголовков и индексы колонок
    let headerRow = -1;
    let colIndexes = {};

    for (let i = 0; i < Math.min(sheetData.length, 10); i++) {
        const row = sheetData[i];
        if (!row) continue;
        const cells = row.map(c => String(c).toUpperCase().trim());
        const idxDate = cells.findIndex(c => c.includes('DATE'));
        const idxConductor = cells.findIndex(c => c.includes('CONDUCTOR'));
        const idxTarif = cells.findIndex(c => c.includes('TARIF_SUM') || (c.includes('TARIF') && !c.includes('TARIF_PAY')));
        const idxCar = cells.findIndex(c => c.includes('CAR') || c.includes('PLATE') || c.includes('AUTO'));
        const idxRoute = cells.findIndex(c => c.includes('ROUTE') || c.includes('RUTE'));
        const idxTarifPay = cells.findIndex(c => c.includes('TARIF_PAY') || c.includes('TARIFPAY'));

        if (idxDate >= 0 && idxConductor >= 0 && idxTarif >= 0) {
            headerRow = i;
            colIndexes = {
                date: idxDate,
                conductor: idxConductor,
                tarifSum: idxTarif,
                car: idxCar >= 0 ? idxCar : -1,
                route: idxRoute >= 0 ? idxRoute : -1,
                tarifPay: idxTarifPay >= 0 ? idxTarifPay : -1
            };
            break;
        }
    }

    if (headerRow < 0) return [];

    // Парсинг строк данных
    const transactions = [];
    for (let i = headerRow + 1; i < sheetData.length; i++) {
        const row = sheetData[i];
        if (!row || row.length === 0) continue;

        const date = String(row[colIndexes.date] || '').trim();
        const conductor = String(row[colIndexes.conductor] || '').trim();
        const tarifSumStr = String(row[colIndexes.tarifSum] || '0').trim().replace(',', '.');
        const tarifSum = parseFloat(tarifSumStr);

        // Пропускаем пустые или невалидные строки
        if (!date || !conductor || isNaN(tarifSum)) continue;

        // Проверка, что это строка данных, а не заголовок
        if (conductor.toUpperCase().includes('CONDUCTOR')) continue;

        const car = colIndexes.car >= 0 ? String(row[colIndexes.car] || '').trim() : '';
        const route = colIndexes.route >= 0 ? String(row[colIndexes.route] || '').trim() : '';

        transactions.push({
            date: date,
            conductor: normalizeName(conductor),
            plate: normalizePlate(car),
            route: route,
            tarifSum: tarifSum,        // в копейках
            tarifRub: tarifSum / 100,   // в рублях
            tarifPay: colIndexes.tarifPay >= 0 ? parseFloat(String(row[colIndexes.tarifPay] || '0').replace(',', '.')) : 0
        });
    }

    return transactions;
}

/* ================================================================
   СВЕРКА
   ================================================================ */

/**
 * Выполнить сверку: сопоставить ведомости и транзакции
 * @param {Object[]} vedomosti - массив распарсенных ведомостей
 * @param {Object[]} transactions - массив транзакций
 * @returns {Object} - результат сверки
 */
export function reconcile(vedomosti, transactions) {
    // 1. Собираем уникальные даты из ведомостей
    const vedomostDates = new Set();
    vedomosti.forEach(v => {
        if (v.date) vedomostDates.add(normalizeDate(v.date));
    });

    // 2. Фильтруем транзакции только по датам ведомостей
    const filteredTransactions = transactions.filter(t => {
        const tDate = normalizeDate(t.date);
        return vedomostDates.has(tDate);
    });

    // 3. Группируем транзакции по (водитель + гос. номер)
    const txByDriver = new Map();
    filteredTransactions.forEach(t => {
        const key = `${t.conductor}|${t.plate || ''}`;
        if (!txByDriver.has(key)) {
            txByDriver.set(key, { conductor: t.conductor, plate: t.plate, totalTarif: 0, txCount: 0, dates: new Set() });
        }
        const entry = txByDriver.get(key);
        entry.totalTarif += t.tarifRub;
        entry.txCount++;
        entry.dates.add(normalizeDate(t.date));
    });

    // 4. Собираем водителей из ведомостей и сопоставляем
    const driverMap = new Map(); // ключ: нормализованное ФИО|номер
    const allVedomostDrivers = [];

    vedomosti.forEach(v => {
        v.drivers.forEach(d => {
            const key = `${d.fio}|${d.plate}`;
            if (!driverMap.has(key)) {
                driverMap.set(key, {
                    fio: d.fio,
                    plate: d.plate,
                    route: d.route,
                    section: d.section,
                    cashier: v.cashier,
                    vedomostDate: v.date,
                    totalGiven: 0  // Сдано
                });
            }
            driverMap.get(key).totalGiven += d.sum;
            allVedomostDrivers.push(d);
        });
    });

    // 5. Сопоставление: для каждого водителя из ведомости ищем транзакции
    const results = [];
    const unmatchedTx = []; // транзакции без пары в ведомости

    // Прямое сопоставление
    const usedTxKeys = new Set();

    driverMap.forEach((vd, key) => {
        const [fio, plate] = key.split('|');

        // Точное совпадение по (ФИО + номер)
        const txKey = `${vd.fio}|${vd.plate}`;
        let txEntry = txByDriver.get(txKey);

        // Нечёткое совпадение по ФИО, если точного нет
        if (!txEntry) {
            let bestSim = 0;
            let bestKey = '';
            txByDriver.forEach((entry, k) => {
                const [txFio, txPlate] = k.split('|');
                // Сначала проверяем совпадение номера
                const plateMatch = txPlate && vd.plate && normalizePlate(txPlate) === normalizePlate(vd.plate);
                const sim = nameSimilarity(vd.fio, txFio);
                if (plateMatch && sim >= FUZZY_THRESHOLD && sim > bestSim) {
                    bestSim = sim;
                    bestKey = k;
                }
            });
            if (bestKey) {
                txEntry = txByDriver.get(bestKey);
                usedTxKeys.add(bestKey);
            }
        } else {
            usedTxKeys.add(txKey);
        }

        const totalCollected = txEntry ? txEntry.totalTarif : 0;
        const diff = txEntry ? Math.round(totalCollected - vd.totalGiven) : -vd.totalGiven;

        results.push({
            driver: vd.fio,
            car: vd.plate || '—',
            route: vd.route || '—',
            section: vd.section === 'city' ? 'Город' : 'Пригород',
            cashier: vd.cashier || '—',
            date: vd.vedomostDate || '—',
            given: Math.round(vd.totalGiven),
            collected: Math.round(totalCollected),
            diff: diff,
            txCount: txEntry ? txEntry.txCount : 0,
            status: diff === 0 ? 'ok' : (Math.abs(diff) <= 10 ? 'warn' : 'err')
        });
    });

    // Не сопоставленные транзакции
    txByDriver.forEach((entry, key) => {
        if (!usedTxKeys.has(key)) {
            unmatchedTx.push({
                driver: entry.conductor,
                plate: entry.plate || '—',
                totalCollected: Math.round(entry.totalTarif),
                txCount: entry.txCount
            });
        }
    });

    // 6. Агрегация по кассирам
    const cashierMap = new Map();
    results.forEach(r => {
        const key = r.cashier;
        if (!cashierMap.has(key)) {
            cashierMap.set(key, { cashier: key, count: 0, given: 0, collected: 0, diff: 0 });
        }
        const c = cashierMap.get(key);
        c.count++;
        c.given += r.given;
        c.collected += r.collected;
        c.diff += r.diff;
    });

    // 7. Агрегация по маршрутам
    const routeMap = new Map();
    results.forEach(r => {
        const key = r.route || 'Без маршрута';
        if (!routeMap.has(key)) {
            routeMap.set(key, { route: key, type: r.section, drivers: 0, sum: 0 });
        }
        const rm = routeMap.get(key);
        rm.drivers++;
        rm.sum += r.given;
    });

    // 8. Выводы
    const totalGiven = results.reduce((s, r) => s + r.given, 0);
    const totalCollected = results.reduce((s, r) => s + r.collected, 0);
    const totalDiff = results.reduce((s, r) => s + r.diff, 0);
    const discrepancies = results.filter(r => r.diff !== 0);

    return {
        drivers: results,
        cashiers: Array.from(cashierMap.values()),
        routes: Array.from(routeMap.values()),
        unmatchedTx,
        conclusions: {
            totalDrivers: results.length,
            totalGiven,
            totalCollected,
            totalDiff,
            discrepanciesCount: discrepancies.length,
            matchedPercent: results.length > 0
                ? Math.round((results.length - discrepancies.length) / results.length * 100)
                : 0
        }
    };
}

/* ================================================================
   ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ
   ================================================================ */

/**
 * Нормализовать дату к формату YYYY-MM-DD
 * @param {string} dateStr
 * @returns {string}
 */
function normalizeDate(dateStr) {
    if (!dateStr) return '';
    let d = String(dateStr).trim();
    // Excel serial date number
    const serial = parseInt(d);
    if (!isNaN(serial) && serial > 40000 && serial < 60000) {
        const date = new Date((serial - 25569) * 86400 * 1000);
        return date.toISOString().split('T')[0];
    }
    // DD.MM.YYYY or DD/MM/YYYY
    const parts = d.split(/[./-]/);
    if (parts.length === 3) {
        let day, month, year;
        if (parts[0].length === 4) {
            // YYYY-MM-DD
            year = parts[0]; month = parts[1]; day = parts[2];
        } else {
            // DD.MM.YYYY
            day = parts[0]; month = parts[1]; year = parts[2];
        }
        if (year.length === 2) year = '20' + year;
        return `${year}-${month.padStart(2, '0')}-${day.padStart(2, '0')}`;
    }
    return d;
}