#include "stdafx.h"
#include "Mainfrm.h"
#include "Resource.h"
#include "ProviderDlg.h"
#include "core/resize.hpp"
#include "core/transform.hpp"
#include "win/settings_store.hpp"
#include <shlobj.h>
#include <filesystem>
#include <fstream>
#include <sstream>
#include <UIRibbon.h>

namespace fs = std::filesystem;
using json = nlohmann::json;

static std::string wide_to_utf8(const std::wstring& w) {
    if (w.empty()) return {};
    int n = WideCharToMultiByte(CP_UTF8, 0, w.c_str(), (int)w.size(), nullptr, 0, nullptr, nullptr);
    if (n <= 0) return {};
    std::string s(n, '\0');
    WideCharToMultiByte(CP_UTF8, 0, w.c_str(), (int)w.size(), s.data(), n, nullptr, nullptr);
    return s;
}

static std::wstring utf8_to_wide_mf(const std::string& s) {
    if (s.empty()) return {};
    int n = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), (int)s.size(), nullptr, 0);
    if (n <= 0) return {};
    std::wstring w(n, L'\0');
    MultiByteToWideChar(CP_UTF8, 0, s.c_str(), (int)s.size(), w.data(), n);
    return w;
}

CMainFrame::CMainFrame()
{
    try {
        m_settingsPath = media::settings::get_settings_json_path().string();
    } catch (...) {
        m_settingsPath = (fs::current_path() / "settings.json").string();
    }
    LoadPresets();
}

void CMainFrame::LogMessage(const CString& msg)
{
    if (m_pDockLog)
        m_pDockLog->GetLogContainer().GetLogView().AppendLine(msg);
}

HWND CMainFrame::Create(HWND parent)
{
    SetView(m_view);
    LoadRegistrySettings(L"Polymech\\pm-image-ui");
    return CRibbonDockFrame::Create(parent);
}

void CMainFrame::SwitchSettingsMode(CSettingsView::Mode mode)
{
    if (!m_pDockSettings) return;
    auto& sv = m_pDockSettings->GetSettingsContainer().GetSettingsView();
    if (sv.GetMode() == mode) return;
    sv.SetMode(mode);
    const wchar_t* caption = (mode == CSettingsView::MODE_RESIZE)
        ? L"Resize Settings" : L"Settings";
    m_pDockSettings->GetSettingsContainer().SetDockCaption(caption);
    m_pDockSettings->GetSettingsContainer().SetTabText(
        (mode == CSettingsView::MODE_RESIZE) ? L"Resize" : L"Settings");
    m_pDockSettings->GetSettingsContainer().Invalidate();
    m_pDockSettings->RedrawWindow();
}

STDMETHODIMP CMainFrame::Execute(UINT32 cmdID, UI_EXECUTIONVERB verb,
    const PROPERTYKEY*, const PROPVARIANT*, IUISimplePropertySet*)
{
    if (verb == UI_EXECUTIONVERB_EXECUTE) {
        switch (cmdID) {
        case IDC_CMD_ADD_FILES:  OnAddFiles();   break;
        case IDC_CMD_ADD_FOLDER: OnAddFolder();  break;
        case IDC_CMD_CLEAR:      OnClearQueue(); break;
        case IDC_CMD_SAVE_AS:    OnSaveAs();     break;
        case IDC_CMD_RESIZE:
            SwitchSettingsMode(CSettingsView::MODE_RESIZE);
            OnResize();
            break;
        case IDC_CMD_PROMPT:
            SwitchSettingsMode(CSettingsView::MODE_TRANSFORM);
            OnPrompt();
            break;
        case IDC_CMD_RUN:
            SwitchSettingsMode(CSettingsView::MODE_TRANSFORM);
            OnRun();
            break;
        case IDC_CMD_PRESETS:         OnPresets();               break;
        case IDC_CMD_PROVIDER_KEYS:   ShowProviderSettingsDlg(GetHwnd()); break;
        case IDC_CMD_ABOUT:           OnHelp();                  break;
        case IDC_CMD_EXIT:       OnExit();       break;
        case IDC_RIBBONHELP:     OnHelp();       break;

        // Model toggle
        case IDC_CMD_MODEL_PRO:
        case IDC_CMD_MODEL_FLASH:
            HandleModelSelect(cmdID);
            break;

        // Aspect toggle
        case IDC_CMD_ASPECT_AUTO:
        case IDC_CMD_ASPECT_1_1:
        case IDC_CMD_ASPECT_3_2:
        case IDC_CMD_ASPECT_4_3:
        case IDC_CMD_ASPECT_16_9:
        case IDC_CMD_ASPECT_9_16:
            HandleAspectSelect(cmdID);
            break;

        // Size toggle
        case IDC_CMD_SIZE_DEFAULT:
        case IDC_CMD_SIZE_1K:
        case IDC_CMD_SIZE_2K:
        case IDC_CMD_SIZE_4K:
            HandleSizeSelect(cmdID);
            break;

        // View panel toggles — each knows its parent and dock side
        case IDC_CMD_VIEW_QUEUE:
            TogglePanelView(m_pDockQueue, DS_DOCKED_BOTTOM,
                GetDockAncestor(), DpiScaleInt(220), IDC_CMD_VIEW_QUEUE);
            break;
        case IDC_CMD_VIEW_LOG:
            TogglePanelView(m_pDockLog, DS_DOCKED_RIGHT,
                m_pDockQueue, DpiScaleInt(360), IDC_CMD_VIEW_LOG);
            break;
        case IDC_CMD_VIEW_SETTINGS:
            TogglePanelView(m_pDockSettings, DS_DOCKED_RIGHT,
                GetDockAncestor(), DpiScaleInt(280), IDC_CMD_VIEW_SETTINGS);
            break;
        case IDC_CMD_VIEW_FILEINFO:
            TogglePanelView(m_pDockFileInfo, DS_DOCKED_BOTTOM,
                m_pDockGenPreview, DpiScaleInt(160), IDC_CMD_VIEW_FILEINFO);
            break;
        case IDC_CMD_VIEW_GENPREVIEW:
            TogglePanelView(m_pDockGenPreview, DS_DOCKED_BOTTOM,
                m_pDockSettings, DpiScaleInt(200), IDC_CMD_VIEW_GENPREVIEW);
            break;

        case IDC_CMD_RESET_LAYOUT:
            ResetLayout();
            break;
        case IDC_CMD_DEBUG_STATE:
            DebugDockState();
            break;

        default: break;
        }
    }

    if (cmdID == cmdTabHome)
        SwitchSettingsMode(CSettingsView::MODE_RESIZE);
    else if (cmdID == cmdTabAI)
        SwitchSettingsMode(CSettingsView::MODE_TRANSFORM);

    return S_OK;
}

STDMETHODIMP CMainFrame::OnViewChanged(UINT32, UI_VIEWTYPE typeId,
    IUnknown* pView, UI_VIEWVERB verb, INT32)
{
    if (typeId == UI_VIEWTYPE_RIBBON) {
        switch (verb) {
        case UI_VIEWVERB_CREATE:
            m_pIUIRibbon = reinterpret_cast<IUIRibbon*>(pView);
            return S_OK;
        case UI_VIEWVERB_SIZE:
            RecalcLayout();
            return S_OK;
        case UI_VIEWVERB_DESTROY:
            m_pIUIRibbon = nullptr;
            return S_OK;
        case UI_VIEWVERB_ERROR:
            return E_FAIL;
        }
    }
    return E_NOTIMPL;
}

STDMETHODIMP CMainFrame::UpdateProperty(UINT32 cmdID, REFPROPERTYKEY key,
    const PROPVARIANT* currentValue, PROPVARIANT* newValue)
{
    if (key == UI_PKEY_BooleanValue) {
        newValue->vt = VT_BOOL;
        newValue->boolVal = IsToggleSelected(cmdID) ? VARIANT_TRUE : VARIANT_FALSE;
        return S_OK;
    }
    return CRibbonDockFrame::UpdateProperty(cmdID, key, currentValue, newValue);
}

void CMainFrame::InvalidateToggle(UINT32 cmdID)
{
    IUIFramework* pFW = GetRibbonFramework();
    if (pFW)
        pFW->InvalidateUICommand(cmdID, UI_INVALIDATIONS_PROPERTY, &UI_PKEY_BooleanValue);
}

bool CMainFrame::IsToggleSelected(UINT32 cmdID) const
{
    if (cmdID == m_selModel || cmdID == m_selAspect || cmdID == m_selSize)
        return true;

    // View panel toggles reflect current visibility
    switch (cmdID) {
    case IDC_CMD_VIEW_QUEUE:      return IsPanelVisible(m_pDockQueue);
    case IDC_CMD_VIEW_LOG:        return IsPanelVisible(m_pDockLog);
    case IDC_CMD_VIEW_SETTINGS:   return IsPanelVisible(m_pDockSettings);
    case IDC_CMD_VIEW_FILEINFO:   return IsPanelVisible(m_pDockFileInfo);
    case IDC_CMD_VIEW_GENPREVIEW: return IsPanelVisible(m_pDockGenPreview);
    }
    return false;
}

void CMainFrame::HandleModelSelect(UINT32 cmdID)
{
    UINT32 prev = m_selModel;
    m_selModel = cmdID;
    InvalidateToggle(prev);
    InvalidateToggle(cmdID);
}

void CMainFrame::HandleAspectSelect(UINT32 cmdID)
{
    UINT32 prev = m_selAspect;
    m_selAspect = cmdID;
    InvalidateToggle(prev);
    InvalidateToggle(cmdID);
}

void CMainFrame::HandleSizeSelect(UINT32 cmdID)
{
    UINT32 prev = m_selSize;
    m_selSize = cmdID;
    InvalidateToggle(prev);
    InvalidateToggle(cmdID);
}

media::TransformOptions CMainFrame::BuildTransformOptions() const
{
    media::TransformOptions opts;
    switch (m_selModel) {
    case IDC_CMD_MODEL_PRO:   opts.model = "gemini-3-pro-image-preview"; break;
    case IDC_CMD_MODEL_FLASH: opts.model = "gemini-3.1-flash-image-preview"; break;
    }
    switch (m_selAspect) {
    case IDC_CMD_ASPECT_AUTO:  opts.aspect_ratio = ""; break;
    case IDC_CMD_ASPECT_1_1:   opts.aspect_ratio = "1:1"; break;
    case IDC_CMD_ASPECT_3_2:   opts.aspect_ratio = "3:2"; break;
    case IDC_CMD_ASPECT_4_3:   opts.aspect_ratio = "4:3"; break;
    case IDC_CMD_ASPECT_16_9:  opts.aspect_ratio = "16:9"; break;
    case IDC_CMD_ASPECT_9_16:  opts.aspect_ratio = "9:16"; break;
    }
    switch (m_selSize) {
    case IDC_CMD_SIZE_DEFAULT: opts.image_size = ""; break;
    case IDC_CMD_SIZE_1K:      opts.image_size = "1K"; break;
    case IDC_CMD_SIZE_2K:      opts.image_size = "2K"; break;
    case IDC_CMD_SIZE_4K:      opts.image_size = "4K"; break;
    }
    return opts;
}

BOOL CMainFrame::OnCommand(WPARAM wparam, LPARAM)
{
    switch (LOWORD(wparam)) {
    case IDM_ADD_FILES:    OnAddFiles();   return TRUE;
    case IDM_ADD_FOLDER:   OnAddFolder();  return TRUE;
    case IDM_CLEAR_QUEUE:  OnClearQueue(); return TRUE;
    case IDM_RESIZE:       OnResize();     return TRUE;
    case IDM_EXIT:         OnExit();       return TRUE;
    case IDM_ABOUT:        return OnHelp();
    case IDW_VIEW_STATUSBAR: return OnViewStatusBar();
    case IDW_VIEW_TOOLBAR:   return OnViewToolBar();
    }
    return FALSE;
}

BOOL CMainFrame::OnHelp()
{
    ::MessageBox(GetHwnd(), L"pm-image \u2014 resize & transform\nWin32++ UI",
                 L"About pm-image", MB_ICONINFORMATION | MB_OK);
    return TRUE;
}

// Called by LoadDockRegistrySettings() to instantiate the right CDocker subclass.
// Do NOT store the raw pointer here — Win32++ may call CloseAllDockers() on failure
// which deletes the objects and leaves our stored pointers dangling.
// Member pointers are fetched safely via GetDockFromID() after a successful load.
DockPtr CMainFrame::NewDockerFromID(int id)
{
    switch (id) {
    case DOCK_ID_QUEUE:      return std::make_unique<CDockQueue>();
    case DOCK_ID_LOG:        return std::make_unique<CDockLog>();
    case DOCK_ID_SETTINGS:   return std::make_unique<CDockSettings>();
    case DOCK_ID_GENPREVIEW: return std::make_unique<CDockGenPreview>();
    case DOCK_ID_FILEINFO:   return std::make_unique<CDockFileInfo>();
    }
    return nullptr;
}

// Apply container single-tab hiding to any non-null panel pointer.
static void SetupDockContainers(CDockQueue* q, CDockLog* l, CDockSettings* s,
                                CDockGenPreview* gp, CDockFileInfo* fi)
{
    if (q)  q->GetQueueContainer().SetHideSingleTab(TRUE);
    if (l)  l->GetLogContainer().SetHideSingleTab(TRUE);
    if (s)  s->GetSettingsContainer().SetHideSingleTab(TRUE);
    if (gp) gp->GetContainer().SetHideSingleTab(TRUE);
    if (fi) fi->GetInfoContainer().SetHideSingleTab(TRUE);
}

// Helper: build the hardcoded default panel hierarchy.
void CMainFrame::BuildDefaultDockLayout()
{
    CloseAllDockers();   // clear any partial state Win32++ might have
    m_pDockQueue = nullptr; m_pDockLog = nullptr; m_pDockSettings = nullptr;
    m_pDockGenPreview = nullptr; m_pDockFileInfo = nullptr;

    auto pDockQ = AddDockedChild(std::make_unique<CDockQueue>(),
                                 DS_DOCKED_BOTTOM, DpiScaleInt(220), DOCK_ID_QUEUE);
    m_pDockQueue = static_cast<CDockQueue*>(pDockQ);

    auto pDockL = m_pDockQueue->AddDockedChild(std::make_unique<CDockLog>(),
                                               DS_DOCKED_RIGHT, DpiScaleInt(360), DOCK_ID_LOG);
    m_pDockLog = static_cast<CDockLog*>(pDockL);

    auto pDockS = AddDockedChild(std::make_unique<CDockSettings>(),
                                 DS_DOCKED_RIGHT, DpiScaleInt(280), DOCK_ID_SETTINGS);
    m_pDockSettings = static_cast<CDockSettings*>(pDockS);

    auto pDockGP = m_pDockSettings->AddDockedChild(std::make_unique<CDockGenPreview>(),
                                                   DS_DOCKED_BOTTOM, DpiScaleInt(200), DOCK_ID_GENPREVIEW);
    m_pDockGenPreview = static_cast<CDockGenPreview*>(pDockGP);

    auto pDockFI = m_pDockGenPreview->AddDockedChild(std::make_unique<CDockFileInfo>(),
                                                     DS_DOCKED_BOTTOM, DpiScaleInt(160), DOCK_ID_FILEINFO);
    m_pDockFileInfo = static_cast<CDockFileInfo*>(pDockFI);
}

void CMainFrame::OnInitialUpdate()
{
    // Member pointers start null; they are set after a confirmed successful load
    // (NOT inside NewDockerFromID, where they would dangle if Win32++ rolls back).
    m_pDockQueue = nullptr; m_pDockLog = nullptr; m_pDockSettings = nullptr;
    m_pDockGenPreview = nullptr; m_pDockFileInfo = nullptr;

    bool fromRegistry = false;
    try {
        // Attempt to restore the full dock topology (parent, style, size, floating
        // rect, hidden state) from the Win32++ registry key saved at WM_CLOSE.
        fromRegistry = LoadDockRegistrySettings(L"Polymech\\pm-image-ui");

        if (fromRegistry) {
            // Fetch member pointers by dock ID now that all dockers are safely alive.
            // GetDockFromID walks the m_allDockers list built by LoadDockRegistrySettings.
            m_pDockQueue      = static_cast<CDockQueue*>     (GetDockFromID(DOCK_ID_QUEUE));
            m_pDockLog        = static_cast<CDockLog*>       (GetDockFromID(DOCK_ID_LOG));
            m_pDockSettings   = static_cast<CDockSettings*>  (GetDockFromID(DOCK_ID_SETTINGS));
            m_pDockGenPreview = static_cast<CDockGenPreview*>(GetDockFromID(DOCK_ID_GENPREVIEW));
            m_pDockFileInfo   = static_cast<CDockFileInfo*>  (GetDockFromID(DOCK_ID_FILEINFO));

            // If any panel is missing the registry save is incomplete — fall back.
            if (!m_pDockQueue || !m_pDockLog || !m_pDockSettings ||
                !m_pDockGenPreview || !m_pDockFileInfo)
            {
                LogMessage(L"[Layout] Registry restore incomplete — using default layout.");
                fromRegistry = false;
            }
        }
    }
    catch (const std::exception& ex) {
        LogMessage(CString(L"[Layout] Registry restore threw: ") + ex.what());
        fromRegistry = false;
    }
    catch (...) {
        LogMessage(L"[Layout] Registry restore threw unknown exception.");
        fromRegistry = false;
    }

    if (!fromRegistry) {
        // Delete the stale/bad registry key so the next launch starts clean.
        const CString appKey = _T("Software\\Polymech\\pm-image-ui");
        CRegKey k;
        if (ERROR_SUCCESS == k.Open(HKEY_CURRENT_USER, appKey))
            k.RecurseDeleteKey(_T("Dock Settings"));

        BuildDefaultDockLayout();
    }

    SetupDockContainers(m_pDockQueue, m_pDockLog, m_pDockSettings, m_pDockGenPreview, m_pDockFileInfo);

    // Modern flat dock caption styling (null-safe).
    COLORREF capBg    = RGB(240, 240, 240);
    COLORREF capFg    = RGB(68, 68, 68);
    COLORREF capBgInv = RGB(240, 240, 240);
    COLORREF capFgInv = RGB(140, 140, 140);
    COLORREF capPen   = RGB(220, 220, 220);
    auto styleDocker = [&](CDocker* d) {
        if (!d) return;
        d->SetCaptionColors(capFg, capBg, capFgInv, capBgInv, capPen);
        d->SetCaptionHeight(22);
    };
    styleDocker(m_pDockQueue);
    styleDocker(m_pDockLog);
    styleDocker(m_pDockSettings);
    styleDocker(m_pDockGenPreview);
    styleDocker(m_pDockFileInfo);

    DragAcceptFiles(TRUE);
    SetWindowText(L"pm-image");
    GetStatusBar().SetPartText(0, L"Drop files or use Add Files to begin.");

    // Restore window placement and dock sizes saved from last session.
    // Must run after all docks are created so SetDockSize is valid.
    LoadLayout();
}

void CMainFrame::SetupToolBar()
{
    // Toolbar is unused — the ribbon provides all commands.
    // Leaving this empty avoids the IDW_MAIN BITMAP resource requirement.
}

void CMainFrame::OnAddFiles()
{
    CFileDialog dlg(TRUE, nullptr, nullptr,
                    OFN_FILEMUSTEXIST | OFN_ALLOWMULTISELECT | OFN_EXPLORER,
                    L"Images (*.jpg;*.jpeg;*.png;*.webp;*.tif;*.tiff;*.bmp;*.gif;*.avif;*.heic)\0"
                    L"*.jpg;*.jpeg;*.png;*.webp;*.tif;*.tiff;*.bmp;*.gif;*.avif;*.heic\0"
                    L"All Files (*.*)\0*.*\0\0");
    dlg.SetTitle(L"Add images to queue");

    if (dlg.DoModal(*this) != IDOK) return;

    std::vector<std::wstring> files;
    int pos = 0;
    CString path = dlg.GetNextPathName(pos);
    while (!path.IsEmpty()) {
        files.push_back(std::wstring(path.c_str()));
        if (pos < 0) break;
        path = dlg.GetNextPathName(pos);
    }
    AddFilesToQueue(files);
}

void CMainFrame::OnAddFolder()
{
    BROWSEINFOW bi{};
    bi.hwndOwner = GetHwnd();
    bi.lpszTitle = L"Select folder with images";
    bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_NEWDIALOGSTYLE;
    wchar_t dn[MAX_PATH]{};
    bi.pszDisplayName = dn;
    PIDLIST_ABSOLUTE pidl = SHBrowseForFolderW(&bi);
    if (!pidl) return;
    wchar_t path[MAX_PATH * 4]{};
    if (SHGetPathFromIDListW(pidl, path)) {
        std::vector<std::wstring> v = { path };
        AddFilesToQueue(v);
    }
    CoTaskMemFree(pidl);
}

void CMainFrame::AddFilesToQueue(const std::vector<std::wstring>& paths)
{
    if (!m_pDockQueue) return;
    auto& lv = m_pDockQueue->GetQueueContainer().GetListView();

    bool firstAdded = (lv.QueueCount() == 0);
    int firstNewIdx = lv.QueueCount();

    for (auto& p : paths) {
        std::error_code ec;
        fs::path fp(p);
        if (fs::is_directory(fp, ec)) {
            for (auto& entry : fs::recursive_directory_iterator(fp,
                    fs::directory_options::skip_permission_denied, ec)) {
                if (!entry.is_regular_file()) continue;
                std::wstring ext = entry.path().extension().wstring();
                for (auto& c : ext) c = static_cast<wchar_t>(towlower(c));
                if (ext == L".jpg" || ext == L".jpeg" || ext == L".png" || ext == L".webp" ||
                    ext == L".tif" || ext == L".tiff" || ext == L".bmp" || ext == L".gif" ||
                    ext == L".avif" || ext == L".heic") {
                    lv.AddFile(CString(entry.path().c_str()));
                }
            }
        } else {
            lv.AddFile(CString(fp.c_str()));
        }
    }

    CString status;
    status.Format(L"%d file(s) in queue", lv.QueueCount());
    GetStatusBar().SetPartText(0, status);

    if (firstAdded && lv.QueueCount() > 0) {
        CString firstPath = lv.GetItemPath(firstNewIdx);
        m_view.LoadPicture(firstPath.c_str());
    }
}

void CMainFrame::OnClearQueue()
{
    if (m_pDockQueue) {
        m_pDockQueue->GetQueueContainer().GetListView().ClearAll();
        m_view.ClearPicture();
        GetStatusBar().SetPartText(0, L"Queue cleared.");
    }
}

void CMainFrame::OnSaveAs()
{
    if (!m_pDockQueue) return;
    auto& lv = m_pDockQueue->GetQueueContainer().GetListView();

    // Use the first selected item, fall back to first item.
    auto sel = GetSelectedQueueItems();
    int idx = sel.empty() ? 0 : sel.front();
    if (idx < 0 || idx >= lv.QueueCount()) {
        ::MessageBoxW(GetHwnd(), L"No file selected in the queue.", L"Save As", MB_ICONINFORMATION);
        return;
    }

    CString srcPath = lv.GetItemPath(idx);
    if (srcPath.IsEmpty()) return;

    // Derive a suggested filename from the source path.
    fs::path src(srcPath.c_str());
    std::wstring suggestedName = src.filename().wstring();
    std::wstring ext           = src.extension().wstring();
    // ext includes the dot, e.g. L".jpg"
    if (ext.empty()) ext = L".*";

    // Build the filter string: "JPEG Files (*.jpg)\0*.jpg\0All Files (*.*)\0*.*\0"
    // We need a double-null-terminated sequence.
    std::wstring extNoDot = ext.size() > 1 ? ext.substr(1) : L"*";
    std::wstring extUpper = extNoDot;
    for (auto& c : extUpper) c = towupper(c);

    wchar_t filter[256] = {};
    int fpos = 0;
    auto appendStr = [&](const std::wstring& s) {
        for (wchar_t c : s) filter[fpos++] = c;
        filter[fpos++] = L'\0';
    };
    appendStr(extUpper + L" Files (*." + extNoDot + L")");
    appendStr(L"*." + extNoDot);
    appendStr(L"All Files (*.*)");
    appendStr(L"*.*");

    wchar_t destPath[MAX_PATH] = {};
    wcscpy_s(destPath, suggestedName.c_str());

    OPENFILENAMEW ofn{};
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner   = GetHwnd();
    ofn.lpstrFilter = filter;
    ofn.lpstrFile   = destPath;
    ofn.nMaxFile    = MAX_PATH;
    ofn.lpstrTitle  = L"Save As";
    ofn.Flags       = OFN_OVERWRITEPROMPT | OFN_PATHMUSTEXIST | OFN_NOCHANGEDIR;
    ofn.lpstrDefExt = extNoDot.c_str();

    if (!::GetSaveFileNameW(&ofn))
        return;  // user cancelled

    std::error_code ec;
    fs::copy_file(src, fs::path(destPath), fs::copy_options::overwrite_existing, ec);
    if (ec) {
        std::wstring msg = L"Copy failed: " + utf8_to_wide_mf(ec.message());
        ::MessageBoxW(GetHwnd(), msg.c_str(), L"Save As", MB_ICONERROR);
    } else {
        CString log;
        log.Format(L"Saved: %s", destPath);
        LogMessage(log);
        GetStatusBar().SetPartText(0, log);
    }
}

void CMainFrame::OnResize()
{
    if (m_processing) {
        ::MessageBox(GetHwnd(), L"Already processing.", L"pm-image", MB_ICONWARNING);
        return;
    }
    if (!m_pDockQueue || !m_pDockSettings) return;

    auto& lv = m_pDockQueue->GetQueueContainer().GetListView();
    int count = lv.QueueCount();
    if (count == 0) {
        ::MessageBox(GetHwnd(), L"Queue is empty \u2014 drop files first.", L"pm-image", MB_ICONINFORMATION);
        return;
    }

    media::ResizeOptions opt;
    std::string out_dir;
    m_pDockSettings->GetSettingsContainer().GetSettingsView().ReadOptions(opt, out_dir);

    std::vector<std::pair<int, std::string>> items;
    items.reserve(count);
    for (int i = 0; i < count; ++i) {
        CString p = lv.GetItemPath(i);
        items.emplace_back(i, wide_to_utf8(std::wstring(p.c_str())));
    }

    m_processing = true;
    HWND hwnd = GetHwnd();

    LogMessage(L"--- Resize started ---");
    CString rinfo;
    rinfo.Format(L"%d file(s)  |  Max: %dx%d  |  Q: %d",
        (int)items.size(), opt.max_width, opt.max_height, opt.quality);
    LogMessage(rinfo);

    m_worker = std::thread([items = std::move(items), opt, out_dir, hwnd]() mutable {
        int ok = 0, fail = 0;
        for (auto& [idx, input] : items) {
            ::PostMessage(hwnd, UWM_QUEUE_PROGRESS, (WPARAM)idx, 1);
            std::string output_path;
            if (!out_dir.empty()) {
                namespace fs2 = std::filesystem;
                fs2::path op = fs2::path(out_dir) / fs2::path(input).filename();
                output_path = op.string();
                std::error_code ec2;
                fs2::create_directories(fs2::path(out_dir), ec2);
            } else {
                output_path = input;
            }

            std::string err;
            bool success = media::resize_file(input, output_path, opt, err);
            ::PostMessage(hwnd, UWM_QUEUE_PROGRESS, (WPARAM)idx, success ? 2 : 3);
            if (success) ++ok; else ++fail;
        }
        ::PostMessage(hwnd, UWM_QUEUE_DONE, (WPARAM)ok, (LPARAM)fail);
    });
    m_worker.detach();

    GetStatusBar().SetPartText(0, L"Resizing\u2026");
}

std::vector<int> CMainFrame::GetSelectedQueueItems()
{
    std::vector<int> sel;
    if (!m_pDockQueue) return sel;
    auto& lv = m_pDockQueue->GetQueueContainer().GetListView();
    int idx = -1;
    while ((idx = lv.GetNextItem(idx, LVNI_SELECTED)) != -1)
        sel.push_back(idx);
    if (sel.empty()) {
        int total = lv.QueueCount();
        for (int i = 0; i < total; ++i) sel.push_back(i);
    }
    return sel;
}

static INT_PTR CALLBACK PromptDlgProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
{
    switch (msg) {
    case WM_INITDIALOG: {
        ::SetWindowLongPtr(hwnd, GWLP_USERDATA, lp);
        auto* prompt = reinterpret_cast<std::wstring*>(lp);
        if (!prompt->empty())
            ::SetDlgItemTextW(hwnd, IDC_EDIT_PROMPT, prompt->c_str());

        RECT rc;
        ::GetClientRect(hwnd, &rc);
        int w = rc.right - rc.left, h = rc.bottom - rc.top;
        int margin = 10;

        HWND hLabel = ::GetDlgItem(hwnd, IDC_STATIC_PROMPT_LABEL);
        ::SetWindowPos(hLabel, nullptr, margin, margin, w - 2*margin, 20, SWP_NOZORDER);

        HWND hEdit = ::GetDlgItem(hwnd, IDC_EDIT_PROMPT);
        ::SetWindowPos(hEdit, nullptr, margin, 35, w - 2*margin, h - 80, SWP_NOZORDER);

        HWND hOk = ::GetDlgItem(hwnd, IDOK);
        HWND hCancel = ::GetDlgItem(hwnd, IDCANCEL);
        int btnW = 80, btnH = 28;
        ::SetWindowPos(hOk, nullptr, w - 2*(btnW + margin), h - btnH - margin, btnW, btnH, SWP_NOZORDER);
        ::SetWindowPos(hCancel, nullptr, w - btnW - margin, h - btnH - margin, btnW, btnH, SWP_NOZORDER);

        HFONT hFont = static_cast<HFONT>(::GetStockObject(DEFAULT_GUI_FONT));
        ::SendMessage(hLabel, WM_SETFONT, (WPARAM)hFont, TRUE);
        ::SendMessage(hEdit, WM_SETFONT, (WPARAM)hFont, TRUE);
        ::SendMessage(hOk, WM_SETFONT, (WPARAM)hFont, TRUE);
        ::SendMessage(hCancel, WM_SETFONT, (WPARAM)hFont, TRUE);

        ::SetFocus(hEdit);
        return FALSE;
    }
    case WM_COMMAND:
        if (LOWORD(wp) == IDOK) {
            auto* prompt = reinterpret_cast<std::wstring*>(::GetWindowLongPtr(hwnd, GWLP_USERDATA));
            wchar_t buf[4096]{};
            ::GetDlgItemTextW(hwnd, IDC_EDIT_PROMPT, buf, 4095);
            *prompt = buf;
            ::EndDialog(hwnd, IDOK);
            return TRUE;
        }
        if (LOWORD(wp) == IDCANCEL) {
            ::EndDialog(hwnd, IDCANCEL);
            return TRUE;
        }
        break;
    case WM_CLOSE:
        ::EndDialog(hwnd, IDCANCEL);
        return TRUE;
    }
    return FALSE;
}

static HWND CreatePromptDialog(HWND parent, std::wstring& prompt)
{
    // Build a dialog template in memory
    alignas(DWORD) BYTE buf[2048]{};
    DLGTEMPLATE* dlg = reinterpret_cast<DLGTEMPLATE*>(buf);
    dlg->style = DS_MODALFRAME | DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_VISIBLE;
    dlg->cdit = 4; // label, edit, OK, Cancel
    dlg->cx = 280; dlg->cy = 160;

    WORD* p = reinterpret_cast<WORD*>(dlg + 1);
    *p++ = 0; // menu
    *p++ = 0; // class
    // title "AI Transform - Enter Prompt"
    const wchar_t title[] = L"AI Transform - Enter Prompt";
    memcpy(p, title, sizeof(title));
    p += (sizeof(title) / sizeof(WORD));

    // Align to DWORD
    if (reinterpret_cast<uintptr_t>(p) % 4) p++;

    auto addItem = [&](DWORD style, short x, short y, short cx, short cy, WORD id, const wchar_t* cls, const wchar_t* text) {
        if (reinterpret_cast<uintptr_t>(p) % 4) p++;
        DLGITEMTEMPLATE* item = reinterpret_cast<DLGITEMTEMPLATE*>(p);
        item->style = style | WS_CHILD | WS_VISIBLE;
        item->x = x; item->y = y; item->cx = cx; item->cy = cy;
        item->id = id;
        p = reinterpret_cast<WORD*>(item + 1);
        // class
        size_t clen = wcslen(cls) + 1;
        memcpy(p, cls, clen * 2); p += clen;
        // text
        size_t tlen = wcslen(text) + 1;
        memcpy(p, text, tlen * 2); p += tlen;
        *p++ = 0; // extra
    };

    // Label
    addItem(SS_LEFT, 6, 4, 268, 10, IDC_STATIC_PROMPT_LABEL,
            L"Static", L"Describe the transformation:");
    // Multiline edit
    addItem(ES_MULTILINE | ES_AUTOVSCROLL | ES_WANTRETURN | WS_BORDER | WS_VSCROLL | WS_TABSTOP,
            6, 18, 268, 110, IDC_EDIT_PROMPT, L"Edit", L"");
    // OK button
    addItem(BS_DEFPUSHBUTTON | WS_TABSTOP, 150, 134, 56, 18, IDOK, L"Button", L"Transform");
    // Cancel button
    addItem(WS_TABSTOP, 212, 134, 56, 18, IDCANCEL, L"Button", L"Cancel");

    INT_PTR result = ::DialogBoxIndirectParam(
        ::GetModuleHandle(nullptr),
        dlg, parent, PromptDlgProc,
        reinterpret_cast<LPARAM>(&prompt));

    return (result == IDOK) ? parent : nullptr;
}

void CMainFrame::OnPrompt()
{
    std::wstring prompt = m_lastPrompt;
    if (!CreatePromptDialog(GetHwnd(), prompt))
        return;
    m_lastPrompt = prompt;
    if (!prompt.empty()) {
        CString s;
        s.Format(L"Prompt set: %.60s%s", prompt.c_str(), prompt.size() > 60 ? L"\u2026" : L"");
        GetStatusBar().SetPartText(0, s);
        LogMessage(s);
    }
}

void CMainFrame::OnRun()
{
    if (m_processing) {
        ::MessageBox(GetHwnd(), L"Already processing.", L"pm-image", MB_ICONWARNING);
        return;
    }
    if (!m_pDockQueue) return;

    auto indices = GetSelectedQueueItems();
    if (indices.empty()) {
        ::MessageBox(GetHwnd(), L"Queue is empty \u2014 drop files first.", L"pm-image", MB_ICONINFORMATION);
        return;
    }

    if (m_lastPrompt.empty()) {
        OnPrompt();
        if (m_lastPrompt.empty()) return;
    }

    std::string promptUtf8 = wide_to_utf8(m_lastPrompt);

    // Look up API key: settings store first, env var as fallback.
    std::string active_provider;
    std::string api_key = media::settings::get_active_api_key(active_provider);

    if (api_key.empty()) {
        // Legacy env-var fallback (Google only)
        const char* env_key = std::getenv("IMAGE_TRANSFORM_GOOGLE_API_KEY");
        if (env_key && env_key[0] != '\0') {
            api_key = env_key;
            active_provider = "google";
        }
    }

    if (api_key.empty()) {
        int choice = ::MessageBoxW(GetHwnd(),
            L"No API key configured.\n\nOpen the API Keys dialog now?",
            L"pm-image", MB_ICONWARNING | MB_YESNO);
        if (choice == IDYES)
            ShowProviderSettingsDlg(GetHwnd());
        return;
    }

    media::TransformOptions base_opts = BuildTransformOptions();
    base_opts.provider = active_provider;
    base_opts.prompt   = promptUtf8;
    base_opts.api_key  = api_key;

    auto& lv = m_pDockQueue->GetQueueContainer().GetListView();
    std::vector<std::pair<int, std::string>> items;
    for (int idx : indices) {
        CString p = lv.GetItemPath(idx);
        items.emplace_back(idx, wide_to_utf8(std::wstring(p.c_str())));
    }

    m_processing = true;
    HWND hwnd = GetHwnd();

    LogMessage(L"--- Transform started ---");
    CString info;
    info.Format(L"Model: %S  |  %d file(s)  |  Aspect: %S  |  Size: %S",
        base_opts.model.c_str(), (int)items.size(),
        base_opts.aspect_ratio.empty() ? "auto" : base_opts.aspect_ratio.c_str(),
        base_opts.image_size.empty() ? "default" : base_opts.image_size.c_str());
    LogMessage(info);

    m_worker = std::thread([items = std::move(items), base_opts, hwnd]() {
        int ok = 0, fail = 0;
        for (auto& [idx, input] : items) {
            ::PostMessage(hwnd, UWM_TRANSFORM_PROGRESS, (WPARAM)idx, 1);

            auto progress = [hwnd](const std::string& msg) {
                auto* ws = new wchar_t[msg.size() * 2 + 2];
                int n = MultiByteToWideChar(CP_UTF8, 0, msg.c_str(), (int)msg.size(), ws, (int)(msg.size() * 2 + 1));
                ws[n] = L'\0';
                ::PostMessage(hwnd, UWM_LOG_MESSAGE, (WPARAM)ws, 0);
            };

            media::TransformOptions topts = base_opts;
            std::string output = media::default_transform_output(input, topts.prompt);
            auto result = media::transform_image(input, output, topts, progress);

            if (result.ok) {
                ++ok;
                ::PostMessage(hwnd, UWM_TRANSFORM_PROGRESS, (WPARAM)idx, 2);

                // Send both source path and generated path as a pair
                std::wstring wsrc = std::wstring(input.begin(), input.end());
                std::wstring wout;
                int n = MultiByteToWideChar(CP_UTF8, 0, result.output_path.c_str(),
                    (int)result.output_path.size(), nullptr, 0);
                if (n > 0) { wout.resize(n); MultiByteToWideChar(CP_UTF8, 0,
                    result.output_path.c_str(), (int)result.output_path.size(), wout.data(), n); }

                auto* pair = new std::pair<std::wstring, std::wstring>(wsrc, wout);
                ::PostMessage(hwnd, UWM_GENERATED_FILE, (WPARAM)pair, 0);
            } else {
                ++fail;
                ::PostMessage(hwnd, UWM_TRANSFORM_PROGRESS, (WPARAM)idx, 3);
                auto* ws = new wchar_t[result.error.size() * 2 + 16];
                std::wstring errmsg = L"Error: " + utf8_to_wide_mf(result.error);
                wcscpy_s(ws, errmsg.size() + 1, errmsg.c_str());
                ::PostMessage(hwnd, UWM_LOG_MESSAGE, (WPARAM)ws, 0);
            }
        }
        ::PostMessage(hwnd, UWM_TRANSFORM_DONE, (WPARAM)ok, (LPARAM)fail);
    });
    m_worker.detach();

    GetStatusBar().SetPartText(0, L"Transforming\u2026");
}

void CMainFrame::OnExit()
{
    Close();
}

LRESULT CMainFrame::OnGetMinMaxInfo(UINT msg, WPARAM wparam, LPARAM lparam)
{
    LPMINMAXINFO lpMMI = reinterpret_cast<LPMINMAXINFO>(lparam);
    const CSize minSz(600, 400);
    lpMMI->ptMinTrackSize.x = DpiScaleInt(minSz.cx);
    lpMMI->ptMinTrackSize.y = DpiScaleInt(minSz.cy);
    return FinalWindowProc(msg, wparam, lparam);
}

LRESULT CMainFrame::OnQueueProgress(WPARAM wparam, LPARAM lparam)
{
    if (!m_pDockQueue) return 0;
    auto& lv = m_pDockQueue->GetQueueContainer().GetListView();
    int idx = static_cast<int>(wparam);
    int state = static_cast<int>(lparam);
    if (state == 1)
        lv.SetItemStatus(idx, L"Resizing\u2026");
    else if (state == 2)
        lv.SetItemStatus(idx, L"\u2713 Done");
    else
        lv.SetItemStatus(idx, L"\u2717 Error");
    return 0;
}

LRESULT CMainFrame::OnQueueDone(WPARAM wparam, LPARAM lparam)
{
    m_processing = false;
    int ok = static_cast<int>(wparam);
    int fail = static_cast<int>(lparam);
    CString s;
    s.Format(L"Done: %d succeeded, %d failed", ok, fail);
    GetStatusBar().SetPartText(0, s);
    LogMessage(s);
    if (fail > 0)
        ::MessageBox(GetHwnd(), s, L"pm-image", MB_ICONWARNING);
    return 0;
}

LRESULT CMainFrame::OnTransformProgress(WPARAM wparam, LPARAM lparam)
{
    if (!m_pDockQueue) return 0;
    auto& lv = m_pDockQueue->GetQueueContainer().GetListView();
    int idx = static_cast<int>(wparam);
    int state = static_cast<int>(lparam);
    if (state == 1)
        lv.SetItemStatus(idx, L"Transforming\u2026");
    else if (state == 2)
        lv.SetItemStatus(idx, L"\u2713 Transformed");
    else
        lv.SetItemStatus(idx, L"\u2717 AI Error");
    return 0;
}

LRESULT CMainFrame::OnTransformDone(WPARAM wparam, LPARAM lparam)
{
    m_processing = false;
    int ok = static_cast<int>(wparam);
    int fail = static_cast<int>(lparam);
    CString s;
    s.Format(L"Transform done: %d succeeded, %d failed", ok, fail);
    GetStatusBar().SetPartText(0, s);
    LogMessage(s);
    if (fail > 0)
        ::MessageBox(GetHwnd(), s, L"pm-image", MB_ICONWARNING);
    return 0;
}

LRESULT CMainFrame::OnLogMessage(WPARAM wparam)
{
    auto* ws = reinterpret_cast<wchar_t*>(wparam);
    if (ws) {
        LogMessage(CString(ws));
        delete[] ws;
    }
    return 0;
}

LRESULT CMainFrame::OnGeneratedFile(WPARAM wparam)
{
    auto* pair = reinterpret_cast<std::pair<std::wstring, std::wstring>*>(wparam);
    if (pair && m_pDockQueue) {
        m_generatedMap[pair->first] = pair->second;

        auto& lv = m_pDockQueue->GetQueueContainer().GetListView();
        int idx = lv.AddFile(CString(pair->second.c_str()));
        lv.SetItemStatus(idx, L"\u2728 Generated");
        LogMessage(CString(L"Generated: ") + pair->second.c_str());
        delete pair;
    }
    return 0;
}

void CMainFrame::UpdateFileInfoForSelection(int idx)
{
    if (!m_pDockQueue) return;
    auto& lv = m_pDockQueue->GetQueueContainer().GetListView();
    if (idx < 0 || idx >= lv.QueueCount()) return;
    CString path = lv.GetItemPath(idx);
    if (path.IsEmpty()) return;

    if (m_pDockFileInfo && ::IsWindowVisible(m_pDockFileInfo->GetHwnd()))
        m_pDockFileInfo->GetInfoContainer().GetInfoView().ShowFileInfo(path.c_str());

    if (m_pDockGenPreview && ::IsWindowVisible(m_pDockGenPreview->GetHwnd()) && m_pDockSettings) {
        auto& sv = m_pDockSettings->GetSettingsContainer().GetSettingsView();
        if (sv.GetMode() == CSettingsView::MODE_TRANSFORM) {
            std::wstring srcKey(path.c_str());
            auto it = m_generatedMap.find(srcKey);
            auto& gp = m_pDockGenPreview->GetContainer().GetPreview();
            if (it != m_generatedMap.end())
                gp.LoadPicture(it->second.c_str());
            else
                gp.ClearPicture();
        }
    }
}

void CMainFrame::ResetLayout()
{
    // Dock hierarchy (must restore parents before children):
    //   ancestor → Queue (BOTTOM) → Log (RIGHT of Queue)
    //   ancestor → Settings (RIGHT) → GenPreview (BOTTOM) → FileInfo (BOTTOM of GenPreview)

    // Ensure a docker is undocked before we re-dock it elsewhere.
    auto ensureUndocked = [this](CDocker* p) {
        if (!p) return;
        if (p->IsDocked() || IsPanelVisible(p))
            p->Hide();  // undocks + hides
    };

    // Undock everything first (children before parents to avoid layout thrash)
    ensureUndocked(m_pDockFileInfo);
    ensureUndocked(m_pDockGenPreview);
    ensureUndocked(m_pDockLog);
    ensureUndocked(m_pDockQueue);
    ensureUndocked(m_pDockSettings);

    // Re-dock in hierarchy order: parents first
    CDocker* ancestor = GetDockAncestor();
    if (m_pDockQueue && ancestor) {
        ancestor->Dock(m_pDockQueue, DS_DOCKED_BOTTOM);
        m_pDockQueue->SetDockSize(DpiScaleInt(220));
        InvalidateToggle(IDC_CMD_VIEW_QUEUE);
    }
    if (m_pDockLog && m_pDockQueue) {
        m_pDockQueue->Dock(m_pDockLog, DS_DOCKED_RIGHT);
        m_pDockLog->SetDockSize(DpiScaleInt(360));
        InvalidateToggle(IDC_CMD_VIEW_LOG);
    }
    if (m_pDockSettings && ancestor) {
        ancestor->Dock(m_pDockSettings, DS_DOCKED_RIGHT);
        m_pDockSettings->SetDockSize(DpiScaleInt(280));
        InvalidateToggle(IDC_CMD_VIEW_SETTINGS);
    }
    if (m_pDockGenPreview && m_pDockSettings) {
        m_pDockSettings->Dock(m_pDockGenPreview, DS_DOCKED_BOTTOM);
        m_pDockGenPreview->SetDockSize(DpiScaleInt(200));
        InvalidateToggle(IDC_CMD_VIEW_GENPREVIEW);
    }
    if (m_pDockFileInfo && m_pDockGenPreview) {
        m_pDockGenPreview->Dock(m_pDockFileInfo, DS_DOCKED_BOTTOM);
        m_pDockFileInfo->SetDockSize(DpiScaleInt(160));
        InvalidateToggle(IDC_CMD_VIEW_FILEINFO);
    }

    // Centre window on the primary monitor
    HMONITOR hMon = ::MonitorFromWindow(GetHwnd(), MONITOR_DEFAULTTOPRIMARY);
    MONITORINFO mi{sizeof(mi)};
    ::GetMonitorInfoW(hMon, &mi);
    const RECT& wa = mi.rcWork;
    int w = std::min(1280L, wa.right - wa.left - 80);
    int h = std::min(860L,  wa.bottom - wa.top - 80);
    int x = wa.left + (wa.right  - wa.left - w) / 2;
    int y = wa.top  + (wa.bottom - wa.top  - h) / 2;
    ::SetWindowPos(GetHwnd(), nullptr, x, y, w, h, SWP_NOZORDER | SWP_SHOWWINDOW);

    RecalcLayout();

    // Persist the clean defaults so the next session starts fresh.
    // Save dock topology first (before settings.json window placement clear).
    SaveDockRegistrySettings(L"Polymech\\pm-image-ui");
    std::string err;
    media::settings::WindowLayout defaults;
    media::settings::save_window_layout(defaults, err);
}

void CMainFrame::DebugDockState()
{
    auto dockState = [](const CDocker* p, const char* name) -> std::string {
        if (!p) return std::string("\"") + name + "\": null";
        std::string s = std::string("\"") + name + "\": { ";
        s += "\"docked\": ";    s += p->IsDocked()   ? "true" : "false"; s += ", ";
        s += "\"undocked\": ";  s += p->IsUndocked() ? "true" : "false"; s += ", ";
        s += "\"visible\": ";   s += ::IsWindowVisible(p->GetHwnd()) ? "true" : "false"; s += ", ";
        s += "\"size\": ";      s += std::to_string(p->GetDockSize()); s += " }";
        return s;
    };

    std::string json = "{\n  ";
    json += dockState(m_pDockQueue,      "Queue");      json += ",\n  ";
    json += dockState(m_pDockLog,        "Log");        json += ",\n  ";
    json += dockState(m_pDockSettings,   "Settings");   json += ",\n  ";
    json += dockState(m_pDockGenPreview, "GenPreview"); json += ",\n  ";
    json += dockState(m_pDockFileInfo,   "FileInfo");
    json += "\n}";

    LogMessage(CString(L"── Dock State ──────────────────────"));
    // Print line by line so it's readable in the log
    std::istringstream ss(json);
    std::string line;
    while (std::getline(ss, line))
        LogMessage(CString(utf8_to_wide_mf(line).c_str()));
}

// ── Presets ─────────────────────────────────────────────

void CMainFrame::LoadPresets()
{
    m_presets.clear();
    try {
        std::string raw;
        std::string err;
        if (!media::settings::load_settings_utf8(raw, err) || raw.empty())
            return;
        json j = json::parse(raw, nullptr, false);
        if (j.is_discarded()) return;
        if (j.contains("transform") && j["transform"].contains("prompt_presets")) {
            for (auto& p : j["transform"]["prompt_presets"]) {
                PromptPreset pp;
                pp.name   = p.value("name", "");
                pp.prompt = p.value("prompt", "");
                if (!pp.prompt.empty())
                    m_presets.push_back(std::move(pp));
            }
        }
    } catch (...) {}
}

void CMainFrame::SavePresets()
{
    json j;
    try {
        std::string existing;
        std::string err;
        if (media::settings::load_settings_utf8(existing, err) && !existing.empty()) {
            j = json::parse(existing, nullptr, false);
            if (j.is_discarded()) j = json::object();
        } else {
            j = json::object();
        }
    } catch (...) { j = json::object(); }

    json arr = json::array();
    for (auto& p : m_presets)
        arr.push_back({ {"name", p.name}, {"prompt", p.prompt} });
    j["transform"]["prompt_presets"] = arr;

    try {
        std::string err;
        media::settings::save_settings_utf8(j.dump(2), err);
    } catch (...) {}
}

void CMainFrame::AddPreset(const std::string& name, const std::string& prompt)
{
    m_presets.push_back({ name, prompt });
    SavePresets();
}

void CMainFrame::RemovePreset(int index)
{
    if (index >= 0 && index < (int)m_presets.size()) {
        m_presets.erase(m_presets.begin() + index);
        SavePresets();
    }
}

// ── Layout persistence ──────────────────────────────────────────────────

bool CMainFrame::IsPanelVisible(const CDocker* pDock) const
{
    return pDock && ::IsWindowVisible(pDock->GetHwnd());
}

// Re-dock pDock into pParent with dockStyle if it is currently hidden or floating.
// If it is already docked, hide it instead (toggle semantics).
void CMainFrame::TogglePanelView(CDocker* pDock, UINT dockStyle, CDocker* pParent, int defaultSize, UINT32 cmdID)
{
    if (!pDock || !pParent) return;

    if (IsPanelVisible(pDock)) {
        // Docked or floating → hide (also undocks if docked)
        pDock->Hide();
    } else {
        // Hidden or not docked → re-dock into original parent
        if (pDock->IsDocked()) {
            // Shouldn't normally happen, but ensure it's undocked first
            pDock->Hide();
        }
        pParent->Dock(pDock, dockStyle);
        if (defaultSize > 0)
            pDock->SetDockSize(defaultSize);
    }

    InvalidateToggle(cmdID);
}

void CMainFrame::SaveLayout()
{
    // Dock topology (parent, style, size, floating rect, hidden) is saved by
    // SaveDockRegistrySettings() in the WM_CLOSE handler.  This function only
    // persists the main window placement to settings.json.
    WINDOWPLACEMENT wp{sizeof(wp)};
    if (!GetWindowPlacement(wp))
        return;

    media::settings::WindowLayout layout;
    layout.has_placement = true;
    layout.show_cmd      = (wp.showCmd == SW_SHOWMINIMIZED) ? SW_SHOWNORMAL : (int)wp.showCmd;
    layout.min_pos       = wp.ptMinPosition;
    layout.max_pos       = wp.ptMaxPosition;
    layout.normal_rect   = wp.rcNormalPosition;

    std::string err;
    media::settings::save_window_layout(layout, err);
}

void CMainFrame::LoadLayout()
{
    // Dock topology (parent, style, size, floating rect, hidden) was already
    // restored by LoadDockRegistrySettings() at the top of OnInitialUpdate().
    // Here we only restore the main window placement from settings.json.
    media::settings::WindowLayout layout;
    std::string err;
    if (!media::settings::load_window_layout(layout, err) || !layout.has_placement)
        return;

    // ── Multi-monitor safety ──────────────────────────────────────────
    POINT centre = {
        (layout.normal_rect.left + layout.normal_rect.right)  / 2,
        (layout.normal_rect.top  + layout.normal_rect.bottom) / 2,
    };
    HMONITOR hMon = ::MonitorFromPoint(centre, MONITOR_DEFAULTTONULL);
    if (!hMon) {
        HMONITOR hPrimary = ::MonitorFromPoint({0, 0}, MONITOR_DEFAULTTOPRIMARY);
        MONITORINFO mi{sizeof(mi)};
        ::GetMonitorInfoW(hPrimary, &mi);
        const RECT& wa = mi.rcWork;
        int w = std::min(1200L, wa.right - wa.left);
        int h = std::min(800L,  wa.bottom - wa.top);
        layout.normal_rect = { wa.left + 40, wa.top + 40, wa.left + 40 + w, wa.top + 40 + h };
        layout.show_cmd    = SW_SHOWNORMAL;
    }

    WINDOWPLACEMENT wp{sizeof(wp)};
    wp.showCmd          = (UINT)layout.show_cmd;
    wp.ptMinPosition    = layout.min_pos;
    wp.ptMaxPosition    = layout.max_pos;
    wp.rcNormalPosition = layout.normal_rect;
    SetWindowPlacement(wp);
}

void CMainFrame::OnPresets()
{
    ShowPresetsMenu();
}

void CMainFrame::ShowPresetsMenu()
{
    constexpr UINT ID_PRESET_BASE  = 50000;
    constexpr UINT ID_REMOVE_BASE  = 51000;
    constexpr UINT ID_SAVE_PRESET  = 52000;

    HMENU hMenu = ::CreatePopupMenu();
    if (!hMenu) return;

    if (m_presets.empty()) {
        ::AppendMenuW(hMenu, MF_STRING | MF_GRAYED, 0, L"(no presets)");
    } else {
        for (int i = 0; i < (int)m_presets.size(); ++i) {
            std::wstring label = utf8_to_wide_mf(m_presets[i].name);
            if (label.empty())
                label = utf8_to_wide_mf(m_presets[i].prompt.substr(0, 40));
            ::AppendMenuW(hMenu, MF_STRING, ID_PRESET_BASE + i, label.c_str());
        }
    }

    ::AppendMenuW(hMenu, MF_SEPARATOR, 0, nullptr);
    ::AppendMenuW(hMenu, MF_STRING, ID_SAVE_PRESET, L"Save current prompt\u2026");

    if (!m_presets.empty()) {
        HMENU hRemove = ::CreatePopupMenu();
        for (int i = 0; i < (int)m_presets.size(); ++i) {
            std::wstring label = utf8_to_wide_mf(m_presets[i].name);
            if (label.empty())
                label = utf8_to_wide_mf(m_presets[i].prompt.substr(0, 40));
            ::AppendMenuW(hRemove, MF_STRING, ID_REMOVE_BASE + i, label.c_str());
        }
        ::AppendMenuW(hMenu, MF_POPUP, (UINT_PTR)hRemove, L"Remove preset");
    }

    POINT pt;
    ::GetCursorPos(&pt);
    UINT choice = (UINT)::TrackPopupMenu(hMenu, TPM_RETURNCMD | TPM_NONOTIFY,
        pt.x, pt.y, 0, GetHwnd(), nullptr);
    ::DestroyMenu(hMenu);

    if (choice == 0) return;

    if (choice == ID_SAVE_PRESET) {
        std::wstring prompt = m_lastPrompt;
        if (prompt.empty()) {
            ::MessageBox(GetHwnd(), L"No prompt to save.\nRun a transform first, or type a prompt.",
                L"pm-image", MB_ICONINFORMATION);
            return;
        }

        // Ask for a name
        wchar_t nameBuf[256]{};
        alignas(DWORD) BYTE dlgBuf[1024]{};
        DLGTEMPLATE* dlg = reinterpret_cast<DLGTEMPLATE*>(dlgBuf);
        dlg->style = DS_MODALFRAME | DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_VISIBLE;
        dlg->cdit = 3;
        dlg->cx = 220; dlg->cy = 60;
        WORD* p = reinterpret_cast<WORD*>(dlg + 1);
        *p++ = 0; *p++ = 0;
        const wchar_t dlgTitle[] = L"Save Preset";
        memcpy(p, dlgTitle, sizeof(dlgTitle)); p += sizeof(dlgTitle) / sizeof(WORD);
        if (reinterpret_cast<uintptr_t>(p) % 4) p++;

        auto addCtrl = [&](DWORD style, short x, short y, short cx, short cy, WORD id, const wchar_t* cls, const wchar_t* text) {
            if (reinterpret_cast<uintptr_t>(p) % 4) p++;
            DLGITEMTEMPLATE* item = reinterpret_cast<DLGITEMTEMPLATE*>(p);
            item->style = style | WS_CHILD | WS_VISIBLE;
            item->x = x; item->y = y; item->cx = cx; item->cy = cy; item->id = id;
            p = reinterpret_cast<WORD*>(item + 1);
            size_t clen = wcslen(cls) + 1; memcpy(p, cls, clen * 2); p += clen;
            size_t tlen = wcslen(text) + 1; memcpy(p, text, tlen * 2); p += tlen;
            *p++ = 0;
        };
        addCtrl(SS_LEFT, 6, 6, 208, 10, 0xFFFF, L"Static", L"Preset name:");
        addCtrl(ES_AUTOHSCROLL | WS_BORDER | WS_TABSTOP, 6, 18, 208, 14, 1001, L"Edit", L"");
        addCtrl(BS_DEFPUSHBUTTON | WS_TABSTOP, 160, 38, 50, 16, IDOK, L"Button", L"Save");

        struct NameCtx { wchar_t* buf; int maxLen; };
        NameCtx ctx = { nameBuf, 255 };

        INT_PTR result = ::DialogBoxIndirectParam(
            ::GetModuleHandle(nullptr), dlg, GetHwnd(),
            [](HWND h, UINT msg, WPARAM wp, LPARAM lp) -> INT_PTR {
                if (msg == WM_INITDIALOG) {
                    ::SetWindowLongPtr(h, GWLP_USERDATA, lp);
                    HFONT hf = (HFONT)::GetStockObject(DEFAULT_GUI_FONT);
                    ::EnumChildWindows(h, [](HWND c, LPARAM f) -> BOOL {
                        ::SendMessage(c, WM_SETFONT, (WPARAM)f, TRUE); return TRUE;
                    }, (LPARAM)hf);
                    ::SetFocus(::GetDlgItem(h, 1001));
                    return FALSE;
                }
                if (msg == WM_COMMAND && LOWORD(wp) == IDOK) {
                    auto* c = reinterpret_cast<NameCtx*>(::GetWindowLongPtr(h, GWLP_USERDATA));
                    ::GetDlgItemTextW(h, 1001, c->buf, c->maxLen);
                    ::EndDialog(h, IDOK);
                    return TRUE;
                }
                if (msg == WM_CLOSE) { ::EndDialog(h, IDCANCEL); return TRUE; }
                return FALSE;
            }, reinterpret_cast<LPARAM>(&ctx));

        if (result != IDOK || nameBuf[0] == L'\0') return;
        AddPreset(wide_to_utf8(nameBuf), wide_to_utf8(prompt));
        LogMessage(CString(L"Preset saved: ") + nameBuf);
        return;
    }

    if (choice >= ID_REMOVE_BASE && choice < ID_REMOVE_BASE + m_presets.size()) {
        int idx = choice - ID_REMOVE_BASE;
        std::wstring name = utf8_to_wide_mf(m_presets[idx].name);
        RemovePreset(idx);
        LogMessage(CString(L"Preset removed: ") + name.c_str());
        return;
    }

    if (choice >= ID_PRESET_BASE && choice < ID_PRESET_BASE + m_presets.size()) {
        int idx = choice - ID_PRESET_BASE;
        m_lastPrompt = utf8_to_wide_mf(m_presets[idx].prompt);
        LogMessage(CString(L"Preset loaded: ") + utf8_to_wide_mf(m_presets[idx].name).c_str());
        return;
    }
}

LRESULT CMainFrame::WndProc(UINT msg, WPARAM wparam, LPARAM lparam)
{
    try {
        switch (msg) {
        case WM_CLOSE:
            // Save dock layout (parent, style, size, floating rect, hidden)
            // to Win32++ registry BEFORE OnClose() hides & destroys the window.
            SaveDockRegistrySettings(L"Polymech\\pm-image-ui");
            // Save window placement to settings.json.
            SaveLayout();
            return WndProcDefault(msg, wparam, lparam);
        case WM_GETMINMAXINFO:   return OnGetMinMaxInfo(msg, wparam, lparam);
        case UWM_QUEUE_PROGRESS:     return OnQueueProgress(wparam, lparam);
        case UWM_QUEUE_DONE:         return OnQueueDone(wparam, lparam);
        case UWM_TRANSFORM_PROGRESS: return OnTransformProgress(wparam, lparam);
        case UWM_TRANSFORM_DONE:     return OnTransformDone(wparam, lparam);
        case UWM_LOG_MESSAGE:        return OnLogMessage(wparam);
        case UWM_GENERATED_FILE:     return OnGeneratedFile(wparam);
        case UWM_QUEUE_ITEM_CLICKED: {
            int idx = static_cast<int>(wparam);
            try {
                if (m_pDockQueue) {
                    CString path = m_pDockQueue->GetQueueContainer().GetListView().GetItemPath(idx);
                    if (!path.IsEmpty())
                        m_view.LoadPicture(path.c_str());
                    UpdateFileInfoForSelection(idx);
                }
            }
            catch (const std::exception& ex) {
                LogMessage(CString(L"[Queue click] ") + ex.what());
            }
            catch (...) {
                LogMessage(L"[Queue click] Unknown exception — panel state may be invalid.");
            }
            return 0;
        }
        case WM_DROPFILES: {
            HDROP hDrop = reinterpret_cast<HDROP>(wparam);
            UINT count = DragQueryFileW(hDrop, 0xFFFFFFFF, nullptr, 0);
            std::vector<std::wstring> paths;
            for (UINT i = 0; i < count; ++i) {
                UINT len = DragQueryFileW(hDrop, i, nullptr, 0);
                if (!len) continue;
                std::wstring w(len + 1, L'\0');
                DragQueryFileW(hDrop, i, w.data(), len + 1);
                w.resize(len);
                paths.push_back(std::move(w));
            }
            DragFinish(hDrop);
            AddFilesToQueue(paths);
            return 0;
        }
        }
        return WndProcDefault(msg, wparam, lparam);
    }
    catch (const CException& e) {
        CString s;
        s << e.GetText() << L'\n' << e.GetErrorString();
        ::MessageBox(nullptr, s, L"Error", MB_ICONERROR);
    }
    catch (const std::exception& e) {
        ::MessageBoxA(nullptr, e.what(), "Error", MB_ICONERROR);
    }
    return 0;
}