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

"""
================================================================================
Модуль: Логистический конструктор
================================================================================
Сравнение четырёх методик расчёта стоимости перевозки
================================================================================
"""

from PyQt5.QtWidgets import (
    QWidget, QVBoxLayout, QHBoxLayout, QLabel, 
    QLineEdit, QPushButton, QGroupBox, QGridLayout,
    QSpinBox, QDoubleSpinBox, QTableWidget, QTableWidgetItem,
    QHeaderView, QMessageBox, QScrollArea, QFrame, QMainWindow,
    QApplication, QFileDialog
)
from PyQt5.QtCore import Qt, QTimer
from PyQt5.QtGui import QColor, QBrush, QFont, QClipboard
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 LogisticModule:
    """Класс модуля для 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 = LogisticWidget(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, 850)
        self.window.show()


class LogisticWidget(QWidget):
    """Интерфейс калькулятора Логистический конструктор"""
    
    def __init__(self, main_window, module):
        super().__init__()
        self.main_window = main_window
        self.module = module
        self.last_result = ""
        self.last_params = None
        self.setup_ui()
        self.connect_signals()
        self.update_preview()
    
    def load_calculation(self, calculation: dict):
        """Загружает сохраненный расчет в поля"""
        params = calculation.get('params', {})
        if not params:
            return
        
        try:
            # Маршрут
            self.point_a_edit.setText(params.get('point_a', ''))
            self.point_b_edit.setText(params.get('point_b', ''))
            
            # Расстояние
            distance = params.get('distance', 700)
            if isinstance(distance, float):
                distance = int(distance)
            self.distance_spin.setValue(distance)
            
            # Вес
            self.weight_spin.setValue(float(params.get('weight', 20)))
            
            # Время
            hours = params.get('hours', 12)
            if isinstance(hours, float):
                hours = int(hours)
            self.hours_spin.setValue(hours)
            
            # Расценки
            self.rate_ton_spin.setValue(float(params.get('rate_ton', 1500)))
            self.rate_tkm_spin.setValue(float(params.get('rate_tkm', 3.50)))
            self.rate_hourly_spin.setValue(float(params.get('rate_hourly', 800)))
            self.rate_km_spin.setValue(float(params.get('rate_km', 45)))
            
            # Запускаем расчет
            self.calculate()
            
        except Exception as e:
            print(f"Ошибка загрузки расчета: {e}")
    
    def setup_ui(self):
        """Создание интерфейса"""
        main_layout = QVBoxLayout(self)
        main_layout.setContentsMargins(0, 0, 0, 0)
        
        scroll_area = QScrollArea()
        scroll_area.setWidgetResizable(True)
        scroll_area.setFrameShape(QFrame.NoFrame)
        
        scroll_content = QWidget()
        scroll_layout = QVBoxLayout(scroll_content)
        scroll_layout.setSpacing(10)
        scroll_layout.setContentsMargins(10, 10, 10, 10)
        
        # === БЛОК 1: ПАРАМЕТРЫ МАРШРУТА ===
        route_group = QGroupBox("📦 ПАРАМЕТРЫ МАРШРУТА")
        route_group.setStyleSheet("""
            QGroupBox {
                font-size: 14px;
                font-weight: bold;
                border: 2px solid #c0c0c0;
                border-radius: 8px;
                margin-top: 10px;
                padding-top: 15px;
            }
            QGroupBox::title {
                subcontrol-origin: margin;
                left: 15px;
                padding: 0 10px 0 10px;
            }
        """)
        route_layout = QGridLayout(route_group)
        
        route_layout.addWidget(QLabel("Точка А:"), 0, 0)
        self.point_a_edit = QLineEdit("Москва")
        self.point_a_edit.setMinimumHeight(30)
        route_layout.addWidget(self.point_a_edit, 0, 1)
        
        route_layout.addWidget(QLabel("Точка Б:"), 0, 2)
        self.point_b_edit = QLineEdit("Санкт-Петербург")
        self.point_b_edit.setMinimumHeight(30)
        route_layout.addWidget(self.point_b_edit, 0, 3)
        
        route_layout.addWidget(QLabel("Расстояние (км):"), 1, 0)
        self.distance_spin = QSpinBox()
        self.distance_spin.setRange(1, 10000)
        self.distance_spin.setValue(700)
        self.distance_spin.setSuffix(" км")
        self.distance_spin.setMinimumHeight(30)
        route_layout.addWidget(self.distance_spin, 1, 1)
        
        route_layout.addWidget(QLabel("Вес груза (т):"), 1, 2)
        self.weight_spin = QDoubleSpinBox()
        self.weight_spin.setRange(0.1, 100)
        self.weight_spin.setValue(20.0)
        self.weight_spin.setSuffix(" т")
        self.weight_spin.setDecimals(1)
        self.weight_spin.setMinimumHeight(30)
        route_layout.addWidget(self.weight_spin, 1, 3)
        
        route_layout.addWidget(QLabel("Время в пути (ч):"), 2, 0)
        self.hours_spin = QSpinBox()
        self.hours_spin.setRange(1, 168)
        self.hours_spin.setValue(12)
        self.hours_spin.setSuffix(" ч")
        self.hours_spin.setMinimumHeight(30)
        route_layout.addWidget(self.hours_spin, 2, 1)
        
        scroll_layout.addWidget(route_group)
        
        # === БЛОК 2: РАСЦЕНКИ ===
        rates_group = QGroupBox("💰 РАСЦЕНКИ (заполните те, которые хотите сравнить)")
        rates_group.setStyleSheet(route_group.styleSheet())
        rates_layout = QGridLayout(rates_group)
        
        rates_layout.addWidget(QLabel("За тонну:"), 0, 0)
        self.rate_ton_spin = QDoubleSpinBox()
        self.rate_ton_spin.setRange(0, 10000)
        self.rate_ton_spin.setValue(1500)
        self.rate_ton_spin.setSuffix(" ₽/т")
        self.rate_ton_spin.setDecimals(2)
        self.rate_ton_spin.setMinimumHeight(30)
        rates_layout.addWidget(self.rate_ton_spin, 0, 1)
        
        rates_layout.addWidget(QLabel("За тонно-км:"), 0, 2)
        self.rate_tkm_spin = QDoubleSpinBox()
        self.rate_tkm_spin.setRange(0, 100)
        self.rate_tkm_spin.setValue(3.50)
        self.rate_tkm_spin.setSuffix(" ₽/т/км")
        self.rate_tkm_spin.setDecimals(2)
        self.rate_tkm_spin.setMinimumHeight(30)
        rates_layout.addWidget(self.rate_tkm_spin, 0, 3)
        
        rates_layout.addWidget(QLabel("Почасовая:"), 1, 0)
        self.rate_hourly_spin = QDoubleSpinBox()
        self.rate_hourly_spin.setRange(0, 5000)
        self.rate_hourly_spin.setValue(800)
        self.rate_hourly_spin.setSuffix(" ₽/ч")
        self.rate_hourly_spin.setDecimals(2)
        self.rate_hourly_spin.setMinimumHeight(30)
        rates_layout.addWidget(self.rate_hourly_spin, 1, 1)
        
        rates_layout.addWidget(QLabel("За километр:"), 1, 2)
        self.rate_km_spin = QDoubleSpinBox()
        self.rate_km_spin.setRange(0, 500)
        self.rate_km_spin.setValue(45)
        self.rate_km_spin.setSuffix(" ₽/км")
        self.rate_km_spin.setDecimals(2)
        self.rate_km_spin.setMinimumHeight(30)
        rates_layout.addWidget(self.rate_km_spin, 1, 3)
        
        scroll_layout.addWidget(rates_group)
        
        # === БЛОК 3: КНОПКИ ===
        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)
        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)
        
        self.copy_btn = QPushButton("📋 Копировать в Max")
        self.copy_btn.setMinimumHeight(40)
        self.copy_btn.setMinimumWidth(150)
        self.copy_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.copy_btn.clicked.connect(self.copy_to_max)
        btn_layout.addWidget(self.copy_btn)
        
        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)
        
        scroll_layout.addLayout(btn_layout)
        
        # === БЛОК 4: РЕЗУЛЬТАТЫ ===
        result_group = QGroupBox("📊 РЕЗУЛЬТАТЫ СРАВНЕНИЯ")
        result_group.setStyleSheet(route_group.styleSheet())
        result_layout = QVBoxLayout(result_group)
        
        # Сводка
        self.summary_label = QLabel()
        self.summary_label.setStyleSheet("""
            background-color: #e8f0fe;
            padding: 15px;
            border-radius: 5px;
            font-size: 11pt;
            line-height: 1.5;
            border: 1px solid #1976D2;
        """)
        self.summary_label.setWordWrap(True)
        self.summary_label.setMinimumHeight(100)
        result_layout.addWidget(self.summary_label)
        
        # Таблица результатов
        self.result_table = QTableWidget()
        self.result_table.setColumnCount(3)
        self.result_table.setHorizontalHeaderLabels(["Методика", "Стоимость", "Комментарий"])
        self.result_table.horizontalHeader().setStretchLastSection(True)
        self.result_table.setAlternatingRowColors(True)
        self.result_table.setMinimumHeight(200)
        self.result_table.setStyleSheet("""
            QTableWidget {
                font-size: 10pt;
                gridline-color: #c0c0c0;
                border: 1px solid #c0c0c0;
                border-radius: 5px;
            }
            QTableWidget::item {
                padding: 5px;
            }
            QHeaderView::section {
                background-color: #e0e0e0;
                padding: 5px;
                font-size: 10pt;
                font-weight: bold;
                border: 1px solid #c0c0c0;
            }
        """)
        result_layout.addWidget(self.result_table)
        
        # Детализация для Excel и Max
        self.details_label = QLabel()
        self.details_label.setVisible(False)
        result_layout.addWidget(self.details_label)
        
        scroll_layout.addWidget(result_group)
        scroll_layout.addStretch()
        
        scroll_area.setWidget(scroll_content)
        main_layout.addWidget(scroll_area)
    
    def connect_signals(self):
        """Подключение сигналов"""
        preview_widgets = [
            self.distance_spin, self.weight_spin, self.hours_spin,
            self.rate_ton_spin, self.rate_tkm_spin, self.rate_hourly_spin, self.rate_km_spin,
            self.point_a_edit, self.point_b_edit
        ]
        
        for widget in preview_widgets:
            if isinstance(widget, (QSpinBox, QDoubleSpinBox, QLineEdit)):
                if isinstance(widget, (QSpinBox, QDoubleSpinBox)):
                    widget.valueChanged.connect(self.update_preview)
                else:
                    widget.textChanged.connect(self.update_preview)
    
    def update_preview(self):
        """Обновляет предварительный просмотр"""
        params = self.get_params()
        self.summary_label.setText(
            f"📍 Маршрут: {params['point_a']} → {params['point_b']}\n"
            f"📏 Расстояние: {params['distance']} км | ⚖️ Вес: {params['weight']:.1f} т | ⏱️ Время: {params['hours']} ч"
        )
    
    def get_params(self) -> dict:
        """Возвращает словарь с текущими параметрами"""
        return {
            "point_a": self.point_a_edit.text(),
            "point_b": self.point_b_edit.text(),
            "distance": self.distance_spin.value(),
            "weight": self.weight_spin.value(),
            "hours": self.hours_spin.value(),
            "rate_ton": self.rate_ton_spin.value(),
            "rate_tkm": self.rate_tkm_spin.value(),
            "rate_hourly": self.rate_hourly_spin.value(),
            "rate_km": self.rate_km_spin.value()
        }
    
    def calculate(self):
        """Основной расчет"""
        try:
            params = self.get_params()
            
            distance = params["distance"]
            weight = params["weight"]
            hours = params["hours"]
            
            # Собираем активные методики
            results = []
            
            # За тонну
            if params["rate_ton"] > 0:
                cost = weight * params["rate_ton"]
                results.append((
                    "За тонну", 
                    cost, 
                    f"{weight:.1f} т × {params['rate_ton']:.2f} ₽/т = {cost:,.2f} ₽"
                ))
            
            # За тонно-км (без деления на 1000)
            if params["rate_tkm"] > 0:
                cost = weight * distance * params["rate_tkm"]
                results.append((
                    "За тонно-км", 
                    cost, 
                    f"{weight:.1f} т × {distance} км × {params['rate_tkm']:.2f} ₽/т/км = {cost:,.2f} ₽"
                ))
            
            # Почасовая
            if params["rate_hourly"] > 0:
                cost = hours * params["rate_hourly"]
                results.append((
                    "Почасовая", 
                    cost, 
                    f"{hours} ч × {params['rate_hourly']:.2f} ₽/ч = {cost:,.2f} ₽"
                ))
            
            # За километр
            if params["rate_km"] > 0:
                cost = distance * params["rate_km"]
                results.append((
                    "За километр", 
                    cost, 
                    f"{distance} км × {params['rate_km']:.2f} ₽/км = {cost:,.2f} ₽"
                ))
            
            if not results:
                QMessageBox.warning(self, "Предупреждение", "Заполните хотя бы одну расценку!")
                return
            
            # Сортируем по стоимости (от самой дешевой к самой дорогой)
            results.sort(key=lambda x: x[1])
            
            best_cost = results[0][1]
            worst_cost = results[-1][1]
            avg_cost = sum(r[1] for r in results) / len(results)
            
            # Заполняем таблицу
            self.result_table.setRowCount(len(results))
            
            for i, (method, cost, comment) in enumerate(results):
                # Методика
                method_item = QTableWidgetItem(method)
                method_item.setTextAlignment(Qt.AlignCenter)
                self.result_table.setItem(i, 0, method_item)
                
                # Стоимость
                cost_item = QTableWidgetItem(f"{cost:,.2f} ₽".replace(",", " "))
                cost_item.setTextAlignment(Qt.AlignCenter)
                self.result_table.setItem(i, 1, cost_item)
                
                # Комментарий
                comment_item = QTableWidgetItem(comment)
                self.result_table.setItem(i, 2, comment_item)
                
                # Цветовая индикация (ИСПРАВЛЕНО!)
                if cost == worst_cost:
                    # САМАЯ ДОРОГАЯ - зеленый (наша выручка!)
                    color = "#dff0d8"
                    text_color = "#2e7d32"
                    # Делаем жирным шрифт для самой дорогой
                    font = QFont()
                    font.setBold(True)
                    method_item.setFont(font)
                    cost_item.setFont(font)
                    comment_item.setFont(font)
                elif cost == best_cost:
                    # САМАЯ ДЕШЕВАЯ - красный (невыгодно)
                    color = "#f8d7da"
                    text_color = "#b02a37"
                elif cost < avg_cost:
                    # Ниже среднего - светло-красный
                    color = "#ffebee"
                    text_color = "#b02a37"
                else:
                    # Выше среднего - светло-зеленый
                    color = "#e8f5e9"
                    text_color = "#2e7d32"
                
                cost_item.setBackground(QColor(color))
                cost_item.setForeground(QBrush(QColor(text_color)))
            
            self.result_table.resizeColumnsToContents()
            
            # Обновляем сводку
            best_method = results[0][0]
            best_cost_val = results[0][1]
            worst_method = results[-1][0]
            worst_cost_val = results[-1][1]
            diff = worst_cost_val - best_cost_val
            
            summary = f"📍 Маршрут: {params['point_a']} → {params['point_b']}\n"
            summary += f"📏 Расстояние: {distance} км | ⚖️ Вес: {weight:.1f} т | ⏱️ Время: {hours} ч\n\n"
            summary += f"✅ САМАЯ ДОРОГАЯ (выгодная): {worst_method} = {worst_cost_val:,.2f} ₽\n"
            summary += f"❌ САМАЯ ДЕШЕВАЯ (невыгодная): {best_method} = {best_cost_val:,.2f} ₽\n"
            summary += f"💰 РАЗНИЦА: {diff:,.2f} ₽\n\n"
            
            if diff > 100000:
                summary += "🚀 ОГРОМНАЯ РАЗНИЦА! Выбирайте самый дорогой тариф!"
            elif diff > 50000:
                summary += "💪 Существенная разница, есть смысл требовать максимум"
            elif diff > 10000:
                summary += "👍 Умеренная разница, но выбирайте дороже"
            else:
                summary += "🤝 Разница небольшая, можно выбрать любой удобный вариант"
            
            self.summary_label.setText(summary)
            
            # Сохраняем детали для экспорта
            self.last_result = f"{worst_cost_val:,.2f} ₽".replace(",", " ")
            self.last_params = params
            self.last_results_list = results
            self.last_worst_cost = worst_cost_val
            self.last_worst_method = worst_method
            self.last_diff = diff
            
            # Сохраняем в историю
            self.save_to_history()
            
        except Exception as e:
            QMessageBox.critical(self, "Ошибка", f"Ошибка при расчёте:\n{str(e)}")
    
    def get_description(self) -> str:
        params = self.get_params()
        return f"{params['point_a']} → {params['point_b']}, {params['weight']:.1f} т, {params['distance']} км"
    
    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": self.get_description(),
                "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_result or 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": self.get_description(),
            "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):
        """Копирует красивое сообщение в буфер обмена для отправки в Max"""
        if not self.last_params or not self.last_results_list:
            QMessageBox.warning(self, "Предупреждение", "Сначала выполните расчёт!")
            return
        
        params = self.last_params
        results = self.last_results_list
        
        # Находим самый дорогой и самый дешевый
        sorted_results = sorted(results, key=lambda x: x[1])
        best_cost = sorted_results[0][1]
        best_method = sorted_results[0][0]
        worst_cost = sorted_results[-1][1]
        worst_method = sorted_results[-1][0]
        diff = worst_cost - best_cost
        
        # Формируем таблицу
        table_text = ""
        for method, cost, comment in sorted_results:
            table_text += f"  • {method}: {cost:,.2f} ₽\n"
        
        message = f"""🛣️ ЛОГИСТИЧЕСКИЙ КОНСТРУКТОР - СРАВНЕНИЕ ТАРИФОВ

📅 Дата: {datetime.now().strftime('%d.%m.%Y %H:%M')}
📍 Маршрут: {params['point_a']} → {params['point_b']}
📏 Расстояние: {params['distance']} км
⚖️ Вес груза: {params['weight']:.1f} т
⏱️ Время в пути: {params['hours']} ч

💰 РЕЗУЛЬТАТЫ СРАВНЕНИЯ:
{table_text}
✅ САМАЯ ДОРОГАЯ (выгодная): {worst_method} = {worst_cost:,.2f} ₽
❌ САМАЯ ДЕШЕВАЯ (невыгодная): {best_method} = {best_cost:,.2f} ₽
💰 РАЗНИЦА: {diff:,.2f} ₽

🔗 Код расчёта: {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 or not self.last_results_list:
            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"logistic_calculation_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx",
                "Excel Files (*.xlsx)"
            )
            
            if not filename:
                return
            
            params = self.last_params
            results = self.last_results_list
            sorted_results = sorted(results, key=lambda x: x[1])
            worst_cost = sorted_results[-1][1]
            worst_method = sorted_results[-1][0]
            best_cost = sorted_results[0][1]
            best_method = sorted_results[0][0]
            diff = worst_cost - best_cost
            
            # Создаем книгу Excel
            wb = openpyxl.Workbook()
            ws = wb.active
            ws.title = "Сравнение тарифов"
            
            # Настройка стилей
            title_font = Font(name='Arial', size=14, bold=True, color="FFFFFF")
            title_fill = PatternFill(start_color="1976D2", end_color="1976D2", fill_type="solid")
            header_font = Font(name='Arial', size=11, bold=True, color="FFFFFF")
            header_fill = PatternFill(start_color="2E7D32", end_color="2E7D32", fill_type="solid")
            cell_font = Font(name='Arial', size=10)
            bold_font = Font(name='Arial', size=10, bold=True)
            center_alignment = Alignment(horizontal="center", vertical="center")
            left_alignment = Alignment(horizontal="left", vertical="center")
            right_alignment = 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:C1')
            title_cell = ws['A1']
            title_cell.value = "🛣️ ЛОГИСТИЧЕСКИЙ КОНСТРУКТОР - СРАВНЕНИЕ ТАРИФОВ"
            title_cell.font = title_font
            title_cell.fill = title_fill
            title_cell.alignment = center_alignment
            title_cell.border = border
            
            # Дата
            ws.merge_cells('A2:C2')
            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_alignment
            date_cell.border = border
            
            # Параметры маршрута
            row = 4
            ws.merge_cells(f'A{row}:C{row}')
            section_cell = ws[f'A{row}']
            section_cell.value = "📍 ПАРАМЕТРЫ МАРШРУТА"
            section_cell.font = Font(name='Arial', size=12, bold=True)
            section_cell.fill = PatternFill(start_color="E3F2FD", end_color="E3F2FD", fill_type="solid")
            section_cell.alignment = left_alignment
            section_cell.border = border
            
            row += 1
            route_data = [
                ("Точка А:", params['point_a']),
                ("Точка Б:", params['point_b']),
                ("Расстояние:", f"{params['distance']} км"),
                ("Вес груза:", f"{params['weight']:.1f} т"),
                ("Время в пути:", f"{params['hours']} ч"),
            ]
            
            for i, (label, value) in enumerate(route_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_alignment
                
                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_alignment
            
            row += len(route_data) + 1
            
            # Расценки
            ws.merge_cells(f'A{row}:C{row}')
            section_cell = ws[f'A{row}']
            section_cell.value = "💰 РАСЦЕНКИ"
            section_cell.font = Font(name='Arial', size=12, bold=True)
            section_cell.fill = PatternFill(start_color="E3F2FD", end_color="E3F2FD", fill_type="solid")
            section_cell.alignment = left_alignment
            section_cell.border = border
            
            row += 1
            rates_data = [
                ("За тонну:", f"{params['rate_ton']:.2f} ₽/т"),
                ("За тонно-км:", f"{params['rate_tkm']:.2f} ₽/т/км"),
                ("Почасовая:", f"{params['rate_hourly']:.2f} ₽/ч"),
                ("За километр:", f"{params['rate_km']:.2f} ₽/км"),
            ]
            
            for i, (label, value) in enumerate(rates_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_alignment
                
                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_alignment
            
            row += len(rates_data) + 2
            
            # Заголовки таблицы результатов
            headers = ["Методика", "Стоимость", "Комментарий"]
            for col, header in enumerate(headers, 1):
                cell = ws.cell(row=row, column=col, value=header)
                cell.font = header_font
                cell.fill = header_fill
                cell.alignment = center_alignment
                cell.border = border
            
            row += 1
            
            # Заполняем таблицу
            for method, cost, comment in sorted_results:
                ws.cell(row=row, column=1, value=method).font = cell_font
                ws.cell(row=row, column=1).border = border
                ws.cell(row=row, column=1).alignment = left_alignment
                
                cost_cell = ws.cell(row=row, column=2, value=f"{cost:,.2f} ₽")
                cost_cell.font = cell_font
                cost_cell.border = border
                cost_cell.alignment = right_alignment
                
                # Цветовая индикация
                if cost == worst_cost:
                    cost_cell.font = Font(name='Arial', size=10, bold=True, color="2E7D32")
                elif cost == best_cost:
                    cost_cell.font = Font(name='Arial', size=10, bold=True, color="B71C1C")
                
                ws.cell(row=row, column=3, value=comment).font = cell_font
                ws.cell(row=row, column=3).border = border
                ws.cell(row=row, column=3).alignment = left_alignment
                
                row += 1
            
            row += 1
            
            # Итоги
            ws.merge_cells(f'A{row}:C{row}')
            summary_cell = ws[f'A{row}']
            summary_cell.value = f"✅ САМАЯ ДОРОГАЯ: {worst_method} = {worst_cost:,.2f} ₽"
            summary_cell.font = Font(name='Arial', size=11, bold=True, color="2E7D32")
            summary_cell.border = border
            summary_cell.alignment = left_alignment
            
            row += 1
            ws.merge_cells(f'A{row}:C{row}')
            summary_cell = ws[f'A{row}']
            summary_cell.value = f"❌ САМАЯ ДЕШЕВАЯ: {best_method} = {best_cost:,.2f} ₽"
            summary_cell.font = Font(name='Arial', size=11, bold=True, color="B71C1C")
            summary_cell.border = border
            summary_cell.alignment = left_alignment
            
            row += 1
            ws.merge_cells(f'A{row}:C{row}')
            summary_cell = ws[f'A{row}']
            summary_cell.value = f"💰 РАЗНИЦА: {diff:,.2f} ₽"
            summary_cell.font = Font(name='Arial', size=11, bold=True)
            summary_cell.border = border
            summary_cell.alignment = left_alignment
            
            # Автоподбор ширины колонок
            ws.column_dimensions['A'].width = 25
            ws.column_dimensions['B'].width = 20
            ws.column_dimensions['C'].width = 50
            
            # Сохраняем файл
            wb.save(filename)
            
            QMessageBox.information(
                self,
                "Готово",
                f"✅ Расчет успешно экспортирован!\n\nФайл сохранен:\n{filename}"
            )
            
        except Exception as e:
            QMessageBox.critical(self, "Ошибка", f"Не удалось экспортировать:\n{str(e)}")