#include "PropertyWidgets.h"
#include <QSignalBlocker>
#include <QRegularExpression>
#include <QRegularExpressionMatch>
#include <QComboBox>
#include <QCheckBox>
#include "Vtk/uLibVtkInterface.h"
#include "Math/Units.h"
#include "Math/Dense.h"

namespace uLib {
namespace Qt {

PropertyWidgetBase::PropertyWidgetBase(PropertyBase* prop, QWidget* parent) 
    : QWidget(parent), m_BaseProperty(prop) {
    m_Layout = new QHBoxLayout(this);
    m_Layout->setContentsMargins(4, 2, 4, 2);
    m_Label = new QLabel(QString::fromStdString(prop->GetName()), this);
    m_Label->setMinimumWidth(100);
    m_Layout->addWidget(m_Label);
}
PropertyWidgetBase::~PropertyWidgetBase() {
    m_Connection.disconnect();
}

// Helper for unit parsing
double parseWithUnits(const QString& text, double* factorOut, QString* suffixOut) {
    static QRegularExpression re("^\\s*([-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?)\\s*(_?[a-zA-Z]+)?\\s*$");
    QRegularExpressionMatch match = re.match(text);
    if (!match.hasMatch()) return 0.0;

    double num = match.captured(1).toDouble();
    QString unit = match.captured(3);
    double factor = 1.0;

    if (!unit.isEmpty()) {
        QString u = unit.startsWith('_') ? unit.mid(1) : unit;
        if (u == "m") factor = CLHEP::meter;
        else if (u == "cm") factor = CLHEP::centimeter;
        else if (u == "mm") factor = CLHEP::millimeter;
        else if (u == "um") factor = CLHEP::micrometer;
        else if (u == "nm") factor = CLHEP::nanometer;
        else if (u == "km") factor = CLHEP::kilometer;
        else if (u == "deg") factor = CLHEP::degree;
        else if (u == "rad") factor = CLHEP::radian;
        else if (u == "ns") factor = CLHEP::nanosecond;
        else if (u == "s") factor = CLHEP::second;
        else if (u == "ms") factor = CLHEP::millisecond;
        else if (u == "MeV") factor = CLHEP::megaelectronvolt;
        else if (u == "eV") factor = CLHEP::electronvolt;
        else if (u == "keV") factor = CLHEP::kiloelectronvolt;
        else if (u == "GeV") factor = CLHEP::gigaelectronvolt;
        else if (u == "TeV") factor = CLHEP::teraelectronvolt;
        if (suffixOut) *suffixOut = u;
    } else if (suffixOut) {
        // Reuse previous suffix if none provided, or empty
    }

    if (factorOut) *factorOut = factor;
    return num * factor;
}

// UnitLineEdit implementation
UnitLineEdit::UnitLineEdit(QWidget* parent) : QLineEdit(parent), m_Value(0), m_Factor(1.0), m_Suffix(""), m_IsInteger(false) {
    connect(this, &QLineEdit::editingFinished, this, &UnitLineEdit::onEditingFinished);
}

void UnitLineEdit::setUnits(const QString& suffix, double factor) {
    m_Suffix = suffix;
    m_Factor = factor;
    updateText();
}

void UnitLineEdit::setValue(double val) {
    if (m_Value != val) {
        m_Value = val;
        // Suffix heuristic ONLY if it was mm and no explicit unit was given?
        // Actually, if m_Suffix is empty or we have a specific one, we should respect it.
        // The original code had a heuristic, but it's better to let property decide.
        // Let's keep it ONLY if m_Suffix was mm (legacy behavior)
        if (!m_IsInteger && m_Suffix == "mm" && std::abs(val) >= 1000.0) { m_Suffix = "m"; m_Factor = CLHEP::meter; }
        updateText();
    }
}

void UnitLineEdit::onEditingFinished() {
    double factor = m_Factor;
    QString suffix = m_Suffix;
    double parsedVal = parseWithUnits(text(), &factor, &suffix);
    if (!suffix.isEmpty()) {
        m_Suffix = suffix;
        m_Factor = factor;
    }
    if (m_IsInteger) {
        parsedVal = std::round(parsedVal);
    }
    
    if (m_Value != parsedVal) {
        m_Value = parsedVal;
        emit valueManualChanged(m_Value);
    }
    updateText();
}

void UnitLineEdit::updateText() {
    QSignalBlocker blocker(this);
    QString s;
    if (m_IsInteger) {
        s = QString::number((int)m_Value);
        if (s.isEmpty()) s = "0";
    } else {
        double displayVal = m_Value / m_Factor;
        s = QString::number(displayVal, 'g', 6);
        if (!s.contains('.') && !s.contains('e')) {
            s += ".0";
        }
    }
    if (!m_Suffix.isEmpty()) {
        s += " " + m_Suffix;
    }
    setText(s);
}

void UnitLineEdit::setIntegerOnly(bool integerOnly) {
    m_IsInteger = integerOnly;
    updateText();
}

DoublePropertyWidget::DoublePropertyWidget(Property<double>* prop, QWidget* parent)
    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
    m_Edit = new UnitLineEdit(this);
    QString units = QString::fromStdString(prop->GetUnits());
    if (!units.isEmpty()) {
        double factor = 1.0;
        parseWithUnits("1 " + units, &factor);
        m_Edit->setUnits(units, factor);
    }
    m_Edit->setValue(prop->Get());
    m_Layout->addWidget(m_Edit, 1);
    connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set(val); });
    m_Connection = uLib::Object::connect(m_Prop, &Property<double>::PropertyChanged, [this](){
        m_Edit->setValue(m_Prop->Get());
    });
}

FloatPropertyWidget::FloatPropertyWidget(Property<float>* prop, QWidget* parent)
    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
    m_Edit = new UnitLineEdit(this);
    QString units = QString::fromStdString(prop->GetUnits());
    if (!units.isEmpty()) {
        double factor = 1.0;
        parseWithUnits("1 " + units, &factor);
        m_Edit->setUnits(units, factor);
    }
    m_Edit->setValue(prop->Get());
    m_Layout->addWidget(m_Edit, 1);
    connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set((float)val); });
    m_Connection = uLib::Object::connect(m_Prop, &Property<float>::PropertyChanged, [this](){
        m_Edit->setValue((double)m_Prop->Get());
    });
}

IntPropertyWidget::IntPropertyWidget(Property<int>* prop, QWidget* parent)
    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
    m_Edit = new UnitLineEdit(this);
    m_Edit->setIntegerOnly(true);
    QString units = QString::fromStdString(prop->GetUnits());
    if (!units.isEmpty()) {
        double factor = 1.0;
        parseWithUnits("1 " + units, &factor);
        m_Edit->setUnits(units, factor);
    }
    m_Edit->setValue(prop->Get());
    m_Layout->addWidget(m_Edit, 1);
    connect(m_Edit, &UnitLineEdit::valueManualChanged, [this](double val){ m_Prop->Set((int)val); });
    m_Connection = uLib::Object::connect(m_Prop, &Property<int>::PropertyChanged, [this](){
        m_Edit->setValue((double)m_Prop->Get());
    });
}

BoolPropertyWidget::BoolPropertyWidget(Property<bool>* prop, QWidget* parent)
    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
    m_CheckBox = new QCheckBox(this);
    m_CheckBox->setChecked(prop->Get());
    m_Layout->addWidget(m_CheckBox, 1);
    connect(m_CheckBox, &QCheckBox::toggled, [this](bool val){ if (m_Prop->Get() != val) m_Prop->Set(val); });
    m_Connection = uLib::Object::connect(m_Prop, &Property<bool>::PropertyChanged, [this](){
        if (m_CheckBox->isChecked() != m_Prop->Get()) {
            QSignalBlocker blocker(m_CheckBox);
            m_CheckBox->setChecked(m_Prop->Get());
        }
    });
}
BoolPropertyWidget::~BoolPropertyWidget() {}

StringPropertyWidget::StringPropertyWidget(Property<std::string>* prop, QWidget* parent)
    : PropertyWidgetBase(prop, parent), m_Prop(prop) {
    m_LineEdit = new QLineEdit(this);
    m_LineEdit->setText(QString::fromStdString(prop->Get()));
    m_Layout->addWidget(m_LineEdit, 1);
    connect(m_LineEdit, &QLineEdit::editingFinished, [this](){
        std::string val = m_LineEdit->text().toStdString();
        if (m_Prop->Get() != val) m_Prop->Set(val);
    });
    m_Connection = uLib::Object::connect(m_Prop, &Property<std::string>::PropertyChanged, [this](){
        if (m_LineEdit->text().toStdString() != m_Prop->Get()) {
            QSignalBlocker blocker(m_LineEdit);
            m_LineEdit->setText(QString::fromStdString(m_Prop->Get()));
        }
    });
}
StringPropertyWidget::~StringPropertyWidget() {}

class EnumPropertyWidget : public PropertyWidgetBase {
    PropertyBase* m_Prop;
    QComboBox* m_Combo;
public:
    EnumPropertyWidget(PropertyBase* prop, QWidget* parent)
        : PropertyWidgetBase(prop, parent), m_Prop(prop) {
        m_Combo = new QComboBox(this);
        const auto& labels = prop->GetEnumLabels();
        for (const auto& label : labels) {
            m_Combo->addItem(QString::fromStdString(label));
        }

        // Get initial value
        if (auto* p = dynamic_cast<Property<int>*>(prop)) {
            m_Combo->setCurrentIndex(p->Get());
            connect(m_Combo, &QComboBox::currentIndexChanged, [p](int index){
                p->Set(index);
            });
            // Store connection in base m_Connection so it's auto-disconnected on destruction.
            m_Connection = uLib::Object::connect(p, &Property<int>::PropertyChanged, [this, p](){
                if (m_Combo->currentIndex() != p->Get()) {
                    QSignalBlocker blocker(m_Combo);
                    m_Combo->setCurrentIndex(p->Get());
                }
            });
        }

        m_Layout->addWidget(m_Combo, 1);
    }
};

PropertyEditor::PropertyEditor(QWidget* parent) : QWidget(parent), m_Object(nullptr) {
    m_MainLayout = new QVBoxLayout(this);
    m_MainLayout->setContentsMargins(0, 0, 0, 0);
    m_ScrollArea = new QScrollArea(this);
    m_ScrollArea->setWidgetResizable(true);
    m_MainLayout->addWidget(m_ScrollArea);
    m_Container = new QWidget();
    m_ContainerLayout = new QVBoxLayout(m_Container);
    m_ContainerLayout->setAlignment(::Qt::AlignTop);
    m_ScrollArea->setWidget(m_Container);
    
    registerFactory<double>([](PropertyBase* p, QWidget* parent){
        return new DoublePropertyWidget(static_cast<Property<double>*>(p), parent);
    });
    registerFactory<float>([](PropertyBase* p, QWidget* parent){
        return new FloatPropertyWidget(static_cast<Property<float>*>(p), parent);
    });
    registerFactory<int>([](PropertyBase* p, QWidget* parent){
        return new IntPropertyWidget(static_cast<Property<int>*>(p), parent);
    });
    registerFactory<bool>([](PropertyBase* p, QWidget* parent){
        return new BoolPropertyWidget(static_cast<Property<bool>*>(p), parent);
    });
    registerFactory<std::string>([](PropertyBase* p, QWidget* parent){
        return new StringPropertyWidget(static_cast<Property<std::string>*>(p), parent);
    });
    
    // Register EnumProperty specifically (needs to check type since it holds Property<int> but is EnumProperty)
    m_Factories[std::type_index(typeid(EnumProperty))] = [](PropertyBase* p, QWidget* parent) {
        return new EnumPropertyWidget(p, parent);
    };

    // Vector Registration
    registerFactory<Vector2i>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector2i, 2>(static_cast<Property<Vector2i>*>(p), parent); });
    registerFactory<Vector2f>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector2f, 2>(static_cast<Property<Vector2f>*>(p), parent); });
    registerFactory<Vector2d>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector2d, 2>(static_cast<Property<Vector2d>*>(p), parent); });
    registerFactory<Vector3i>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector3i, 3>(static_cast<Property<Vector3i>*>(p), parent); });
    registerFactory<Vector3f>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector3f, 3>(static_cast<Property<Vector3f>*>(p), parent); });
    registerFactory<Vector3d>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector3d, 3>(static_cast<Property<Vector3d>*>(p), parent); });
    registerFactory<Vector4i>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector4i, 4>(static_cast<Property<Vector4i>*>(p), parent); });
    registerFactory<Vector4f>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector4f, 4>(static_cast<Property<Vector4f>*>(p), parent); });
    registerFactory<Vector4d>([](PropertyBase* p, QWidget* parent){ return new VectorPropertyWidget<Vector4d, 4>(static_cast<Property<Vector4d>*>(p), parent); });
}

PropertyEditor::~PropertyEditor() {}

void PropertyEditor::setObject(::uLib::Object* obj, bool displayOnly) {
    m_Object = obj;
    clear();
    if (!obj) return;
    
    // Choose which properties to show
    const std::vector<::uLib::PropertyBase*>* props = &obj->GetProperties();
    
    if (displayOnly) {
        if (auto* puppet = dynamic_cast<::uLib::Vtk::Puppet*>(obj)) {
            props = &puppet->GetDisplayProperties();
        } else {
            // If it's not a puppet but displayOnly is requested, showing nothing or fallback?
            // Fallback: core properties.
        }
    }

    for (auto* prop : *props) {
        // Priority 1: Check if it provides enum labels
        if (!prop->GetEnumLabels().empty()) {
            m_ContainerLayout->addWidget(new EnumPropertyWidget(prop, m_Container));
            continue;
        }

        // Priority 2: Standard factory lookup
        auto it = m_Factories.find(prop->GetTypeIndex());
        if (it != m_Factories.end()) {
            QWidget* widget = it->second(prop, m_Container);
            m_ContainerLayout->addWidget(widget);
        } else {
            // Debug info for unknown types
            std::cout << "PropertyEditor: No factory for " << prop->GetName() 
                      << " (Type: " << prop->GetTypeName() << ")" << std::endl;

            QWidget* fallback = new PropertyWidgetBase(prop, m_Container);
            fallback->layout()->addWidget(new QLabel("(Read-only: " + QString::fromStdString(prop->GetValueAsString()) + ")"));
            m_ContainerLayout->addWidget(fallback);
        }
    }
    m_ContainerLayout->addStretch(1);
}

void PropertyEditor::clear() {
    QLayoutItem* item;
    while ((item = m_ContainerLayout->takeAt(0)) != nullptr) {
        delete item->widget();
        delete item;
    }
}

} // namespace Qt
} // namespace uLib