#include "MainWindow.h"

#include <qtabwidget.h>
#include "utils/UiLayoutManager.h"

#include "PropertyBrowser.h"
#include "ModelBrowser.h"
#include "ModelBrowser/PresetModelPanel.h"
#include "DockWidget.h"

#include "viewer/QtOsgViewWidget.h"
#include "viewer/OsgViewer.h"

#include "chartPlot/FitCurveDialog.h"
#include "chartPlot/SurfaceDialog.h"
#include "Layout/LayoutSettingUI.h"
#include "Layout/SignalIndicatorLampUI.h"
#include "Layout/AddParamSetting.h"
#include "Layout/CodeEdtUI.h"

#include "Table/targetlistwgt.h"
#include "common/RecourceHelper.h"

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

#include "Matlab/MatlabObject.h"

#include "Panel/DataPanelManager.h"

#include "ui_MainWindow.h"
#include "viewer/OsgWidget.h"
#include "DockTitleBar.h"

MainWindow::MainWindow(QWidget* parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow) {
    ui->setupUi(this);
    setMinimumSize(800, 600);

    LOG_INFO("MainWindow::MainWindow - Constructor called, about to call InitUI");
    InitUI();
    LOG_INFO("MainWindow::MainWindow - Constructor completed");
}

MainWindow::~MainWindow() {
	UninitUI();
    delete ui;
}

void MainWindow::InitUI() {
    LOG_INFO("MainWindow::InitUI - Function started");
    
    QWidget* centralWidget = takeCentralWidget();
    if (nullptr != centralWidget) {
        delete centralWidget;
    }
    setDockNestingEnabled(true);

    setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
    setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
    setDockOptions(QMainWindow::AllowTabbedDocks | QMainWindow::AllowNestedDocks | QMainWindow::AnimatedDocks);

    DockWidget* model = new DockWidget(tr("model elements"), 0);
    model->SetDockWidgetTitleBar(new DockTitleBar(model));
    model->setObjectName("Dock.ModelBrowser");
    modelBrowser_ = new ModelBrowser(0);
    modelBrowser_->AttachDock(model);
    mapDockWidget_.insert("ModelBrowser", model);
	addDockWidget(Qt::LeftDockWidgetArea, model);

    DockWidget* presetModel = new DockWidget(tr("preset models"), 0);
    presetModel->SetDockWidgetTitleBar(new DockTitleBar(presetModel));
    presetModel->setObjectName("Dock.PresetModelPanel");
    presetModelPanel_ = new PresetModelPanel(0);
    presetModelPanel_->AttachDock(presetModel);
	addDockWidget(Qt::LeftDockWidgetArea, presetModel);
    mapDockWidget_.insert("PresetModelPanel", presetModel);

    DockWidget* attribte = new DockWidget(tr("attribte"), 0);
    attribte->SetDockWidgetTitleBar(new DockTitleBar(attribte));
    attribte->setObjectName("Dock.PropertyBrowser");
    propertyBrowser_ = new PropertyBrowser(0);
    propertyBrowser_->AttachDock(attribte);
    mapDockWidget_.insert("PropertyBrowser", attribte);
    addDockWidget(Qt::RightDockWidgetArea, attribte);

    // Set an initial width for the property dock (no max constraint),
    // this serves as default when there is no saved layout yet.
    {
        const int totalWidth = qMax(800, this->width());
        const int initialPropWidth = qBound(240, totalWidth / 4, 480); // ~25% of window, within [240, 480]
        QList<QDockWidget*> docksProp;
        QList<int> sizesProp;
        docksProp << attribte; sizesProp << initialPropWidth;
        resizeDocks(docksProp, sizesProp, Qt::Horizontal);
    }

    connect(modelBrowser_, &ModelBrowser::WorkSpaceChange, propertyBrowser_, &PropertyBrowser::OnWorkSpaceChange);
    connect(modelBrowser_, &ModelBrowser::EntityChange, propertyBrowser_, &PropertyBrowser::OnEntityChange);
    connect(modelBrowser_, &ModelBrowser::FileEntryChange, propertyBrowser_, &PropertyBrowser::OnFileEntryChange);
    connect(modelBrowser_, &ModelBrowser::GroupChange, propertyBrowser_, &PropertyBrowser::OnGroupChange);

    qtOsgViewWidget_ = new OsgWidget(0);
    qtOsgViewWidget_->Initialize();

    DockWidget* mainView = new DockWidget(tr("Main View"), 0);
    mainView->SetDockWidgetTitleBar(new DockTitleBar(mainView));
    mainView->setObjectName("Dock.MainView");
    qtOsgViewWidget_->AttachDock(mainView);
    mapDockWidget_.insert("MainView", mainView);
    addDockWidget(Qt::RightDockWidgetArea, mainView);

    splitDockWidget(model, mainView, Qt::Horizontal);

	tabifyDockWidget(model, presetModel);

    dataPanelManager_ = new DataPanelManager(this, this);
    
    connect(&WorkSpaceManager::Get(), &WorkSpaceManager::WorkSpaceChanged,
            dataPanelManager_, &DataPanelManager::OnWorkspaceChanged);

    // Restore previous UI layout if available
    LOG_INFO("MainWindow::InitUI - About to call UiLayoutManager::Restore");
    UiLayoutManager::Restore(this, 1);
    LOG_INFO("MainWindow::InitUI - UiLayoutManager::Restore completed");

    // After restore, if the main view is too small, expand it
    {
        QDockWidget* mainViewDock = mapDockWidget_.value("MainView", nullptr);
        QDockWidget* modelDock = mapDockWidget_.value("ModelBrowser", nullptr);
        QDockWidget* propertyDock = mapDockWidget_.value("PropertyBrowser", nullptr);
        if (mainViewDock) {
            // Use percentage-based allocation instead of fixed pixel values
            const int totalWidth = this->width();
            const int modelBrowserWidth = qMin(280, totalWidth / 6);  // ~15% or max 280px
            const int propertyBrowserWidth = qMin(320, totalWidth / 4);  // ~25% or max 320px
            const int mainViewMinWidth = totalWidth - modelBrowserWidth - propertyBrowserWidth - 50; // Reserve some margin
            
            // Only resize if main view is too small (less than 50% of available space)
            if (mainViewDock->width() < mainViewMinWidth * 0.5) {
                QList<QDockWidget*> docks;
                QList<int> sizes;
                if (modelDock) { docks << modelDock; sizes << modelBrowserWidth; }
                docks << mainViewDock; sizes << mainViewMinWidth;
                resizeDocks(docks, sizes, Qt::Horizontal);
            }
        }

        // Defer setting an initial width for the property dock once, without constraining max width
        if (propertyDock) {
            QDockWidget* capturedDock = propertyDock;
            QMetaObject::invokeMethod(this, [this, capturedDock]() {
                QDockWidget* pd = capturedDock;
                if (!pd) return;
                const int totalW = this->width();
                const int desired = qBound(240, totalW / 4, 480); // ~25% of window
                LOG_INFO("PropertyDock pre-adjust width=%d, desired=%d, windowW=%d", pd->width(), desired, totalW);
                const int oldMin = pd->minimumWidth();
                const int oldMax = pd->maximumWidth();
                pd->setMinimumWidth(desired);
                pd->setMaximumWidth(desired);
                QList<QDockWidget*> docksProp; QList<int> sizesProp;
                docksProp << pd; sizesProp << desired;
                resizeDocks(docksProp, sizesProp, Qt::Horizontal);
                pd->setMinimumWidth(oldMin > 0 ? oldMin : 240);
                pd->setMaximumWidth(QWIDGETSIZE_MAX);
                LOG_INFO("PropertyDock post-adjust width=%d (min=%d,max=%d)", pd->width(), pd->minimumWidth(), pd->maximumWidth());
            }, Qt::QueuedConnection);
        }
    }

    qtOsgViewWidget_->LoadDefaultScene();
#if 0
	MatlabObject::GetInstance()->RunMatlabFile("");
#endif // 1
}

void MainWindow::UninitUI() {
    // Save layout state before tearing down widgets
    UiLayoutManager::Save(this, 1);
    
    if (dataPanelManager_) {
        delete dataPanelManager_;
        dataPanelManager_ = nullptr;
    }
    
    if (qtOsgViewWidget_) {
        qtOsgViewWidget_->Uninitialize();
        delete qtOsgViewWidget_;
        qtOsgViewWidget_ = nullptr;
	}
}