#include "AddCurveFileDlg.h"

#include <QFileDialog>
#include <QFileInfo>
#include <QMessageBox>
#include <QColorDialog>
#include <QListWidget>

#include "workspace/WorkSpace.h"
#include "workspace/WorkSpaceManager.h"

#include "ui_AddCurveFileDlg.h"

AddCurveFileDlg::AddCurveFileDlg(QWidget* parent)
    : BaseAddFileDlg(FileEntryType::Curve, parent)
    , ui(new Ui::AddCurveFileDlg)
    , currentCurveIndex_(-1)
    , selectedColor_(255, 0, 0) {  // Default to red color
    
    SetupUI(ui);
    SetTitle(getDialogTitle());
    
    // Initialize chart type combo box
    ui->chartTypeComboBox->addItem("Wave", static_cast<int>(ChartType::Wave));
    ui->chartTypeComboBox->addItem("Report", static_cast<int>(ChartType::Report));
    ui->chartTypeComboBox->setCurrentIndex(0);  // Default to Wave
    
    // Initialize chart properties with default values
    chartProperties_.chartType = ChartType::Wave;
    
    setupConnections();
    updateCurvePropertiesUI();  // Initialize UI based on default chart type
}

AddCurveFileDlg::~AddCurveFileDlg() {
    delete ui;
}

void AddCurveFileDlg::setupConnections() {
    // File selection connections
    connect(ui->selectFileBtn, &QToolButton::clicked, this, &AddCurveFileDlg::OnSelectFile);
    
    // Chart type connection
    connect(ui->chartTypeComboBox, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &AddCurveFileDlg::onChartTypeChanged);
    
    // Curve management connections
    connect(ui->addCurveBtn, &QPushButton::clicked, this, &AddCurveFileDlg::onAddCurveClicked);
    connect(ui->removeCurveBtn, &QPushButton::clicked, this, &AddCurveFileDlg::onRemoveCurveClicked);
    connect(ui->curveListWidget, &QListWidget::currentRowChanged, this, &AddCurveFileDlg::onCurveSelectionChanged);
    connect(ui->curveListWidget, &QListWidget::itemClicked, this, &AddCurveFileDlg::onCurveListWidgetItemClicked);
    
    // Curve properties connections
    connect(ui->colorButton, &QPushButton::clicked, this, &AddCurveFileDlg::onColorButtonClicked);
    connect(ui->curveNameEdit, &QLineEdit::textChanged, this, &AddCurveFileDlg::onCurveNameChanged);
    connect(ui->dataStartSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), this, &AddCurveFileDlg::onCurveDataChanged);
    connect(ui->dataStopSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), this, &AddCurveFileDlg::onCurveDataChanged);
    connect(ui->xValueSpinBox, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &AddCurveFileDlg::onCurveDataChanged);
    connect(ui->yValueSpinBox, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &AddCurveFileDlg::onCurveDataChanged);
    
    // Dialog buttons
    connect(ui->addBtn, &QPushButton::clicked, this, &AddCurveFileDlg::onSure);
    connect(ui->cancelBtn, &QPushButton::clicked, this, &QDialog::reject);
}


void AddCurveFileDlg::updateFileInfo(const QString& filePath) {
    QFileInfo fileInfo(filePath);
    if (fileInfo.exists()) {
        ui->fileNameValue->setText(fileInfo.fileName());
        qint64 size = fileInfo.size();
        QString sizeText;
        if (size < 1024) {
            sizeText = QString("%1 B").arg(size);
        }
        else if (size < 1024 * 1024) {
            sizeText = QString("%1 KB").arg(size / 1024.0, 0, 'f', 1);
        }
        else {
            sizeText = QString("%1 MB").arg(size / (1024.0 * 1024.0), 0, 'f', 1);
        }
        ui->fileSizeValue->setText(sizeText);
    } else {
        ui->fileNameValue->setText("-");
        ui->fileSizeValue->setText("-");
    }

    ui->filePathEdit->setText(filePath);
}

void AddCurveFileDlg::onAddCurveClicked() {
    // Save current curve properties if any curve is selected
    if (currentCurveIndex_ >= 0) {
        saveCurveProperties();
    }
    
    // Create new curve with default properties based on chart type
    FileEntryCurve::CurveProperty newCurve;
    newCurve.name = generateCurveName();
    newCurve.color = generateCurveColor();
    
    // Set default values based on chart type
    if (chartProperties_.chartType == ChartType::Wave) {
        newCurve.data.wave.start = 1;
        newCurve.data.wave.stop = 241;
    } else {
        newCurve.data.report.x = 0.0;
        newCurve.data.report.y = 0.0;
    }
    
    // Add to curves list and UI
    curves_.append(newCurve);
        
    // Add to UI list widget with appropriate display format
     QString displayText;
     if (chartProperties_.chartType == ChartType::Wave) {
         displayText = QString("%1 [%2,%3] (%4,%5,%6)")
                      .arg(newCurve.name)
                      .arg(newCurve.data.wave.start)
                      .arg(newCurve.data.wave.stop)
                      .arg(newCurve.color.red())
                      .arg(newCurve.color.green())
                      .arg(newCurve.color.blue());
     } else {
         displayText = QString("%1 (%.2f,%.2f) (%4,%5,%6)")
                      .arg(newCurve.name)
                      .arg(newCurve.data.report.x)
                      .arg(newCurve.data.report.y)
                      .arg(newCurve.color.red())
                      .arg(newCurve.color.green())
                      .arg(newCurve.color.blue());
     }
    
    QListWidgetItem* item = new QListWidgetItem(displayText);
    ui->curveListWidget->addItem(item);
    ++currentCurveIndex_;
    
    // Select the new curve
    ui->curveListWidget->setCurrentRow(curves_.size() - 1);
}

void AddCurveFileDlg::onRemoveCurveClicked() {
    int currentRow = ui->curveListWidget->currentRow();
    if (currentRow < 0 || currentRow >= curves_.size()) {
        return;
    }
    
    // Don't allow removing the last curve
    if (curves_.size() <= 0) {
        QMessageBox::information(this, "Information", "At least one curve must remain.");
        return;
    }
    
    // Remove from curves list and UI
    curves_.removeAt(currentRow);
    delete ui->curveListWidget->takeItem(currentRow);
    
    // Update current index
    if (currentRow >= curves_.size()) {
        currentRow = curves_.size() - 1;
    }
    
    if (currentRow >= 0) {
        ui->curveListWidget->setCurrentRow(currentRow);
    } else {
        currentCurveIndex_ = -1;
        clearCurveProperties();
        enableCurveProperties(false);
    }
}

void AddCurveFileDlg::onCurveListWidgetItemClicked(QListWidgetItem* item) {
    if (!item) {
        return;
    }
    
    int clickedIndex = ui->curveListWidget->row(item);
    
    if (clickedIndex == currentCurveIndex_) {
        ui->curveNameEdit->setText(curves_[currentCurveIndex_].name);
        
        if (chartProperties_.chartType == ChartType::Wave) {
            ui->dataStartSpinBox->setValue(curves_[currentCurveIndex_].data.wave.start);
            ui->dataStopSpinBox->setValue(curves_[currentCurveIndex_].data.wave.stop);
        } else {
            ui->xValueSpinBox->setValue(curves_[currentCurveIndex_].data.report.x);
            ui->yValueSpinBox->setValue(curves_[currentCurveIndex_].data.report.y);
        }
        
        updateColorPreview(curves_[currentCurveIndex_].color);
        enableCurveProperties(true);
        
        ui->curveNameEdit->setFocus();
        ui->curveNameEdit->selectAll();
    } else {
        onCurveSelectionChanged();
    }
}

void AddCurveFileDlg::onCurveSelectionChanged() {
    int currentRow = ui->curveListWidget->currentRow();
    
    // Save previous curve properties
    if (currentCurveIndex_ >= 0 && currentCurveIndex_ < curves_.size()) {
        saveCurveProperties();
    }
    
    currentCurveIndex_ = currentRow;
    
    if (currentRow >= 0 && currentRow < curves_.size()) {
        // Load selected curve properties
        updateCurveProperties();
        enableCurveProperties(true);
    } else {
        clearCurveProperties();
        enableCurveProperties(false);
    }
}

void AddCurveFileDlg::onCurveNameChanged() {
    if (currentCurveIndex_ >= 0 && currentCurveIndex_ < curves_.size()) {
        QString newName = ui->curveNameEdit->text();
        curves_[currentCurveIndex_].name = newName;
        
        // Update list item text with appropriate format
         QListWidgetItem* item = ui->curveListWidget->item(currentCurveIndex_);
         if (item) {
             QString displayText;
             if (chartProperties_.chartType == ChartType::Wave) {
                 displayText = QString("%1 [%2,%3] (%4,%5,%6)")
                              .arg(newName)
                              .arg(curves_[currentCurveIndex_].data.wave.start)
                              .arg(curves_[currentCurveIndex_].data.wave.stop)
                              .arg(curves_[currentCurveIndex_].color.red())
                              .arg(curves_[currentCurveIndex_].color.green())
                              .arg(curves_[currentCurveIndex_].color.blue());
             } else {
                 displayText = QString("%1 (%.2f,%.2f) (%4,%5,%6)")
                              .arg(newName)
                              .arg(curves_[currentCurveIndex_].data.report.x)
                              .arg(curves_[currentCurveIndex_].data.report.y)
                              .arg(curves_[currentCurveIndex_].color.red())
                              .arg(curves_[currentCurveIndex_].color.green())
                              .arg(curves_[currentCurveIndex_].color.blue());
             }
             item->setText(displayText);
         }
    }
}

void AddCurveFileDlg::onCurveDataChanged() {
    if (currentCurveIndex_ >= 0 && currentCurveIndex_ < curves_.size()) {
        // Update curve data based on chart type
        if (chartProperties_.chartType == ChartType::Wave) {
            curves_[currentCurveIndex_].data.wave.start = ui->dataStartSpinBox->value();
            curves_[currentCurveIndex_].data.wave.stop = ui->dataStopSpinBox->value();
        } else {
            curves_[currentCurveIndex_].data.report.x = ui->xValueSpinBox->value();
            curves_[currentCurveIndex_].data.report.y = ui->yValueSpinBox->value();
        }
        
        // Update display text in list widget
        QListWidgetItem* item = ui->curveListWidget->item(currentCurveIndex_);
        if (item) {
            QString itemText;
            if (chartProperties_.chartType == ChartType::Wave) {
                itemText = QString("%1 [%2,%3] (%4,%5,%6)")
                          .arg(curves_[currentCurveIndex_].name)
                          .arg(curves_[currentCurveIndex_].data.wave.start)
                          .arg(curves_[currentCurveIndex_].data.wave.stop)
                          .arg(curves_[currentCurveIndex_].color.red())
                          .arg(curves_[currentCurveIndex_].color.green())
                          .arg(curves_[currentCurveIndex_].color.blue());
            } else {
                itemText = QString("%1 (%2,%3) (%4,%5,%6)")
                          .arg(curves_[currentCurveIndex_].name)
                          .arg(curves_[currentCurveIndex_].data.report.x)
                          .arg(curves_[currentCurveIndex_].data.report.y)
                          .arg(curves_[currentCurveIndex_].color.red())
                          .arg(curves_[currentCurveIndex_].color.green())
                          .arg(curves_[currentCurveIndex_].color.blue());
            }
            item->setText(itemText);
        }
    }
}

void AddCurveFileDlg::onColorButtonClicked() {
    if (currentCurveIndex_ >= 0 && currentCurveIndex_ < curves_.size()) {
        QColor color = QColorDialog::getColor(curves_[currentCurveIndex_].color, this, "Select Curve Color");
        if (color.isValid()) {
            curves_[currentCurveIndex_].color = color;
            selectedColor_ = color;
            updateColorPreview(color);
            
            // Update list item text
             QListWidgetItem* item = ui->curveListWidget->item(currentCurveIndex_);
             if (item) {
                 QString itemText;
                 if (chartProperties_.chartType == ChartType::Wave) {
                      itemText = QString("%1 [%2,%3] (%4,%5,%6)")
                                .arg(curves_[currentCurveIndex_].name)
                                .arg(curves_[currentCurveIndex_].data.wave.start)
                                .arg(curves_[currentCurveIndex_].data.wave.stop)
                                .arg(color.red())
                                .arg(color.green())
                                .arg(color.blue());
                  } else {
                      itemText = QString("%1 (%2,%3) (%4,%5,%6)")
                                .arg(curves_[currentCurveIndex_].name)
                                .arg(curves_[currentCurveIndex_].data.report.x)
                                .arg(curves_[currentCurveIndex_].data.report.y)
                                .arg(color.red())
                                .arg(color.green())
                                .arg(color.blue());
                  }
                 item->setText(itemText);
             }
        }
    }
}

void AddCurveFileDlg::addCurveToList(const FileEntryCurve::CurveProperty& curve) {
     QString itemText;
     if (chartProperties_.chartType == ChartType::Wave) {
         itemText = QString("%1 [%2,%3] (%4,%5,%6)")
                   .arg(curve.name)
                   .arg(curve.data.wave.start)
                   .arg(curve.data.wave.stop)
                   .arg(curve.color.red())
                   .arg(curve.color.green())
                   .arg(curve.color.blue());
     } else {
         itemText = QString("%1 (%2,%3) (%4,%5,%6)")
                   .arg(curve.name)
                   .arg(curve.data.report.x)
                   .arg(curve.data.report.y)
                   .arg(curve.color.red())
                   .arg(curve.color.green())
                   .arg(curve.color.blue());
     }
     
     ui->curveListWidget->addItem(itemText);
 }

void AddCurveFileDlg::updateCurveProperties() {
    if (currentCurveIndex_ >= 0 && currentCurveIndex_ < curves_.size()) {
        const FileEntryCurve::CurveProperty& curve = curves_[currentCurveIndex_];
        
        ui->curveNameEdit->setText(curve.name);
        
        // Update properties based on chart type
        if (chartProperties_.chartType == ChartType::Wave) {
            ui->dataStartSpinBox->setValue(curve.data.wave.start);
            ui->dataStopSpinBox->setValue(curve.data.wave.stop);
        } else {
            ui->xValueSpinBox->setValue(curve.data.report.x);
            ui->yValueSpinBox->setValue(curve.data.report.y);
        }
        
        selectedColor_ = curve.color;
        updateColorPreview(curve.color);
    }
}

void AddCurveFileDlg::saveCurveProperties() {
    if (currentCurveIndex_ >= 0 && currentCurveIndex_ < curves_.size()) {
        curves_[currentCurveIndex_].name = ui->curveNameEdit->text();
        
        // Save properties based on chart type
        if (chartProperties_.chartType == ChartType::Wave) {
            curves_[currentCurveIndex_].data.wave.start = ui->dataStartSpinBox->value();
            curves_[currentCurveIndex_].data.wave.stop = ui->dataStopSpinBox->value();
        } else {
            curves_[currentCurveIndex_].data.report.x = ui->xValueSpinBox->value();
            curves_[currentCurveIndex_].data.report.y = ui->yValueSpinBox->value();
        }
        
        curves_[currentCurveIndex_].color = selectedColor_;
    }
}

void AddCurveFileDlg::clearCurveProperties() {
    ui->curveNameEdit->clear();
    
    // Clear properties based on chart type
    if (chartProperties_.chartType == ChartType::Wave) {
        ui->dataStartSpinBox->setValue(1);
        ui->dataStopSpinBox->setValue(241);
    } else {
        ui->xValueSpinBox->setValue(0.0);
        ui->yValueSpinBox->setValue(0.0);
    }
    
    selectedColor_ = QColor(255, 0, 0);
    updateColorPreview(selectedColor_);
}

void AddCurveFileDlg::enableCurveProperties(bool enabled) {
    ui->curvePropertiesGroupBox->setEnabled(enabled);
}

QString AddCurveFileDlg::generateCurveName() {
    return tr("Curve %1").arg(curves_.size() + 1);
}

QColor AddCurveFileDlg::generateCurveColor() const {
    // Generate different colors for each curve
    static const QColor colors[] = {
        QColor(255, 0, 0),    // Red
        QColor(0, 255, 0),    // Green
        QColor(0, 0, 255),    // Blue
        QColor(255, 255, 0),  // Yellow
        QColor(255, 0, 255),  // Magenta
        QColor(0, 255, 255),  // Cyan
        QColor(255, 128, 0),  // Orange
        QColor(128, 0, 255),  // Purple
    };
    
    int colorIndex = curves_.size() % (sizeof(colors) / sizeof(colors[0]));
    return colors[colorIndex];
}

void AddCurveFileDlg::updateColorPreview(const QColor& color) {
    QString styleSheet = QString("background-color: rgb(%1, %2, %3); border: 1px solid black;")
                        .arg(color.red())
                        .arg(color.green())
                        .arg(color.blue());
    ui->colorPreview->setStyleSheet(styleSheet);
}

bool AddCurveFileDlg::validateSpecificParams() {
    // File path validation
    const QString& selectFilePath = getSelectedFilePath();
    if (selectFilePath.isEmpty()) {
        QMessageBox::warning(this, tr("Validation Error"), tr("Please select a data file."));
        return false;
    }
    
    // File existence validation
    QFileInfo fileInfo(selectFilePath);
    if (!fileInfo.exists()) {
        QMessageBox::warning(this, tr("Validation Error"), tr("Selected file does not exist."));
        return false;
    }
    
    // File readability validation
    if (!fileInfo.isReadable()) {
        QMessageBox::warning(this, tr("Validation Error"), tr("Selected file is not readable. Please check file permissions."));
        return false;
    }
    
    // File size validation (avoid memory issues with large files)
    if (fileInfo.size() > 100 * 1024 * 1024) { // 100MB limit
        QMessageBox::warning(this, tr("Validation Error"), tr("File is too large (over 100MB). Please select a smaller file."));
        return false;
    }
    
    // Curve count validation
    if (curves_.isEmpty()) {
        QMessageBox::warning(this, tr("Validation Error"), tr("At least one curve must be defined."));
        return false;
    }
    
    // Save current curve properties
    if (currentCurveIndex_ >= 0) {
        saveCurveProperties();
    }
    
    // Curve name uniqueness validation
    QStringList curveNames;
    for (int i = 0; i < curves_.size(); ++i) {
        const FileEntryCurve::CurveProperty& curve = curves_[i];
        
        if (curve.name.isEmpty()) {
            QMessageBox::warning(this, tr("Validation Error"), 
                                tr("Curve %1 name cannot be empty.").arg(i + 1));
            return false;
        }
        
        if (curveNames.contains(curve.name)) {
            QMessageBox::warning(this, tr("Validation Error"), 
                                tr("Curve name '%1' is duplicated. Please use different names.").arg(curve.name));
            return false;
        }
        curveNames.append(curve.name);
        
        // Curve name length validation
        if (curve.name.length() > 50) {
            QMessageBox::warning(this, tr("Validation Error"), 
                                tr("Curve name '%1' is too long. Please limit to 50 characters.").arg(curve.name));
            return false;
        }
        
        // Data range validation based on chart type
        if (chartProperties_.chartType == ChartType::Wave) {
            if (curve.data.wave.start < 1 || curve.data.wave.stop < 1) {
                QMessageBox::warning(this, tr("Validation Error"), 
                                    tr("Curve '%1' start and stop values must be greater than 0.").arg(curve.name));
                return false;
            }
            
            if (curve.data.wave.start > curve.data.wave.stop) {
                QMessageBox::warning(this, tr("Validation Error"), 
                                    tr("Curve '%1' start value cannot be greater than stop value.").arg(curve.name));
                return false;
            }
            
            // Data range reasonableness validation
            if (curve.data.wave.stop - curve.data.wave.start < 1) {
                QMessageBox::warning(this, tr("Validation Error"), 
                                    tr("Curve '%1' data range is too small. At least 2 data points are required.").arg(curve.name));
                return false;
            }
            
            if (curve.data.wave.stop > 1000000) {
                QMessageBox::warning(this, tr("Validation Error"), 
                                    tr("Curve '%1' stop value is too large. Please ensure it does not exceed 1000000.").arg(curve.name));
                return false;
            }
        } else {
            // Report type validation - ensure x and y values are reasonable
            if (curve.data.report.x < -1000000 || curve.data.report.x > 1000000) {
                QMessageBox::warning(this, tr("Validation Error"), 
                                    tr("Curve '%1' X value is out of range. Please ensure it is between -1000000 and 1000000.").arg(curve.name));
                return false;
            }
            
            if (curve.data.report.y < -1000000 || curve.data.report.y > 1000000) {
                QMessageBox::warning(this, tr("Validation Error"), 
                                    tr("Curve '%1' Y value is out of range. Please ensure it is between -1000000 and 1000000.").arg(curve.name));
                return false;
            }
        }
    }
    
    // Chart properties validation
    if (ui->chartNameEdit->text().isEmpty()) {
        QMessageBox::warning(this, tr("Validation Error"), tr("Chart name cannot be empty."));
        return false;
    }
    
    if (ui->chartNameEdit->text().length() > 100) {
        QMessageBox::warning(this, tr("Validation Error"), tr("Chart name is too long. Please limit to 100 characters."));
        return false;
    }
    
    // Axis title validation
    if (ui->xTitleEdit->text().length() > 50) {
        QMessageBox::warning(this, tr("Validation Error"), tr("X axis title is too long. Please limit to 50 characters."));
        return false;
    }
    
    if (ui->yTitleEdit->text().length() > 50) {
        QMessageBox::warning(this, tr("Validation Error"), tr("Y axis title is too long. Please limit to 50 characters."));
        return false;
    }
    
    // Axis range validation
    double xMin = ui->xMinSpinBox->value();
    double xMax = ui->xMaxSpinBox->value();
    double yMin = ui->yMinSpinBox->value();
    double yMax = ui->yMaxSpinBox->value();
    
    if (xMin >= xMax) {
        QMessageBox::warning(this, tr("Validation Error"), tr("X axis minimum value must be less than maximum value."));
        return false;
    }
    
    if (yMin >= yMax) {
        QMessageBox::warning(this, tr("Validation Error"), tr("Y axis minimum value must be less than maximum value."));
        return false;
    }
    
   
    // Time parameter validation
    double timeParam = ui->timeParamSpinBox->value();
    if (timeParam < 0) {
        QMessageBox::warning(this, tr("Validation Error"), tr("Time parameter cannot be negative."));
        return false;
    }
    
    // X axis tick count validation
    int xTickCount = ui->xCountSpinBox->value();
    if (xTickCount < 2) {
        QMessageBox::warning(this, tr("Validation Error"), tr("X axis tick count must be at least 2."));
        return false;
    }
   
    return true;
}

QString AddCurveFileDlg::getFileFilter() const {
    return "Data Files (*.txt *.csv *.dat);;All Files (*.*)";
}

QString AddCurveFileDlg::getDialogTitle() const {
    return "Add Curve Data File";
}

void AddCurveFileDlg::onSure() {
    if (validateSpecificParams()) {
        // Create FileEntryCurve object using factory function
        auto fileEntryCurve = CreateFileEntryCurve(getSelectedFilePath());
        if (!fileEntryCurve) {
            QMessageBox::warning(this, tr("Error"), tr("Failed to create file entry"));
            return;
        }
        
        // Set curve properties
        fileEntryCurve->SetName(ui->chartNameEdit->text());
        
        // Set chart properties
        FileEntryCurve::ChartProperties chartProps;
        chartProps.chartType = chartProperties_.chartType;  // Set chart type
        chartProps.xCount = ui->xCountSpinBox->value();
        chartProps.yCount = ui->yCountSpinBox->value();
        chartProps.xTitle = ui->xTitleEdit->text();
        chartProps.yTitle = ui->yTitleEdit->text();
        chartProps.xMin = ui->xMinSpinBox->value();
        chartProps.xMax = ui->xMaxSpinBox->value();
        chartProps.yMin = ui->yMinSpinBox->value();
        chartProps.yMax = ui->yMaxSpinBox->value();
        chartProps.timeParam = ui->timeParamSpinBox->value();
        fileEntryCurve->SetChartProperties(chartProps);
        
        // Add curve properties
        for (const auto& curve : curves_) {
            fileEntryCurve->AddCurveProperty(curve);
        }
        
        // Get current workspace
        WorkSpace* workspace = WorkSpaceManager::Get().GetCurrent();
        if (!workspace) {
            QMessageBox::warning(this, tr("Error"), tr("Unable to get current workspace"));
            return;
        }
        
        // Add FileEntryCurve to workspace using new SetFileEntry method
        auto result = workspace->SetFileEntry(fileEntryCurve);
        if (result != WorkSpace::FileEntryResult::Ok) {
            QString errorMsg;
            switch (result) {
                case WorkSpace::FileEntryResult::LimitExceeded:
                    errorMsg = tr("Curve file count has reached the limit (9 files)");
                    break;
                case WorkSpace::FileEntryResult::Duplicate:
                    errorMsg = tr("File already exists");
                    break;
                case WorkSpace::FileEntryResult::CopyFailed:
                    errorMsg = tr("File copy failed");
                    break;
                case WorkSpace::FileEntryResult::InvalidFile:
                    errorMsg = tr("Invalid file");
                    break;
                default:
                    errorMsg = tr("Failed to add file");
                    break;
            }
            QMessageBox::warning(this, tr("Error"), errorMsg);
            return;
        }
        
        accept();
    }
}

void AddCurveFileDlg::onChartTypeChanged() {
    // Save current curve properties if any curve is selected
    if (currentCurveIndex_ >= 0) {
        saveCurveProperties();
    }
    
    // Update chart type based on combo box selection
    int selectedIndex = ui->chartTypeComboBox->currentIndex();
    ChartType newChartType = static_cast<ChartType>(ui->chartTypeComboBox->itemData(selectedIndex).toInt());
    chartProperties_.chartType = newChartType;
    
    // Update UI to show appropriate curve property controls
    updateCurvePropertiesUI();
    
    // Update current curve properties display if a curve is selected
    if (currentCurveIndex_ >= 0) {
        updateCurveProperties();
    }
}

void AddCurveFileDlg::updateCurvePropertiesUI() {
    bool isWaveType = (chartProperties_.chartType == ChartType::Wave);
    
    // Show/hide Wave type controls (Data Start/Stop)
    ui->dataStartLabel->setVisible(isWaveType);
    ui->dataStartSpinBox->setVisible(isWaveType);
    ui->dataStopLabel->setVisible(isWaveType);
    ui->dataStopSpinBox->setVisible(isWaveType);
    
    // Show/hide Report type controls (X/Y Value)
    ui->xValueLabel->setVisible(!isWaveType);
    ui->xValueSpinBox->setVisible(!isWaveType);
    ui->yValueLabel->setVisible(!isWaveType);
    ui->yValueSpinBox->setVisible(!isWaveType);
}