// pdfFillDataEntergy.js
const fs = require('fs');
const path = require('path');
const pdfFillData = require('./pdfFillData');
const { rgb, degrees } = require('pdf-lib');
const randomData = require('./randomDataGenerator');

class pdfFillDataEntergy extends pdfFillData {
    constructor() {
        super('Entergy');
        this.baselineCorrectionFactor = 0.85;

        // Инициализация всех свойств, которые будут использоваться
        this.customer_name = '';
        this.mail_date = '';
        this.account_number = '';
        this.invoice_number = '';
        this.amount_due_by_date = '';
        this.amount_due_after_date = '';
        this.amount_due_after_value = '';
        this.service_location_line1 = '';
        this.service_location_line2 = '';
        this.billing_days = '';
        this.kwh_used = '';
        this.kwh_used_formatted = '';
        this.avg_kwh_per_day = '';
        this.remit_customer_address = '';
        this.barcode_number = '';
        this.usage_history_data = [];

        // Расчетные свойства для диаграмм и итогов
        this.energy_charges_total = 0;
        this.fuel_charges_total = 0;
        this.other_charges_total = 0;
        this.amount_due_by_value = 0;

        // Свойства для купона
        this.remit_account_number = '';
        this.remit_invoice_number = '';
        this.remit_amount_due_by_date = '';
        this.remit_amount_due_after_date = '';
        this.remit_amount_due_by_value = '';

        this.energy_charge = '';
        this.federal_eac_rider = '';
        this.fuel_adjustment = '';
        this.storm_restoration_offset = '';
        this.storm_restoration_charge = '';
        this.deposit = '';
        this.connect_fee = '';
        this.current_month_energy_charges = 0;

        // Расчетные поля для детализации kWh
        this.federal_eac_rider_detail = '';
        this.fuel_adjustment_detail = '';

        // --- НОВЫЕ СВОЙСТВА ДЛЯ METER READING ---
        this.meter_reading_contract = '';
        this.meter_number = '';
        this.meter_rate = '';
        this.current_meter_reading_datetime = '';
        this.current_meter_reading_value = '';
        this.previous_meter_reading_datetime = '';
        this.previous_meter_reading_value = '';

        // --- НОВЫЕ СВОЙСТВА ДЛЯ ГОТОВЫХ СТРОК ---
        this.meter_reading_header = '';
        this.meter_number_header = '';
        this.rate_header = '';
        this.current_reading_text = '';
        this.previous_reading_text = '';

        this.chart_legend_year_current = '';  // e.g., "2023"
        this.chart_legend_year_previous = ''; // e.g., "2022"

        this.billing_period_formatted = '';

        this.qpc_code = '';
        this.cycle_number = '';
    }

    /**
     * Вспомогательная функция для очистки денежных строк от '$' и запятых
     * @param {string} amount - Строка с суммой
     * @returns {number} - Числовое значение
     */
    _cleanAmount(amount) {
        if (typeof amount !== 'string') return 0;
        return parseFloat(amount.replace(/[^0-9.-]+/g, '')) || 0;
    }

    /**
     * Заполняет свойства класса данными из запроса и выполняет расчеты
     * @param {object} fields - Объект с данными из POST-запроса
     */
    async setFields(fields) {
        if (!fields || Object.keys(fields).length === 0) {
            fields = randomData.entergy(); // <-- Замените на entergy(), aep_ohio() и т.д.
        }
        // --- Получаем данные из формы ---
        this.customer_name = fields.customer_name;
        this.mail_date = fields.mail_date;
        this.account_number = fields.account_number;
        this.invoice_number = fields.invoice_number;
        this.amount_due_by_date = fields.amount_due_by_date;
        this.amount_due_after_date = fields.amount_due_after_date;
        this.amount_due_after_value = fields.amount_due_after_value;
        this.service_location_line1 = fields.service_location_line1;
        this.service_location_line2 = fields.service_location_line2;
        this.billing_days = fields.billing_days;
        this.kwh_used = fields.kwh_used;
        this.avg_kwh_per_day = fields.avg_kwh_per_day;
        this.remit_customer_address = fields.remit_customer_address;
        this.barcode_number = fields.barcode_number;
        this.usage_history_data = fields.usage_history_data || [];

        // --- Детализация для расчетов ---
        const energy_charge = this.energy_charge = this._cleanAmount(fields.energy_charge);
        const federal_eac_rider = this.federal_eac_rider = this._cleanAmount(fields.federal_eac_rider);
        const fuel_adjustment = this._cleanAmount(fields.fuel_adjustment);
        const storm_restoration_offset = this.storm_restoration_offset = this._cleanAmount(fields.storm_restoration_offset);
        const storm_restoration_charge = this.storm_restoration_charge = this._cleanAmount(fields.storm_restoration_charge);
        const deposit = this.deposit = this._cleanAmount(fields.deposit);
        const connect_fee = this.connect_fee = this._cleanAmount(fields.connect_fee);

        // --- Выполняем расчеты ---
        this.energy_charges_total = energy_charge + federal_eac_rider;
        this.fuel_charges_total = fuel_adjustment;
        this.other_charges_total = storm_restoration_offset + storm_restoration_charge;

        const current_month_energy_charges = this.energy_charges_total + this.fuel_charges_total + this.other_charges_total;
        this.current_month_energy_charges = current_month_energy_charges.toFixed(2);
        this.amount_due_by_value = current_month_energy_charges + deposit + connect_fee;

        // --- Подготовка данных для отображения ---
        this.remit_account_number = this.account_number;
        this.remit_invoice_number = this.invoice_number;
        this.remit_amount_due_by_date = this.amount_due_by_date;
        this.remit_amount_due_after_date = this.amount_due_after_date;
        this.remit_amount_due_by_value = `${this.amount_due_by_value.toFixed(2)}`;
        this.kwh_used_formatted = (this._cleanAmount(this.kwh_used)).toLocaleString('en-US');

        // --- ОБРАБОТКА ДАННЫХ ДЛЯ METER READING ---
        this.meter_reading_header = fields.meter_reading_contract;
        this.meter_number_header = fields.meter_number;
        this.rate_header = fields.meter_rate;
        this.current_reading_text = fields.current_meter_reading_datetime;
        this.current_meter_reading_value = fields.current_meter_reading_value;
        this.previous_reading_text = fields.previous_meter_reading_datetime;
        this.previous_meter_reading_value = fields.previous_meter_reading_value;

        const kwhUsedNum = this._cleanAmount(this.kwh_used);

        if (kwhUsedNum > 0) {
            const federalEACRate = (federal_eac_rider / kwhUsedNum).toFixed(8);
            this.federal_eac_rider_detail = `${this.kwh_used_formatted} kWh @ ${federalEACRate}`;

            const fuelAdjustmentRate = (fuel_adjustment / kwhUsedNum).toFixed(8);
            this.fuel_adjustment_detail = `${this.kwh_used_formatted} kWh @ ${fuelAdjustmentRate}`;
        } else {
            this.federal_eac_rider_detail = '';
            this.fuel_adjustment_detail = '';
        }

        const billDate = new Date(this.mail_date);
        if (!isNaN(billDate.getTime())) { // Проверяем, что дата валидная
            const currentYear = billDate.getFullYear();
            this.chart_legend_year_current = String(currentYear);
            this.chart_legend_year_previous = String(currentYear - 1);
        } else {
            // Если дата невалидная, используем запасные значения
            console.warn(`Invalid mail_date format: "${this.mail_date}". Could not determine years for chart legend.`);
            this.chart_legend_year_current = '2023';
            this.chart_legend_year_previous = '2022';
        }

        const billDateForPeriod = new Date(this.mail_date);
        if (!isNaN(billDateForPeriod.getTime())) {
            // toLocaleString с опциями - лучший способ получить название месяца
            const month = billDateForPeriod.toLocaleString('en-US', { month: 'short' }); // "Jun"
            const year = billDateForPeriod.getFullYear(); // 2023
            this.billing_period_formatted = `${month} ${year}`;
        } else {
            // Запасное значение, если дата некорректна
            this.billing_period_formatted = 'Jun 2023';
        }

        this.qpc_code = fields.qpc_code;
        this.cycle_number = fields.cycle_number;
    }

    _describeArc(x, y, radius, startAngle, endAngle) {
        const startRad = (startAngle - 90) * Math.PI / 180;
        const endRad = (endAngle - 90) * Math.PI / 180;
        const start = { x: x + (radius * Math.cos(startRad)), y: y + (radius * Math.sin(startRad)) };
        const end = { x: x + (radius * Math.cos(endRad)), y: y + (radius * Math.sin(endRad)) };
        const largeArcFlag = endAngle - startAngle <= 180 ? "0" : "1";
        const d = ["M", start.x, start.y, "A", radius, radius, 0, largeArcFlag, 1, end.x, end.y].join(" ");
        return d;
    }
    
    _getFieldValue(item) {
        if (!item || typeof item.field !== 'string') {
            return '';
        }
        const fieldKey = item.field;
        const parts = fieldKey.split(',').map(p => p.trim());

        // Шаг 1: Преобразуем каждую часть в ее конечное значение
        // (статический текст, значение переменной или символ переноса строки)
        const resolvedParts = parts.map(part => {
            if (part === '[NEWLINE]') {
                return '\n'; // Наш маркер становится реальным переносом
            }
            // this[part] находит свойство класса по имени, например, this['remit_amount_due_by_date']
            if (this[part] !== undefined && this[part] !== null) {
                return this[part]; // Возвращаем значение переменной
            }
            return part; // Возвращаем статический текст как есть
        });

        // Шаг 2: Грамотно склеиваем части в одну строку
        let finalString = '';
        for (let i = 0; i < resolvedParts.length; i++) {
            const currentPart = resolvedParts[i];

            // Если текущая часть - это перенос строки, просто добавляем ее и переходим к следующей
            if (currentPart === '\n') {
                finalString += '\n';
                continue;
            }

            // Добавляем пробел, только если это НЕ первая часть в строке
            // И если ПРЕДЫДУЩАЯ часть не была переносом строки
            if (i > 0 && resolvedParts[i - 1] !== '\n') {
                finalString += ' ';
            }
            
            finalString += currentPart;
        }

        return finalString;
    }
    
    _evaluate(expression, constants) {
        if (typeof expression === 'number') return expression;
        if (typeof expression !== 'string') return NaN;
        const formula = expression.replace(/[a-zA-Z_][a-zA-Z0-9_]*/g, match => constants[match] !== undefined ? constants[match] : '0');
        try {
            return new Function(`return ${formula}`)();
        } catch (e) { return NaN; }
    }

    async _drawUsageBarChart(page, pageHeight) {
        const usageData = this.usage_history_data;
        if (!usageData || usageData.length === 0) return;

        // Параметры области графика (ВАЖНО: ИЗМЕРЬТЕ ИХ В ILLUSTRATOR)
        const chartArea = {
            x_ill: 87, y_ill: 310, width: 440, height: 80
        };
        const maxKwh = Math.max(...usageData.map(d => d.kwh));
        if (maxKwh === 0) return;

        const barWidth = (chartArea.width / usageData.length) * 0.7;
        const barMargin = (chartArea.width / usageData.length) * 0.3;
        const stepX = barWidth + barMargin;
        const grayColor = rgb(235 / 255, 235 / 255, 235 / 255);
        const blackColor = rgb(0, 0, 0);

        usageData.forEach((dataPoint, index) => {
            if (dataPoint.kwh > 0) { // Рисуем только столбцы с потреблением > 0
                const barHeight = (dataPoint.kwh / maxKwh) * chartArea.height;
                const barX = chartArea.x_ill + (index * stepX);
                const baseY = pageHeight - chartArea.y_ill - chartArea.height;
                
                page.drawRectangle({
                    x: barX, y: baseY, width: barWidth, height: barHeight, color: (index === 5) ? blackColor : grayColor // Июнь (6-й элемент) - черный
                });
            }
        });
    }

    async _drawUsageBarChart(page, pageHeight, constants) {
        const usageData = this.usage_history_data;
        if (!usageData || usageData.length === 0) return;

        // --- 1. Читаем параметры из констант ---
        const chartArea = {
            x_ill: this._evaluate(constants.bar_chart_x_ill, constants),
            y_ill: this._evaluate(constants.bar_chart_y_ill, constants),
            width: this._evaluate(constants.bar_chart_width, constants),
            height: this._evaluate(constants.bar_chart_height, constants)
        };
        const currentMonthIndex = this._evaluate(constants.bar_chart_current_month_index, constants);
        const labelYOffset = this._evaluate(constants.bar_chart_label_y_offset, constants);
        const labelFontSize = this._evaluate(constants.bar_chart_label_font_size, constants);
        const labelFontIndex = this._evaluate(constants.bar_chart_label_ifont, constants); // <--- ЧИТАЕМ ИНДЕКС ШРИФТА
        const barWidthRatio = this._evaluate(constants.bar_chart_bar_width_ratio, constants); // <--- ЧИТАЕМ ШИРИНУ СТОЛБЦА

        const defaultBarColor = rgb(
            this._evaluate(constants.color_bar_default_r, constants),
            this._evaluate(constants.color_bar_default_g, constants),
            this._evaluate(constants.color_bar_default_b, constants)
        );
        const currentBarColor = rgb(
            this._evaluate(constants.color_bar_current_r, constants),
            this._evaluate(constants.color_bar_current_g, constants),
            this._evaluate(constants.color_bar_current_b, constants)
        );

        if (Object.values(chartArea).some(isNaN) || [currentMonthIndex, labelYOffset, labelFontSize, labelFontIndex, barWidthRatio].some(isNaN)) {
            console.error("Could not evaluate all bar chart constants from map.json.");
            return;
        }

        // --- 2. Выполняем расчеты ---
        const maxKwh = Math.max(...usageData.map(d => d.kwh).filter(k => k > 0));
        if (maxKwh <= 0) return;
        
        // Общее пространство на один столбец
        const spacePerBar = chartArea.width / usageData.length;
        // Ширина столбца теперь вычисляется на основе коэффициента
        const barWidth = spacePerBar * barWidthRatio; // <--- ИСПОЛЬЗУЕМ КОЭФФИЦИЕНТ
        
        // --- 3. Рисуем столбцы ---
        usageData.forEach((dataPoint, index) => {
            if (dataPoint.kwh > 0) {
                const barHeight_pdf = (dataPoint.kwh / maxKwh) * chartArea.height;
                // Центрируем столбец внутри его пространства
                const barX_pdf = chartArea.x_ill + (index * spacePerBar) + ((spacePerBar - barWidth) / 2);
                const baseY_pdf = pageHeight - chartArea.y_ill - chartArea.height;
                
                const color = (index === currentMonthIndex) ? currentBarColor : defaultBarColor;

                page.drawRectangle({
                    x: barX_pdf, y: baseY_pdf, width: barWidth, height: barHeight_pdf, color: color,
                });
            }
        });
        
        // --- 4. Рисуем подписи месяцев ---
        const textFont = this.getCustomerFontByIndex(labelFontIndex); // <--- ИСПОЛЬЗУЕМ ИНДЕКС ШРИФТА
        if (!textFont) {
            console.error(`Font with index ${labelFontIndex} not found for bar chart labels.`);
            return;
        }

        usageData.forEach((dataPoint, index) => {
            // Центрируем подпись внутри пространства столбца
            const labelX_center = chartArea.x_ill + (index * spacePerBar) + (spacePerBar / 2);
            const baseY_pdf = pageHeight - chartArea.y_ill - chartArea.height;
            const monthText = dataPoint.month;
            const textWidth = textFont.widthOfTextAtSize(monthText, labelFontSize);

            page.drawText(monthText, {
                x: labelX_center - (textWidth / 2), // Центрируем текст относительно labelX_center
                y: baseY_pdf - labelYOffset,
                font: textFont,
                size: labelFontSize,
                color: rgb(0, 0, 0)
            });
        });
    }

    async _drawChargesDonutChart(page, pageHeight, chartConfig) {
        // --- ПРОВЕРКА, ЧТО КОНФИГ ДИАГРАММЫ СУЩЕСТВУЕТ ---
        if (!chartConfig || !chartConfig.constants || !chartConfig.segments) {
            console.error("Donut chart configuration is missing or invalid in map.json.");
            return;
        }
        const { constants, segments } = chartConfig;

        // --- Преобразуем описание секторов из JSON в массив с реальными значениями ---
        const charges = segments.map(segment => {
            // --- ИЗМЕНЕНИЕ ЗДЕСЬ ---
            // Вычисляем каждый компонент цвета, используя _evaluate
            const r = this._evaluate(segment.color[0], constants);
            const g = this._evaluate(segment.color[1], constants);
            const b = this._evaluate(segment.color[2], constants);

            return {
                value: this[segment.value_field] || 0,
                color: rgb(r, g, b), // Создаем цвет из вычисленных значений
                label: segment.label
            }
        });

        const totalCharges = charges.reduce((sum, c) => sum + c.value, 0);
        if (totalCharges <= 0) return;

        // --- Читаем параметры из констант ---
        const centerX_ill = this._evaluate(constants.donut_chart_center_x_ill, constants);
        const centerY_ill = this._evaluate(constants.donut_chart_center_y_ill, constants);
        const radius      = this._evaluate(constants.donut_chart_radius, constants);
        const thickness   = this._evaluate(constants.donut_chart_thickness, constants);

        if (isNaN(centerX_ill) || isNaN(centerY_ill) || isNaN(radius) || isNaN(thickness)) {
            console.error("Could not evaluate donut chart constants from map.json.");
            return;
        }
        
        const centerX_pdf = centerX_ill;
        const centerY_pdf = pageHeight - centerY_ill;
        const centerY_for_svg = pageHeight - centerY_pdf;
        
        let startAngle = 0;
        for (const charge of charges) {
            if (charge.value <= 0) continue;
            const sweepAngle = (charge.value / totalCharges) * 360;
            if (sweepAngle <= 0) continue;
            
            const endAngle = startAngle + sweepAngle;
            const arcPath = this._describeArc(centerX_pdf, centerY_for_svg, radius, startAngle, endAngle);
            
            if (!arcPath.includes('NaN')) {
                page.drawSvgPath(arcPath, { y: pageHeight, borderColor: charge.color, borderWidth: thickness });
            }
            startAngle = endAngle;
        }
    }

    async drawFancyAmount(item, constants) {
        const page = this.getPageByIndex(item.ipage);
        const font = this.getCustomerFontByIndex(item.ifont);
        if (!page || !font) return;
        
        // --- Получаем и вычисляем параметры ---
        const pageHeight = this.getPageHeight(item.ipage);
        const amountText = `${this._getFieldValue(item) || '0.00'}`;
        const x_ill_end = this._evaluate(item.x_ill, constants); // x_ill - это ПРАВЫЙ край
        const y_ill = this._evaluate(item.y_ill, constants);
        const mainSize = this._evaluate(item.size, constants);
        
        // --- Размеры для разных частей ---
        const dollarSignSize = mainSize * 0.7; // '$' будет 70% от основного размера
        const centsSize = mainSize * 0.6;      // Центы будут 60% от основного размера

        // --- Разбираем сумму на части ---
        const parts = amountText.split('.');
        const dollars = parts[0] || '0';
        const cents = parts.length > 1 ? parts[1] : '00';

        // --- Вычисляем ширину каждой части, чтобы выровнять по правому краю ---
        const centsWidth = font.widthOfTextAtSize(cents, centsSize);
        const dollarsWidth = font.widthOfTextAtSize(dollars, mainSize);
        const dollarSignWidth = font.widthOfTextAtSize('$', dollarSignSize);

        // --- Вычисляем Y-координаты ---
        // Базовая Y-координата для долларов (основной текст)
        const y_pdf_dollars = pageHeight - y_ill - (mainSize * this.baselineCorrectionFactor);
        // Y-координата для центов (поднимаем их выше)
        const y_pdf_cents = y_pdf_dollars + (mainSize - centsSize) * 0.7;
        // Y-координата для знака доллара (чуть ниже центра)
        const y_pdf_dollarSign = y_pdf_cents - 3;

        // --- Вычисляем X-координаты (от правого края) ---
        const x_pdf_cents_start = x_ill_end - centsWidth;
        const x_pdf_dollars_start = x_pdf_cents_start - dollarsWidth;
        const x_pdf_dollarSign_start = x_pdf_dollars_start - dollarSignWidth - (mainSize * 0.1); // Небольшой отступ

        // --- Рисуем части ---
        const r = 0, g = 0, b = 0; // Черный цвет

        // 1. Рисуем центы
        await super.draw(item.ipage, cents, x_pdf_cents_start, y_pdf_cents, centsSize, item.ifont, r, g, b);
        
        // 2. Рисуем доллары
        await super.draw(item.ipage, dollars, x_pdf_dollars_start, y_pdf_dollars, mainSize, item.ifont, r, g, b);

        // 3. Рисуем знак доллара
        await super.draw(item.ipage, '$', x_pdf_dollarSign_start, y_pdf_dollarSign, dollarSignSize, item.ifont, r, g, b);
    }

    async draw() {
        // 1. Загружаем полный конфиг из JSON
        const mapFilePath = path.join(__dirname, 'Entergy.map.json');
        const configJson = fs.readFileSync(mapFilePath, 'utf8');
        const config = JSON.parse(configJson);
        const { constants, donut_chart_segments, map: dataMap } = config;

        // 2. Создаем специальный объект с конфигом для диаграммы
        const donutChartConfig = {
            constants: constants,
            segments: donut_chart_segments
        };

        // 3. Рисуем сложную графику, передавая ей нужные части конфига
        await this._drawUsageBarChart(this.pages[0], this.getPageHeight(0), constants);
        await this._drawChargesDonutChart(this.pages[0], this.getPageHeight(0), donutChartConfig);

        // 4. Рисуем текстовые поля на основе dataMap
        for (const item of dataMap) {
            
            // --- ПРОВЕРКИ НА КАСТОМНЫЕ МЕТОДЫ ---
            
            // Вызываем специальный метод для "красивой" суммы
            if (item.draw_method === 'drawFancyAmount') {
                await this.drawFancyAmount(item, constants);
                continue; // Пропускаем остальную часть цикла для этого элемента
            }
            
            // Вызываем специальный метод для строк с тегами <style>
            if (typeof item.field === 'string' && item.field.includes('<style')) {
                await this.drawStyledText(item, constants);
                continue;
            }
            
            // --- СТАНДАРТНАЯ ЛОГИКА ДЛЯ ОБЫЧНЫХ ПОЛЕЙ ---
            
            const page = this.getPageByIndex(item.ipage);
            const font = this.getCustomerFontByIndex(item.ifont);
            if (!page || !font) {
                console.warn(`Skipping draw: Missing page or font for item:`, item);
                continue;
            }
            
            const pageHeight = this.getPageHeight(item.ipage);
            const fieldText = `${this._getFieldValue(item) || ''}`;
            
            const x_ill = this._evaluate(item.x_ill, constants);
            const y_ill = this._evaluate(item.y_ill, constants);
            const size = this._evaluate(item.size, constants);
            const lineHeight = this._evaluate(item.lineHeight, constants);
            
            if (isNaN(x_ill) || isNaN(y_ill) || isNaN(size)) {
                console.warn('Could not evaluate coordinates/size for item:', item);
                continue;
            }
            
            const y_pdf = pageHeight - y_ill - (size * this.baselineCorrectionFactor);
            const r = this._evaluate(item.cR, constants) || 0;
            const g = this._evaluate(item.cG, constants) || 0;
            const b = this._evaluate(item.cB, constants) || 0;
            const textColor = rgb(r, g, b);

            const textLines = fieldText.split('\n');
            let currentY = y_pdf;
            const effectiveLineHeight = (typeof lineHeight === 'number' && lineHeight > 0) ? lineHeight : (size * 1.2);
            
            const bgColorArray = item.bgColor;
            const hasBackground = Array.isArray(bgColorArray) && bgColorArray.length === 3;
            
            let bgColor = null;
            if (hasBackground) {
                const bg_r = this._evaluate(bgColorArray[0], constants);
                const bg_g = this._evaluate(bgColorArray[1], constants);
                const bg_b = this._evaluate(bgColorArray[2], constants);
                bgColor = rgb(bg_r, bg_g, bg_b);
            }

            for (const line of textLines) {
                let x_pdf;
                
                // Вычисляем X-координату для КАЖДОЙ строки индивидуально
                if (item.align === 'right') {
                    const pageWidth = this.getPageWidth(item.ipage);
                    const rightMargin_pdf = pageWidth - x_ill;
                    x_pdf = await this.alignTextToRight(item.ipage, item.ifont, size, rightMargin_pdf, line);
                } else if (item.align === 'center') {
                    const textWidth = font.widthOfTextAtSize(line, size);
                    x_pdf = x_ill - (textWidth / 2);
                } else {
                    x_pdf = x_ill;
                }

                // Выбираем, какой метод отрисовки использовать
                if (hasBackground) {
                    await this.drawTextWithBackground(item.ipage, line, x_pdf, currentY, size, item.ifont, textColor, bgColor);
                } else {
                    await super.draw(item.ipage, line, x_pdf, currentY, size, item.ifont, r, g, b);
                }
                
                // Смещаем Y для следующей строки
                currentY -= effectiveLineHeight;
            }
        }
    }

}

module.exports = pdfFillDataEntergy;