mainwindow.cpp

#include "mainwindow.h"
#include "util.h"
#include <QtConcurrent>
#include <QDesktopServices>
#include <QStandardPaths>
#include <QUrlQuery>

// ===== Constructor / Destructor =====
MainWindow::MainWindow(){
    setWindowTitle("MetaTrack — Metadata Auditor");
    setMinimumSize(1100, 720);
    createUi();
    applyTheme();
    loadSettings();
    checkExif();
}
MainWindow::~MainWindow(){ saveSettings(); }

// ===== UI Build =====
void MainWindow::createUi(){
    auto tb=addToolBar("Main"); tb->setMovable(false);
    auto actOpen   = tb->addAction("Select File");
    auto actFolder = tb->addAction("Select Folder");
    auto actScan   = tb->addAction("Scan");
    auto actRedact = tb->addAction("Redact");
    auto actExport = tb->addAction("Export CSV");
    auto actReport = tb->addAction("Export HTML Report");
    connect(actOpen,   &QAction::triggered, this, &MainWindow::onActionOpen);
    connect(actFolder, &QAction::triggered, this, &MainWindow::onActionFolder);
    connect(actScan,   &QAction::triggered, this, &MainWindow::onActionScan);
    connect(actRedact, &QAction::triggered, this, &MainWindow::onActionRedact);
    connect(actExport, &QAction::triggered, this, &MainWindow::onActionExportCsv);
    connect(actReport, &QAction::triggered, this, &MainWindow::onActionExportReport);

    leFile=new QLineEdit; leFile->setPlaceholderText("Single file path…");
    btnPickFile=new QPushButton("Browse");
    leDir=new QLineEdit; leDir->setPlaceholderText("Folder path…");
    btnPickDir=new QPushButton("Browse");
    cbRecurse=new QCheckBox("Include subfolders");
    cbAuthorized=new QCheckBox("I am authorized to process these files");
    cbOpenOnGps=new QCheckBox("Auto-open OSM when GPS found");
    cbKeepBackup=new QCheckBox("Keep exiftool backups (_original)"); cbKeepBackup->setChecked(true);
    cbEnableUrlPipe=new QCheckBox("Enable URL import (requires authorization)"); cbEnableUrlPipe->setChecked(false);

    leFilter=new QLineEdit; leFilter->setPlaceholderText("Filter results… (press Enter)");

    btnScan=new QPushButton("Scan");
    btnRedact=new QPushButton("Redact");
    btnExportCsv=new QPushButton("Export CSV");
    btnExportHtml=new QPushButton("Export HTML");
    btnReveal=new QPushButton("Reveal Coordinates");
    btnOpenOsm=new QPushButton("Open in OSM");
    btnClear=new QPushButton("Clear Results");
    btnCancel=new QPushButton("Cancel"); btnCancel->setVisible(false);

    table=new QTableWidget(0, 9);
    table->setHorizontalHeaderLabels({"File","Risk","GPS?","Latitude","Longitude","Size","SHA-256","OSM URL","Source"});
    table->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    table->setSelectionBehavior(QAbstractItemView::SelectRows);
    table->setEditTriggers(QAbstractItemView::NoEditTriggers);
    table->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(table,&QTableWidget::itemSelectionChanged,this,&MainWindow::onTableSelection);
    connect(table,&QTableWidget::customContextMenuRequested,this,&MainWindow::onTableMenu);

    preview=new QLabel("Preview");
    preview->setMinimumSize(320,240);
    preview->setAlignment(Qt::AlignCenter);
    preview->setFrameShape(QFrame::StyledPanel);

    map=new MapPanel;

    log=new QTextEdit; log->setReadOnly(true); log->setMinimumHeight(140);
    progress=new QProgressBar; progress->setVisible(false);

    urlBox=new QPlainTextEdit; urlBox->setPlaceholderText("Paste URLs here (one per line). Only for authorized sources.");
    btnAnalyzeUrls=new QPushButton("Download & Scan URLs");

    drop=new FileDropLabel;
    connect(drop, &FileDropLabel::filesDropped, this, &MainWindow::onFilesDropped);
    connect(drop, &FileDropLabel::urlsDropped, this, &MainWindow::onUrlsDropped);

    // Selectors grid
    auto selGrid=new QGridLayout;
    selGrid->addWidget(new QLabel("File:"),0,0); selGrid->addWidget(leFile,0,1); selGrid->addWidget(btnPickFile,0,2);
    selGrid->addWidget(new QLabel("Folder:"),1,0); selGrid->addWidget(leDir,1,1); selGrid->addWidget(btnPickDir,1,2);
    selGrid->addWidget(cbRecurse,2,1);
    selGrid->addWidget(cbAuthorized,2,2);
    selGrid->addWidget(cbKeepBackup,3,1);
    selGrid->addWidget(cbOpenOnGps,3,2);
    selGrid->addWidget(cbEnableUrlPipe,4,1);

    // Actions row
    auto actions=new QHBoxLayout;
    actions->addWidget(btnScan);
    actions->addWidget(btnRedact);
    actions->addWidget(btnReveal);
    actions->addWidget(btnOpenOsm);
    actions->addWidget(btnExportCsv);
    actions->addWidget(btnExportHtml);
    actions->addWidget(btnClear);
    actions->addStretch();
    actions->addWidget(btnCancel);

    // Left layout (main)
    auto left=new QVBoxLayout;
    left->addLayout(selGrid);
    left->addLayout(actions);
    left->addWidget(leFilter);
    left->addWidget(table,1);
    left->addWidget(new QLabel("Log:"));
    left->addWidget(log);
    left->addWidget(progress);

    // Right layout (preview + map + url pipe + drop zone)
    auto grpPipe=new QGroupBox("URL Import");
    auto pipeLay=new QVBoxLayout(grpPipe);
    pipeLay->addWidget(urlBox,1);
    pipeLay->addWidget(btnAnalyzeUrls);

    auto right=new QVBoxLayout;
    right->addWidget(new QLabel("Preview:"),0);
    right->addWidget(preview);
    right->addWidget(map,1);
    right->addWidget(drop);
    right->addWidget(grpPipe);

    auto central=new QWidget; setCentralWidget(central);
    auto root=new QHBoxLayout(central);
    root->addLayout(left,2);
    root->addLayout(right,1);

    sb=statusBar();
    sb->showMessage("Ready");

    // Connections
    connect(btnPickFile,&QPushButton::clicked,this,&MainWindow::onBtnPickFile);
    connect(btnPickDir,&QPushButton::clicked,this,&MainWindow::onBtnPickDir);
    connect(btnScan,&QPushButton::clicked,this,&MainWindow::onBtnScan);
    connect(btnRedact,&QPushButton::clicked,this,&MainWindow::onBtnRedact);
    connect(btnExportCsv,&QPushButton::clicked,this,&MainWindow::onBtnExportCsv);
    connect(btnExportHtml,&QPushButton::clicked,this,&MainWindow::onBtnExportHtml);
    connect(btnClear,&QPushButton::clicked,this,&MainWindow::onBtnClear);
    connect(btnAnalyzeUrls,&QPushButton::clicked,this,&MainWindow::onBtnAnalyzeUrls);
    connect(btnCancel,&QPushButton::clicked,this,&MainWindow::onBtnCancel);
    connect(leFilter,&QLineEdit::returnPressed,this,&MainWindow::onFilterReturn);
    connect(btnReveal,&QPushButton::clicked,this,&MainWindow::onBtnReveal);
    connect(btnOpenOsm,&QPushButton::clicked,this,&MainWindow::onBtnOpenOsm);
}

void MainWindow::applyTheme(){
    qApp->setStyle("fusion");
    QString css = R"(
        QWidget { font-family: Inter, "Segoe UI", Roboto, Arial; font-size: 13px; color: #ECE7F7; }
        QMainWindow { background: #0b0712; }
        QToolBar { background: qlineargradient(x1:0,y1:0,x2:0,y2:1, stop:0 #1f1531, stop:1 #140c22);
                   border: 1px solid #2c1f43; padding: 6px; }
        QStatusBar { background: #1a1228; border-top:1px solid #2c1f43; color: #cdb7ff; }
        QPushButton {
            background: qlineargradient(x1:0,y1:0,x2:0,y2:1, stop:0 #5a33b8, stop:1 #3c1f87);
            border: 1px solid #7a57d1; padding: 9px 14px; border-radius: 12px;
        }
        QPushButton:hover { background: #6a3fce; }
        QPushButton:pressed { background: #2c176c; }
        QPushButton:disabled { background: #2b2042; color: #8e7fb1; border-color:#3b2c5e; }
        QLineEdit, QPlainTextEdit, QTextEdit, QTableWidget, QGroupBox, QLabel#drop {
            background: rgba(29, 19, 49, 0.85);
            border: 1px solid #3d2c60;
            border-radius: 12px; padding: 8px; selection-background-color:#7b4fe0;
        }
        QGroupBox { margin-top: 12px; }
        QGroupBox::title { subcontrol-origin: margin; subcontrol-position: top left; padding: 4px 8px; color: #c9b9ff; }
        QHeaderView::section { background: #2a1b45; border: 1px solid #3d2c60; padding: 6px; }
        QTableWidget::item { padding: 6px; }
        QTableWidget::item:selected { background: #50307f; color:#f3edff; }
        QScrollBar:vertical, QScrollBar:horizontal { background:#1a1228; border:1px solid #2c1f43; }
        QProgressBar { border: 1px solid #3d2c60; border-radius: 8px; text-align: center; background: #1b1230; color:#e9dfff; }
        QProgressBar::chunk { background: qlineargradient(x1:0,y1:0,x2:1,y2:0, stop:0 #b46df5, stop:1 #7b4fe0); border-radius: 8px; }
    )";
    qApp->setStyleSheet(css);
}

void MainWindow::loadSettings(){
    QSettings s("MetaTrack","MetaTrack");
    restoreGeometry(s.value("geom").toByteArray());
    leFile->setText(s.value("file").toString());
    leDir->setText(s.value("dir").toString());
    cbRecurse->setChecked(s.value("recurse",true).toBool());
    cbAuthorized->setChecked(s.value("auth",false).toBool());
    cbOpenOnGps->setChecked(s.value("openGps",false).toBool());
    cbKeepBackup->setChecked(s.value("keepBackup",true).toBool());
    cbEnableUrlPipe->setChecked(s.value("urlEnable",false).toBool());
    urlBox->setPlainText(s.value("urls").toString());
}
void MainWindow::saveSettings(){
    QSettings s("MetaTrack","MetaTrack");
    s.setValue("geom", saveGeometry());
    s.setValue("file", leFile->text());
    s.setValue("dir", leDir->text());
    s.setValue("recurse", cbRecurse->isChecked());
    s.setValue("auth", cbAuthorized->isChecked());
    s.setValue("openGps", cbOpenOnGps->isChecked());
    s.setValue("keepBackup", cbKeepBackup->isChecked());
    s.setValue("urlEnable", cbEnableUrlPipe->isChecked());
    s.setValue("urls", urlBox->toPlainText());
}

void MainWindow::checkExif(){
    QString ver, err;
    if(ExifTool::available(&ver,&err)) logOk("exiftool found • version: "+ver);
    else logError("exiftool not found: "+err+" — Please install and ensure it’s in PATH.");
}

// ===== File picking =====
void MainWindow::pickFile(){
    const QString f = QFileDialog::getOpenFileName(this, "Select Image", QString(),
                                                   "Images (*.jpg *.jpeg *.png *.tif *.tiff *.heic *.webp *.bmp);;All files (*)");
    if(!f.isEmpty()){
        leFile->setText(f);
        showPreview(f);
    }
}
void MainWindow::pickFolder(){
    const QString d = QFileDialog::getExistingDirectory(this, "Select Folder");
    if(!d.isEmpty()) leDir->setText(d);
}
QStringList MainWindow::collectFiles(const QString &path, bool recursive){
    QStringList out; QFileInfo fi(path); if(!fi.exists()) return out;
    if(fi.isFile()){ out<<fi.absoluteFilePath(); return out; }
    QDirIterator it(path, QDir::Files, recursive? QDirIterator::Subdirectories: QDirIterator::NoIteratorFlags);
    while(it.hasNext()) out<<it.next();
    return out;
}

// ===== Scan =====
void MainWindow::scan(){
    if(!cbAuthorized->isChecked()){
        QMessageBox::warning(this,"Authorization Required","Please confirm authorization before scanning.");
        return;
    }
    QStringList files;
    if(!leFile->text().trimmed().isEmpty()) files<<leFile->text().trimmed();
    else if(!leDir->text().trimmed().isEmpty()) files = collectFiles(leDir->text().trimmed(), cbRecurse->isChecked());
    if(files.isEmpty()){ QMessageBox::information(this,"Nothing to scan","Select a file or a folder."); return; }

    progress->setVisible(true); progress->setValue(0);
    busy=true; btnCancel->setVisible(true);
    sb->showMessage("Scanning…");

    int done=0, total=files.size();
    for(const QString &f: files){
        if(!busy) break;
        if(!QFileInfo::exists(f)) continue;
        if(!isLikelyImage(f)){ logWarn("Not an image, skipping: "+f); continue; }
        GpsResult res = ExifTool::analyze(f);
        addRow(res);
        progress->setValue(++done*100/qMax(1,total));
        qApp->processEvents();
        if(res.hasGps && cbOpenOnGps->isChecked()){
            map->showOsm(res.lat, res.lon);
        }
    }
    busy=false; btnCancel->setVisible(false);
    progress->setVisible(false);
    sb->showMessage("Scan complete.", 4000);
}

// ===== Redact =====
void MainWindow::redact(){
    if(!cbAuthorized->isChecked()){
        QMessageBox::warning(this,"Authorization Required","Please confirm authorization before redaction.");
        return;
    }
    QStringList files;
    if(!leFile->text().trimmed().isEmpty()) files<<leFile->text().trimmed();
    else if(!leDir->text().trimmed().isEmpty()) files = collectFiles(leDir->text().trimmed(), cbRecurse->isChecked());
    if(files.isEmpty()){ QMessageBox::information(this,"Nothing to redact","Select a file or a folder."); return; }
    if(QMessageBox::question(this,"Confirm Redaction",
        "This will remove EXIF metadata from the selected images.\n"
        "Backups "+QString(cbKeepBackup->isChecked()?"WILL":"will NOT")+" be kept.\nProceed?")
        != QMessageBox::Yes) return;

    progress->setVisible(true); progress->setValue(0);
    busy=true; btnCancel->setVisible(true);
    int done=0, total=files.size();

    for(const QString &f: files){
        if(!busy) break;
        QString msg;
        bool ok = ExifTool::stripAll(f, cbKeepBackup->isChecked(), &msg);
        if(ok){ logOk("Redacted: "+QFileInfo(f).fileName()); writeAudit("redact", f, "ok", msg); }
        else  { logError("Redaction failed: "+QFileInfo(f).fileName()); writeAudit("redact", f, "fail", msg); }
        progress->setValue(++done*100/qMax(1,total));
        qApp->processEvents();
    }
    busy=false; btnCancel->setVisible(false);
    progress->setVisible(false);
    sb->showMessage("Redaction completed. You can rescan.", 4000);
}

// ===== URL import (with authorization gate) =====
void MainWindow::analyzeUrls(){
    if(!cbEnableUrlPipe->isChecked()){
        QMessageBox::information(this,"Disabled","Enable URL import checkbox first.");
        return;
    }
    if(!cbAuthorized->isChecked()){
        QMessageBox::warning(this,"Authorization Required","Please confirm authorization to fetch URLs.");
        return;
    }
    QStringList urls;
    for(QString s: urlBox->toPlainText().split('\n')){
        s=s.trimmed(); if(!s.isEmpty()) urls<<s;
    }
    if(urls.isEmpty()){ QMessageBox::information(this,"No URLs","Paste some URLs first."); return; }

    QDir tmpDir(QStandardPaths::writableLocation(QStandardPaths::TempLocation));
    if(!tmpDir.exists()) tmpDir.mkpath(".");

    progress->setVisible(true); progress->setValue(0);
    busy=true; btnCancel->setVisible(true);
    int done=0, n=urls.size();

    for(const QString &uStr: urls){
        if(!busy) break;
        QUrl u(uStr);
        if(!u.isValid() || u.scheme().isEmpty()){ logWarn("Invalid URL: "+uStr); progress->setValue(++done*100/n); continue; }

        QString ext;
        {
            QString path=u.path();
            int dot=path.lastIndexOf('.');
            ext = dot>=0? path.mid(dot+1).toLower(): QString();
            if(ext.isEmpty()) ext="bin";
            ext.remove(QRegularExpression("[^a-z0-9]"));
            if(ext.size()>8) ext=ext.left(8);
        }
        QString outPath = tmpDir.absoluteFilePath(QString("metatrack_%1.%2")
        .arg(QString::number(QDateTime::currentMSecsSinceEpoch()))
        .arg(ext));
        QFile out(outPath);
        if(!out.open(QIODevice::WriteOnly)){ logError("Cannot write: "+outPath); progress->setValue(++done*100/n); continue; }

        QNetworkAccessManager nm; QNetworkRequest req(u); QEventLoop loop;
        QNetworkReply *rep = nm.get(req);
        connect(rep, &QNetworkReply::finished, &loop, &QEventLoop::quit);
        loop.exec();
        if(rep->error()!=QNetworkReply::NoError){
            logError(QString("Download failed (%1): %2").arg(uStr, rep->errorString()));
            out.close(); out.remove(); rep->deleteLater(); progress->setValue(++done*100/n); continue;
        }
        QByteArray data = rep->readAll(); rep->deleteLater();
        out.write(data); out.close();

        if(!isLikelyImage(outPath)){
            QFile::remove(outPath);
            logWarn("Downloaded file is not an image. Discarded.");
        } else {
            logInfo("Downloaded: "+outPath+" • "+fileSizeHuman(QFileInfo(outPath).size()));
            GpsResult res = ExifTool::analyze(outPath);
            addRow(res);
        }
        progress->setValue(++done*100/n);
        qApp->processEvents();
    }
    busy=false; btnCancel->setVisible(false);
    progress->setVisible(false);
    sb->showMessage("URL analysis complete.", 4000);
}

// ===== Table helpers =====
void MainWindow::addRow(const GpsResult& r){
    int row = table->rowCount();
    table->insertRow(row);
    const QString risk = r.hasGps ? "High (GPS present)" : "Low";
    auto iFile=new QTableWidgetItem(QFileInfo(r.path).fileName());
    iFile->setData(Qt::UserRole, r.path);
    table->setItem(row,0,iFile);
    table->setItem(row,1,new QTableWidgetItem(risk));
    table->setItem(row,2,new QTableWidgetItem(r.hasGps?"YES":"NO"));
    table->setItem(row,3,new QTableWidgetItem(r.hasGps? QString("%1").arg(r.lat,0,'f',6):"-"));
    table->setItem(row,4,new QTableWidgetItem(r.hasGps? QString("%1").arg(r.lon,0,'f',6):"-"));
    table->setItem(row,5,new QTableWidgetItem(fileSizeHuman(r.bytes)));
    table->setItem(row,6,new QTableWidgetItem(r.sha256));
    table->setItem(row,7,new QTableWidgetItem(r.hasGps? r.osmUrl:"-"));
    table->setItem(row,8,new QTableWidgetItem(QFileInfo(r.path).absolutePath()));

    RowData rd; rd.r=r; rd.revealed=false; rows.push_back(rd);

    if(r.hasGps){
        logAlert(QString("Sensitive: GPS present • %1").arg(QFileInfo(r.path).fileName()));
        if(!r.gpsLine.isEmpty()) logGps(r.gpsLine);
        writeAudit("scan_gps", r.path, "gps_found", r.osmUrl);
    } else {
        logOk(QFileInfo(r.path).fileName()+": No GPS found");
        writeAudit("scan", r.path, "ok", "");
    }
}

void MainWindow::onSelectionChange(){
    int r = currentRow();
    if(r<0){ map->lock(); btnOpenOsm->setEnabled(false); return; }
    const QString path = table->item(r,0)->data(Qt::UserRole).toString();
    showPreview(path);
    const QString osm = table->item(r,7)->text();
    btnOpenOsm->setEnabled(osm!="-" && !osm.isEmpty());
    map->lock();
}

int MainWindow::currentRow() const {
    auto rowsSel = table->selectionModel()->selectedRows();
    return rowsSel.isEmpty()? -1: rowsSel.first().row();
}

void MainWindow::showPreview(const QString &path){
    QPixmap px;
    if(px.load(path))
        preview->setPixmap(px.scaled(preview->size()*1.0, Qt::KeepAspectRatio, Qt::SmoothTransformation));
    else
        preview->setText("Preview");
}

void MainWindow::revealMap(){
    if(!cbAuthorized->isChecked()){
        QMessageBox::warning(this,"Authorization Required","Confirm authorization to reveal coordinates.");
        return;
    }
    int r = currentRow(); if(r<0){ QMessageBox::information(this,"No selection","Select a row first."); return; }
    if(!rows.value(r).r.hasGps){ QMessageBox::information(this,"No GPS","Selected file has no GPS."); return; }
    const auto &gr = rows[r].r;
    map->showOsm(gr.lat, gr.lon);
    rows[r].revealed=true;
    writeAudit("reveal_map", gr.path, "ok", QString("%1,%2").arg(gr.lat,0,'f',6).arg(gr.lon,0,'f',6));
}

void MainWindow::openInOsm(){
    int r=currentRow(); if(r<0) return;
    const QString url = table->item(r,7)->text();
    if(url=="-" || url.isEmpty()) return;
    if(!cbAuthorized->isChecked()){
        QMessageBox::warning(this,"Authorization Required","Confirm authorization to open coordinates.");
        return;
    }
    QDesktopServices::openUrl(QUrl(url));
    writeAudit("open_osm", table->item(r,0)->data(Qt::UserRole).toString(), "ok", url);
}

void MainWindow::tableMenu(const QPoint &pos){
    int r = table->indexAt(pos).row(); if(r<0) return;
    QMenu m;
    QAction *aCopyName = m.addAction("Copy File Name");
    QAction *aCopySha  = m.addAction("Copy SHA-256");
    QAction *aCopyGps  = m.addAction("Copy Coordinates");
    QAction *aReveal   = m.addAction("Reveal Coordinates");
    QAction *aShowDir  = m.addAction("Show in File Manager");
    QAction *aRemove   = m.addAction("Remove Row");
    QAction *picked = m.exec(table->viewport()->mapToGlobal(pos));
    if(!picked) return;

    const QString path = table->item(r,0)->data(Qt::UserRole).toString();
    if(picked==aCopyName){
        QApplication::clipboard()->setText(QFileInfo(path).fileName());
    } else if(picked==aCopySha){
        QApplication::clipboard()->setText(table->item(r,6)->text());
    } else if(picked==aCopyGps){
        if(table->item(r,2)->text()=="YES"){
            QString s=table->item(r,3)->text()+","+table->item(r,4)->text();
            QApplication::clipboard()->setText(s);
        }
    } else if(picked==aReveal){
        revealMap();
    } else if(picked==aShowDir){
        #ifdef Q_OS_WIN
        QProcess::startDetached("explorer", {"/select,", QDir::toNativeSeparators(path)});
        #elif defined(Q_OS_MAC)
        QProcess::startDetached("open", {"-R", path});
        #else
        QProcess::startDetached("xdg-open", {QFileInfo(path).absolutePath()});
        #endif
    } else if(picked==aRemove){
        table->removeRow(r);
        if(r>=0 && r<rows.size()) rows.remove(r);
    }
}

void MainWindow::applyFilter(){
    const QString f = leFilter->text().trimmed();
    for(int r=0; r<table->rowCount(); ++r){
        bool match=false;
        for(int c=0;c<table->columnCount();++c){
            auto *it=table->item(r,c); if(!it) continue;
            if(it->text().contains(f, Qt::CaseInsensitive)){ match=true; break; }
        }
        table->setRowHidden(r, !f.isEmpty() && !match);
    }
}

// ===== Exports =====
void MainWindow::exportCsv(){
    if(table->rowCount()==0){ QMessageBox::information(this,"No data","Scan something first."); return; }
    const QString f = QFileDialog::getSaveFileName(this, "Save CSV", "metatrack_results.csv", "CSV (*.csv)");
    if(f.isEmpty()) return;
    QFile file(f);
    if(!file.open(QIODevice::WriteOnly|QIODevice::Text)){ QMessageBox::warning(this,"Error","Cannot write file."); return; }
    QTextStream ts(&file);
    QStringList headers;
    for(int c=0;c<table->columnCount();++c) headers<<table->horizontalHeaderItem(c)->text();
    ts<<headers.join(",")<<"\n";
    for(int r=0;r<table->rowCount();++r){
        QStringList line;
        for(int c=0;c<table->columnCount();++c){
            QString cell= table->item(r,c)? table->item(r,c)->text():QString();
            line<<sanitizeCsv(cell);
        }
        ts<<line.join(",")<<"\n";
    }
    file.close();
    sb->showMessage("CSV exported: "+f, 4000);
}

void MainWindow::exportHtml(){
    if(table->rowCount()==0){ QMessageBox::information(this,"No data","Scan something first."); return; }
    const QString f = QFileDialog::getSaveFileName(this, "Save HTML Report", "metatrack_report.html", "HTML (*.html)");
    if(f.isEmpty()) return;

    QString html; QTextStream out(&html);
    auto esc = [](const QString&s){ QString t=s; t.replace("&","&amp;").replace("<","&lt;").replace(">","&gt;"); return t; };

    out << "<!doctype html><html lang='en'><head><meta charset='utf-8'/>"
    "<meta name='viewport' content='width=device-width,initial-scale=1'/>"
    "<title>MetaTrack Audit Report</title>"
    "<style>"
    "body{font-family:Inter,Segoe UI,Roboto,Arial;color:#ece7f7;background:#0b0712;margin:0}"
    "header,footer{padding:16px 24px;background:#1f1531;border-bottom:1px solid #2c1f43}"
    "h1{margin:0;font-size:20px;color:#e8defb}"
    ".wrap{padding:24px}"
    ".card{background:#1a1228;border:1px solid #3d2c60;border-radius:14px;margin:12px 0;padding:16px}"
    ".badge{display:inline-block;padding:2px 8px;border-radius:999px;border:1px solid #7a57d1}"
    "table{width:100%;border-collapse:collapse;margin-top:8px}"
    "th,td{border-bottom:1px solid #2c1f43;padding:8px;text-align:left}"
    ".risk-high{color:#ff89a5}.risk-low{color:#9ff7a1}"
    ".muted{color:#bfa9ff}"
    ".map-note{height:180px;background:#120a1f;border:1px dashed #3d2c60;border-radius:12px;display:flex;align-items:center;justify-content:center;color:#c9b9ff}"
    "</style></head><body>";
    out << "<header><h1>MetaTrack — Metadata Audit Report</h1>"
    "<div class='muted'>Generated: "<<esc(nowTs())<<"</div></header><div class='wrap'>";

    int gpsCount=0;
    for(const auto &rd: rows) if(rd.r.hasGps) ++gpsCount;
    out << "<div class='card'><strong>Summary</strong>"
    "<div class='muted'>Files scanned: "<<rows.size()<<
    " • GPS present: "<<gpsCount<<
    " • Coordinates masked by default</div></div>";

    for(const auto &rd: rows){
        const auto &r = rd.r;
        const QString risk = r.hasGps?"High":"Low";
        out << "<div class='card'>";
        out << "<div><strong>"<<esc(QFileInfo(r.path).fileName())<<"</strong> "
        "<span class='badge'>"<<esc(risk)<<" Risk</span></div>";
        out << "<div class='muted'>Size "<<esc(fileSizeHuman(r.bytes))<<" • SHA-256 "<<esc(r.sha256)<<"</div>";
        out << "<table><thead><tr><th>Tag</th><th>Value</th><th>Risk</th><th>Action</th></tr></thead><tbody>";
        if(r.hasGps){
            out << "<tr><td>GPSPosition</td><td>"
            << esc(QString("%1, %2 (masked)").arg(r.lat,0,'f',2).arg(r.lon,0,'f',2))
            << "</td><td class='risk-high'>High</td><td>Kept (hidden)</td></tr>";
        } else {
            out << "<tr><td>GPSPosition</td><td>—</td><td class='risk-low'>Low</td><td>—</td></tr>";
        }
        out << "</tbody></table>";
        if(r.hasGps){
            out << "<div class='map-note'>Coordinates present. Hidden by policy. OSM: "
            << "<a style='color:#bfa9ff' href='"<<esc(r.osmUrl)<<"'>open</a></div>";
        }
        out << "</div>";
    }
    out << "</div><footer>Authorized use only. This report may contain sensitive data.</footer></body></html>";

    QFile file(f);
    if(!file.open(QIODevice::WriteOnly|QIODevice::Text)){ QMessageBox::warning(this,"Error","Cannot write HTML."); return; }
    QTextStream ts(&file); ts<<html; file.close();
    sb->showMessage("HTML report exported: "+f, 4000);
}

// ===== Audit =====
void MainWindow::writeAudit(const QString &action, const QString &filePath, const QString &status, const QString &details){
    QJsonObject obj{
        {"time", nowTs()},
        {"action", action},
        {"file", QFileInfo(filePath).fileName()},
        {"path", QFileInfo(filePath).absoluteFilePath()},
        {"sha256", sha256File(filePath)},
        {"status", status},
        {"details", details}
    };
    const QString line = QString::fromUtf8(QJsonDocument(obj).toJson(QJsonDocument::Compact))+"\n";
    const QString logDir = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
    QDir().mkpath(logDir);
    QFile f(QDir(logDir).absoluteFilePath("audit.jsonl"));
    if(f.open(QIODevice::Append|QIODevice::Text)){
        f.write(line.toUtf8());
        f.close();
    }
}

// ===== Drop / Append =====
void MainWindow::handleDroppedFiles(const QStringList &paths){
    QStringList files;
    for(const QString &p: paths){
        QFileInfo fi(p);
        if(fi.isDir()) files<<collectFiles(p, cbRecurse->isChecked());
        else if(fi.isFile()) files<<fi.absoluteFilePath();
    }
    if(files.isEmpty()) return;
    if(!cbAuthorized->isChecked()){
        QMessageBox::warning(this,"Authorization Required","Confirm authorization before scanning.");
        return;
    }
    progress->setVisible(true); progress->setValue(0);
    int done=0, total=files.size();
    for(const QString &f: files){
        GpsResult res = ExifTool::analyze(f);
        addRow(res);
        progress->setValue(++done*100/qMax(1,total));
        qApp->processEvents();
    }
    progress->setVisible(false);
    sb->showMessage("Drag & drop scan complete.", 4000);
}

void MainWindow::appendUrls(const QStringList &u){
    if(!cbEnableUrlPipe->isChecked()) return;
    QString t=urlBox->toPlainText();
    if(!t.isEmpty() && !t.endsWith('\n')) t.append("\n");
    urlBox->setPlainText(t + u.join("\n"));
}

// ===== Log helpers =====
void MainWindow::logHtml(const QString &h){ log->append(QString("<span style='color:#bfa9ff'>[%1]</span> %2").arg(nowTs(), h)); }
void MainWindow::logInfo(const QString&m){ logHtml(QString("<span style='color:#e7dcff'>%1</span>").arg(m.toHtmlEscaped())); }
void MainWindow::logWarn(const QString&m){ logHtml(QString("<span style='color:#ffd97a'>⚠ %1</span>").arg(m.toHtmlEscaped())); }
void MainWindow::logError(const QString&m){ logHtml(QString("<span style='color:#ff89a5'>✖ %1</span>").arg(m.toHtmlEscaped())); }
void MainWindow::logOk(const QString&m){ logHtml(QString("<span style='color:#9ff7a1'>✔ %1</span>").arg(m.toHtmlEscaped())); }
void MainWindow::logAlert(const QString&m){ logHtml(QString("<span style='color:#ffb0c9; font-weight:600'>%1</span>").arg(m.toHtmlEscaped())); }
void MainWindow::logGps(const QString&m){ logHtml(QString("<code style='color:#c9b9ff'>%1</code>").arg(m.toHtmlEscaped())); }