#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
================================================================================
Модуль: Топливный калькулятор
================================================================================
Универсальный калькулятор для расчета топлива с двумя режимами рядом
================================================================================
"""

from PyQt5.QtWidgets import (
    QWidget, QVBoxLayout, QHBoxLayout, QLabel, 
    QLineEdit, QPushButton, QGroupBox, QGridLayout,
    QDoubleSpinBox, QSpinBox, QMessageBox, QFrame,
    QScrollArea, QMainWindow, QApplication, QFileDialog
)
from PyQt5.QtCore import Qt, QTimer
from PyQt5.QtGui import QColor, QBrush, QFont, QPixmap
from datetime import datetime

# Попытка импорта openpyxl для Excel
try:
    import openpyxl
    from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
    from openpyxl.utils import get_column_letter
    EXCEL_AVAILABLE = True
except ImportError:
    EXCEL_AVAILABLE = False


class FuelModule:
    """Класс модуля для ModuleManager"""
    
    display_name = "⛽ Топливный калькулятор"
    description = "Расчет топлива: прогноз и факт рядом"
    
    def __init__(self, main_window):
        self.main_window = main_window
        self.widget = None
        self.window = None
    
    def run(self):
        """Запуск модуля — открывает интерфейс в отдельном окне"""
        self.widget = FuelWidget(self.main_window, self)
        
        self.window = QMainWindow()
        self.window.setWindowTitle(f"{self.display_name} - РейсМастер")
        self.window.setWindowIcon(self.main_window.windowIcon())
        self.window.setCentralWidget(self.widget)
        self.window.resize(1100, 700)
        self.window.setMinimumSize(1000, 650)
        self.window.show()


class FuelWidget(QWidget):
    """Интерфейс топливного калькулятора с двумя блоками"""
    
    def __init__(self, main_window, module):
        super().__init__()
        self.main_window = main_window
        self.module = module
        
        # Данные для сохранения
        self.last_forecast = None
        self.last_fact = None
        self.last_result = ""
        self.last_params = None
        
        self.setup_ui()
        self.connect_signals()
        self.update_preview()
    
    def setup_ui(self):
        """Создание интерфейса"""
        main_layout = QVBoxLayout(self)
        main_layout.setContentsMargins(10, 10, 10, 10)
        main_layout.setSpacing(10)
        
        # Заголовок
        title_label = QLabel("⛽ ТОПЛИВНЫЙ КАЛЬКУЛЯТОР")
        title_label.setStyleSheet("""
            font-size: 26px;
            font-weight: bold;
            color: white;
            background-color: #1976D2;
            padding: 12px;
            border-radius: 8px;
            border: 2px solid #0D47A1;
        """)
        title_label.setAlignment(Qt.AlignCenter)
        main_layout.addWidget(title_label)
        
        # Два блока рядом
        blocks_layout = QHBoxLayout()
        blocks_layout.setSpacing(15)
        
        # === БЛОК 1: ПРОГНОЗ (СЛЕВА) ===
        forecast_group = QGroupBox("🔮 ПРОГНОЗ РАСХОДА")
        forecast_group.setStyleSheet("""
            QGroupBox {
                font-size: 16px;
                font-weight: bold;
                border: 3px solid #1976D2;
                border-radius: 10px;
                margin-top: 15px;
                padding-top: 20px;
                background-color: #E3F2FD;
            }
            QGroupBox::title {
                subcontrol-origin: margin;
                left: 15px;
                padding: 0 10px 0 10px;
                color: #1976D2;
            }
        """)
        forecast_layout = QVBoxLayout(forecast_group)
        forecast_layout.setSpacing(12)
        
        # Пояснение
        forecast_desc = QLabel("🔮 Сколько потратим на маршрут?")
        forecast_desc.setStyleSheet("color: #1976D2; font-size: 12px; font-style: italic;")
        forecast_desc.setAlignment(Qt.AlignCenter)
        forecast_layout.addWidget(forecast_desc)
        
        # Поля ввода
        grid_forecast = QGridLayout()
        grid_forecast.setVerticalSpacing(10)
        
        grid_forecast.addWidget(QLabel("📏 Расстояние:"), 0, 0)
        self.forecast_distance = QSpinBox()
        self.forecast_distance.setRange(1, 10000)
        self.forecast_distance.setValue(100)
        self.forecast_distance.setSuffix(" км")
        self.forecast_distance.setMinimumHeight(35)
        grid_forecast.addWidget(self.forecast_distance, 0, 1)
        
        grid_forecast.addWidget(QLabel("🛢️ Расход:"), 1, 0)
        self.forecast_consumption = QDoubleSpinBox()
        self.forecast_consumption.setRange(0, 100)
        self.forecast_consumption.setValue(30.0)
        self.forecast_consumption.setDecimals(1)
        self.forecast_consumption.setSuffix(" л/100км")
        self.forecast_consumption.setMinimumHeight(35)
        grid_forecast.addWidget(self.forecast_consumption, 1, 1)
        
        grid_forecast.addWidget(QLabel("💰 Цена:"), 2, 0)
        self.forecast_price = QDoubleSpinBox()
        self.forecast_price.setRange(0, 200)
        self.forecast_price.setValue(62.0)
        self.forecast_price.setDecimals(2)
        self.forecast_price.setPrefix("₽ ")
        self.forecast_price.setSuffix("/л")
        self.forecast_price.setMinimumHeight(35)
        grid_forecast.addWidget(self.forecast_price, 2, 1)
        
        forecast_layout.addLayout(grid_forecast)
        
        # Результат прогноза
        self.forecast_result = QLabel()
        self.forecast_result.setMinimumHeight(80)
        self.forecast_result.setStyleSheet("""
            background-color: white;
            border: 2px solid #1976D2;
            border-radius: 8px;
            padding: 10px;
            font-size: 14px;
        """)
        self.forecast_result.setAlignment(Qt.AlignCenter)
        forecast_layout.addWidget(self.forecast_result)
        
        blocks_layout.addWidget(forecast_group, 1)
        
        # === БЛОК 2: ФАКТ (СПРАВА) ===
        fact_group = QGroupBox("📊 ФАКТИЧЕСКИЙ РАСХОД")
        fact_group.setStyleSheet("""
            QGroupBox {
                font-size: 16px;
                font-weight: bold;
                border: 3px solid #2E7D32;
                border-radius: 10px;
                margin-top: 15px;
                padding-top: 20px;
                background-color: #E8F5E9;
            }
            QGroupBox::title {
                subcontrol-origin: margin;
                left: 15px;
                padding: 0 10px 0 10px;
                color: #2E7D32;
            }
        """)
        fact_layout = QVBoxLayout(fact_group)
        fact_layout.setSpacing(12)
        
        # Пояснение
        fact_desc = QLabel("📊 Сколько реально сожгли по чекам?")
        fact_desc.setStyleSheet("color: #2E7D32; font-size: 12px; font-style: italic;")
        fact_desc.setAlignment(Qt.AlignCenter)
        fact_layout.addWidget(fact_desc)
        
        # Поля ввода
        grid_fact = QGridLayout()
        grid_fact.setVerticalSpacing(10)
        
        grid_fact.addWidget(QLabel("⛽ Израсходовано:"), 0, 0)
        self.fact_liters = QDoubleSpinBox()
        self.fact_liters.setRange(0.1, 10000)
        self.fact_liters.setValue(100.0)
        self.fact_liters.setDecimals(1)
        self.fact_liters.setSuffix(" л")
        self.fact_liters.setMinimumHeight(35)
        grid_fact.addWidget(self.fact_liters, 0, 1)
        
        grid_fact.addWidget(QLabel("📏 Пробег:"), 1, 0)
        self.fact_distance = QSpinBox()
        self.fact_distance.setRange(1, 10000)
        self.fact_distance.setValue(100)
        self.fact_distance.setSuffix(" км")
        self.fact_distance.setMinimumHeight(35)
        grid_fact.addWidget(self.fact_distance, 1, 1)
        
        grid_fact.addWidget(QLabel("💰 Цена:"), 2, 0)
        self.fact_price = QDoubleSpinBox()
        self.fact_price.setRange(0, 200)
        self.fact_price.setValue(62.0)
        self.fact_price.setDecimals(2)
        self.fact_price.setPrefix("₽ ")
        self.fact_price.setSuffix("/л")
        self.fact_price.setMinimumHeight(35)
        grid_fact.addWidget(self.fact_price, 2, 1)
        
        grid_fact.addWidget(QLabel("📊 Норма:"), 3, 0)
        self.fact_norm = QDoubleSpinBox()
        self.fact_norm.setRange(0, 100)
        self.fact_norm.setValue(30.0)
        self.fact_norm.setDecimals(1)
        self.fact_norm.setSuffix(" л/100км")
        self.fact_norm.setMinimumHeight(35)
        grid_fact.addWidget(self.fact_norm, 3, 1)
        
        fact_layout.addLayout(grid_fact)
        
        # Результат факта
        self.fact_result = QLabel()
        self.fact_result.setMinimumHeight(100)
        self.fact_result.setStyleSheet("""
            background-color: white;
            border: 2px solid #2E7D32;
            border-radius: 8px;
            padding: 10px;
            font-size: 14px;
        """)
        self.fact_result.setAlignment(Qt.AlignCenter)
        fact_layout.addWidget(self.fact_result)
        
        blocks_layout.addWidget(fact_group, 1)
        
        main_layout.addLayout(blocks_layout)
        
        # === КНОПКИ ===
        btn_layout = QHBoxLayout()
        btn_layout.addStretch()
        
        # Кнопка расчета
        self.calc_btn = QPushButton("🧮 РАССЧИТАТЬ ВСЁ")
        self.calc_btn.setMinimumHeight(45)
        self.calc_btn.setMinimumWidth(200)
        self.calc_btn.setStyleSheet("""
            QPushButton {
                background-color: #1976D2;
                color: white;
                border: none;
                border-radius: 5px;
                font-size: 14px;
                font-weight: bold;
                padding: 10px 20px;
            }
            QPushButton:hover {
                background-color: #1565C0;
            }
        """)
        self.calc_btn.clicked.connect(self.calculate_all)
        btn_layout.addWidget(self.calc_btn)
        
        # Кнопка избранного
        self.fav_btn = QPushButton("⭐ В избранное")
        self.fav_btn.setMinimumHeight(40)
        self.fav_btn.setMinimumWidth(150)
        self.fav_btn.setStyleSheet("""
            QPushButton {
                background-color: #FFC107;
                color: #1a2a3a;
                border: none;
                border-radius: 5px;
                font-size: 12pt;
                font-weight: bold;
                padding: 8px 15px;
            }
            QPushButton:hover {
                background-color: #FFB300;
            }
        """)
        self.fav_btn.clicked.connect(self.add_to_favorites)
        btn_layout.addWidget(self.fav_btn)
        
        # Кнопка копирования в Max
        self.max_btn = QPushButton("📋 Копировать в Max")
        self.max_btn.setMinimumHeight(40)
        self.max_btn.setMinimumWidth(150)
        self.max_btn.setStyleSheet("""
            QPushButton {
                background-color: #00A3FF;
                color: white;
                border: none;
                border-radius: 5px;
                font-size: 12pt;
                font-weight: bold;
                padding: 8px 15px;
            }
            QPushButton:hover {
                background-color: #0090E0;
            }
        """)
        self.max_btn.clicked.connect(self.copy_to_max)
        btn_layout.addWidget(self.max_btn)
        
        # Кнопка экспорта в Excel
        self.excel_btn = QPushButton("📊 Экспорт в Excel")
        self.excel_btn.setMinimumHeight(40)
        self.excel_btn.setMinimumWidth(150)
        self.excel_btn.setStyleSheet("""
            QPushButton {
                background-color: #2E7D32;
                color: white;
                border: none;
                border-radius: 5px;
                font-size: 12pt;
                font-weight: bold;
                padding: 8px 15px;
            }
            QPushButton:hover {
                background-color: #1B5E20;
            }
        """)
        self.excel_btn.clicked.connect(self.export_to_excel)
        btn_layout.addWidget(self.excel_btn)
        
        main_layout.addLayout(btn_layout)
        
        # Информационная панель
        info_frame = QFrame()
        info_frame.setStyleSheet("""
            QFrame {
                background-color: #FFF9C4;
                border: 2px solid #FBC02D;
                border-radius: 8px;
                padding: 10px;
            }
        """)
        info_layout = QHBoxLayout(info_frame)
        
        info_icon = QLabel("💡")
        info_icon.setStyleSheet("font-size: 20px;")
        info_layout.addWidget(info_icon)
        
        info_text = QLabel(
            "🔮 Прогноз: сколько топлива и денег уйдет на маршрут\n"
            "📊 Факт: реальный расход по чекам (сравнение с нормой)"
        )
        info_text.setWordWrap(True)
        info_text.setStyleSheet("color: #1a2a3a; font-size: 10pt;")
        info_layout.addWidget(info_text, 1)
        
        main_layout.addWidget(info_frame)
    
    def connect_signals(self):
        """Подключение сигналов для предварительного просмотра"""
        # Прогноз
        self.forecast_distance.valueChanged.connect(self.update_preview)
        self.forecast_consumption.valueChanged.connect(self.update_preview)
        self.forecast_price.valueChanged.connect(self.update_preview)
        
        # Факт
        self.fact_liters.valueChanged.connect(self.update_preview)
        self.fact_distance.valueChanged.connect(self.update_preview)
        self.fact_price.valueChanged.connect(self.update_preview)
        self.fact_norm.valueChanged.connect(self.update_preview)
    
    def update_preview(self):
        """Обновляет предварительный просмотр"""
        # Прогноз
        dist_f = self.forecast_distance.value()
        cons = self.forecast_consumption.value()
        price_f = self.forecast_price.value()
        
        liters_f = dist_f * cons / 100
        cost_f = liters_f * price_f
        
        self.forecast_result.setText(
            f"⛽ Топливо: {liters_f:.1f} л\n"
            f"💰 Стоимость: {cost_f:,.2f} ₽"
        )
        
        # Факт
        liters = self.fact_liters.value()
        dist = self.fact_distance.value()
        price = self.fact_price.value()
        norm = self.fact_norm.value()
        
        if dist > 0:
            actual_cons = liters * 100 / dist
            cost = liters * price if price > 0 else 0
            
            result = f"📊 Расход: {actual_cons:.2f} л/100км\n"
            
            if norm > 0:
                diff = actual_cons - norm
                if diff > 0:
                    result += f"⚠️ Перерасход: +{diff:.2f} л/100км\n"
                elif diff < 0:
                    result += f"✅ Экономия: {abs(diff):.2f} л/100км\n"
                else:
                    result += f"✅ Точно по норме!\n"
            
            if cost > 0:
                result += f"💰 Потрачено: {cost:,.2f} ₽"
            
            self.fact_result.setText(result)
    
    def get_detailed_result(self):
        """Возвращает подробный результат для экспорта и копирования"""
        f = self.last_forecast
        fact = self.last_fact
        
        # Прогноз
        forecast_text = (
            f"🔮 ПРОГНОЗ РАСХОДА:\n"
            f"   📏 Расстояние: {f['distance']} км\n"
            f"   🛢️ Расход: {f['consumption']} л/100км\n"
            f"   💰 Цена: {f['price']} ₽/л\n"
            f"   ⛽ Топливо: {f['liters']:.1f} л\n"
            f"   💵 Стоимость: {f['cost']:,.2f} ₽"
        )
        
        # Факт
        fact_text = (
            f"📊 ФАКТИЧЕСКИЙ РАСХОД:\n"
            f"   ⛽ Израсходовано: {fact['liters']} л\n"
            f"   📏 Пробег: {fact['distance']} км\n"
            f"   📈 Расход: {fact['actual_consumption']:.2f} л/100км"
        )
        
        if fact['price'] > 0:
            fact_text += f"\n   💵 Потрачено: {fact['cost']:,.2f} ₽"
        
        if fact['norm'] > 0:
            diff = fact['actual_consumption'] - fact['norm']
            if diff > 0:
                fact_text += f"\n   ⚠️ Перерасход: +{diff:.2f} л/100км"
            elif diff < 0:
                fact_text += f"\n   ✅ Экономия: {abs(diff):.2f} л/100км"
            else:
                fact_text += f"\n   ✅ Точно по норме!"
        
        return forecast_text, fact_text
    
    def calculate_all(self):
        """Расчет всех значений и показ подробного результата"""
        try:
            # Сохраняем данные для прогноза
            dist_f = self.forecast_distance.value()
            cons = self.forecast_consumption.value()
            price_f = self.forecast_price.value()
            
            liters_f = dist_f * cons / 100
            cost_f = liters_f * price_f
            
            self.last_forecast = {
                "distance": dist_f,
                "consumption": cons,
                "price": price_f,
                "liters": liters_f,
                "cost": cost_f
            }
            
            # Сохраняем данные для факта
            liters = self.fact_liters.value()
            dist = self.fact_distance.value()
            price = self.fact_price.value()
            norm = self.fact_norm.value()
            
            actual_cons = liters * 100 / dist
            cost = liters * price if price > 0 else 0
            
            self.last_fact = {
                "liters": liters,
                "distance": dist,
                "price": price,
                "norm": norm,
                "actual_consumption": actual_cons,
                "cost": cost
            }
            
            self.last_params = {
                "forecast": self.last_forecast,
                "fact": self.last_fact
            }
            
            self.last_result = f"Прогноз: {cost_f:,.2f} ₽ | Факт: {actual_cons:.1f} л/100км"
            
            # Сохраняем в историю
            self.save_to_history()
            
            # Получаем подробный результат
            forecast_text, fact_text = self.get_detailed_result()
            
            # Показываем подробный результат
            QMessageBox.information(
                self,
                "ПОДРОБНЫЙ РЕЗУЛЬТАТ",
                f"{forecast_text}\n\n{fact_text}"
            )
            
        except Exception as e:
            QMessageBox.critical(self, "Ошибка", f"Ошибка при расчете: {str(e)}")
    
    def save_to_history(self):
        """Сохраняет расчет в историю"""
        if self.main_window and hasattr(self.main_window, 'history_manager') and self.last_params:
            calculation = {
                "id": datetime.now().strftime("%Y%m%d%H%M%S"),
                "date": datetime.now().strftime("%d.%m.%Y %H:%M"),
                "module": "⛽ Топливный калькулятор",
                "description": f"Прогноз: {self.last_forecast['liters']:.1f} л, Факт: {self.last_fact['actual_consumption']:.1f} л/100км",
                "result": self.last_result,
                "params": self.last_params
            }
            self.main_window.history_manager.add_to_history(calculation)
            if hasattr(self.main_window, 'favorites_widget'):
                self.main_window.favorites_widget.refresh()
    
    def add_to_favorites(self):
        """Добавляет расчет в избранное"""
        if not self.last_params:
            QMessageBox.warning(self, "Предупреждение", "Сначала выполните расчет!")
            return
        
        calculation = {
            "id": datetime.now().strftime("%Y%m%d%H%M%S"),
            "date": datetime.now().strftime("%d.%m.%Y %H:%M"),
            "module": "⛽ Топливный калькулятор",
            "description": f"Прогноз: {self.last_forecast['liters']:.1f} л, Факт: {self.last_fact['actual_consumption']:.1f} л/100км",
            "result": self.last_result,
            "params": self.last_params
        }
        
        if self.main_window and hasattr(self.main_window, 'history_manager'):
            if self.main_window.history_manager.add_to_favorites(calculation):
                QMessageBox.information(self, "Готово", "⭐ Расчет добавлен в избранное!")
                if hasattr(self.main_window, 'favorites_widget'):
                    self.main_window.favorites_widget.refresh()
            else:
                QMessageBox.information(self, "Инфо", "Этот расчет уже в избранном")
    
    def copy_to_max(self):
        """Копирует красивое сообщение в буфер обмена"""
        if not self.last_params:
            QMessageBox.warning(self, "Предупреждение", "Сначала выполните расчет!")
            return
        
        forecast_text, fact_text = self.get_detailed_result()
        
        message = f"""⛽ ТОПЛИВНЫЙ КАЛЬКУЛЯТОР - ПОДРОБНЫЙ РЕЗУЛЬТАТ

📅 Дата: {datetime.now().strftime('%d.%m.%Y %H:%M')}

{forecast_text}

{fact_text}

🔗 Код расчёта: {datetime.now().strftime('%Y%m%d%H%M%S')}
🌐 mirom.tech"""
        
        clipboard = QApplication.clipboard()
        clipboard.setText(message)
        
        QMessageBox.information(
            self,
            "Готово",
            "✅ Подробный результат скопирован в буфер обмена\nОткройте Max и вставьте (Ctrl+V)"
        )
    
    def export_to_excel(self):
        """Экспорт подробного расчета в Excel"""
        if not self.last_params:
            QMessageBox.warning(self, "Предупреждение", "Сначала выполните расчет!")
            return
        
        if not EXCEL_AVAILABLE:
            QMessageBox.warning(
                self,
                "Библиотека не установлена",
                "Для экспорта в Excel требуется библиотека openpyxl\n\nУстановите: pip install openpyxl"
            )
            return
        
        try:
            filename, _ = QFileDialog.getSaveFileName(
                self,
                "Сохранить расчет в Excel",
                f"fuel_calculation_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx",
                "Excel Files (*.xlsx)"
            )
            
            if not filename:
                return
            
            f = self.last_forecast
            fact = self.last_fact
            
            wb = openpyxl.Workbook()
            ws = wb.active
            ws.title = "Топливный расчет"
            
            # Стили
            title_font = Font(name='Arial', size=16, bold=True, color="FFFFFF")
            title_fill = PatternFill(start_color="1976D2", end_color="1976D2", fill_type="solid")
            subtitle_font = Font(name='Arial', size=14, bold=True, color="FFFFFF")
            forecast_fill = PatternFill(start_color="1976D2", end_color="1976D2", fill_type="solid")
            fact_fill = PatternFill(start_color="2E7D32", end_color="2E7D32", fill_type="solid")
            cell_font = Font(name='Arial', size=11)
            bold_font = Font(name='Arial', size=11, bold=True)
            center_align = Alignment(horizontal="center", vertical="center")
            left_align = Alignment(horizontal="left", vertical="center")
            right_align = Alignment(horizontal="right", vertical="center")
            border = Border(
                left=Side(style='thin'),
                right=Side(style='thin'),
                top=Side(style='thin'),
                bottom=Side(style='thin')
            )
            
            # Заголовок
            ws.merge_cells('A1:D1')
            title = ws['A1']
            title.value = "⛽ ТОПЛИВНЫЙ КАЛЬКУЛЯТОР - ПОДРОБНЫЙ РАСЧЕТ"
            title.font = title_font
            title.fill = title_fill
            title.alignment = center_align
            title.border = border
            
            # Дата
            ws.merge_cells('A2:D2')
            date_cell = ws['A2']
            date_cell.value = f"Дата расчета: {datetime.now().strftime('%d.%m.%Y %H:%M')}"
            date_cell.font = Font(name='Arial', size=10, italic=True)
            date_cell.alignment = right_align
            date_cell.border = border
            
            # Прогноз
            row = 4
            ws.merge_cells(f'A{row}:D{row}')
            forecast_title = ws[f'A{row}']
            forecast_title.value = "🔮 ПРОГНОЗ РАСХОДА"
            forecast_title.font = subtitle_font
            forecast_title.fill = forecast_fill
            forecast_title.alignment = center_align
            forecast_title.border = border
            
            row += 1
            forecast_data = [
                ("Расстояние:", f"{f['distance']} км"),
                ("Расход:", f"{f['consumption']} л/100км"),
                ("Цена:", f"{f['price']} ₽/л"),
                ("Топливо:", f"{f['liters']:.1f} л"),
                ("Стоимость:", f"{f['cost']:,.2f} ₽")
            ]
            
            for i, (label, value) in enumerate(forecast_data):
                ws[f'A{row+i}'] = label
                ws[f'A{row+i}'].font = bold_font
                ws[f'A{row+i}'].border = border
                ws[f'A{row+i}'].alignment = left_align
                
                ws[f'B{row+i}'] = value
                ws[f'B{row+i}'].font = cell_font
                ws[f'B{row+i}'].border = border
                ws[f'B{row+i}'].alignment = left_align
            
            # Факт
            row += len(forecast_data) + 2
            ws.merge_cells(f'A{row}:D{row}')
            fact_title = ws[f'A{row}']
            fact_title.value = "📊 ФАКТИЧЕСКИЙ РАСХОД"
            fact_title.font = subtitle_font
            fact_title.fill = fact_fill
            fact_title.alignment = center_align
            fact_title.border = border
            
            row += 1
            fact_data = [
                ("Израсходовано:", f"{fact['liters']} л"),
                ("Пробег:", f"{fact['distance']} км"),
            ]
            
            if fact['price'] > 0:
                fact_data.append(("Цена:", f"{fact['price']} ₽/л"))
                fact_data.append(("Потрачено:", f"{fact['cost']:,.2f} ₽"))
            
            fact_data.append(("Фактический расход:", f"{fact['actual_consumption']:.2f} л/100км"))
            
            if fact['norm'] > 0:
                diff = fact['actual_consumption'] - fact['norm']
                if diff > 0:
                    fact_data.append(("Отклонение от нормы:", f"+{diff:.2f} л/100км (перерасход)"))
                elif diff < 0:
                    fact_data.append(("Отклонение от нормы:", f"{diff:.2f} л/100км (экономия)"))
                else:
                    fact_data.append(("Отклонение от нормы:", "Точно по норме"))
            
            for i, (label, value) in enumerate(fact_data):
                ws[f'A{row+i}'] = label
                ws[f'A{row+i}'].font = bold_font
                ws[f'A{row+i}'].border = border
                ws[f'A{row+i}'].alignment = left_align
                
                ws[f'B{row+i}'] = value
                ws[f'B{row+i}'].font = cell_font
                ws[f'B{row+i}'].border = border
                ws[f'B{row+i}'].alignment = left_align
            
            # Итог
            row += len(fact_data) + 2
            ws.merge_cells(f'A{row}:D{row}')
            total_cell = ws[f'A{row}']
            total_cell.value = f"ИТОГО: Прогноз {f['cost']:,.2f} ₽ | Факт {fact['actual_consumption']:.2f} л/100км"
            total_cell.font = Font(name='Arial', size=12, bold=True)
            total_cell.border = border
            total_cell.alignment = center_align
            
            # Автоширина
            ws.column_dimensions['A'].width = 25
            ws.column_dimensions['B'].width = 25
            ws.column_dimensions['C'].width = 5
            ws.column_dimensions['D'].width = 5
            
            wb.save(filename)
            
            QMessageBox.information(
                self,
                "Готово",
                f"✅ Подробный расчет успешно экспортирован!\n\nФайл сохранен:\n{filename}"
            )
            
        except Exception as e:
            QMessageBox.critical(self, "Ошибка", f"Не удалось экспортировать:\n{str(e)}")