<?php
/**
 * AutoDashPro ERP - bootstrap
 * SQLite init, schema, helpers, profit engine
 */
declare(strict_types=1);
error_reporting(E_ALL & ~E_DEPRECATED);
ini_set('display_errors', '1');
date_default_timezone_set('Asia/Shanghai');

session_start();
define('ERP_ROOT', dirname(__DIR__));
define('DATA_DIR', ERP_ROOT . '/data');
if (!is_dir(DATA_DIR)) { @mkdir(DATA_DIR, 0775, true); }
if (!is_dir(DATA_DIR)) { die('无法创建 data 目录，请检查目录权限'); }
define('UPLOADS_DIR', ERP_ROOT . '/uploads/dump');
if (!is_dir(UPLOADS_DIR)) { @mkdir(UPLOADS_DIR, 0775, true); }

/* ---------- DB ---------- */
function db(): PDO {
    static $pdo = null;
    if ($pdo === null) {
        $pdo = new PDO('sqlite:' . DATA_DIR . '/erp.sqlite');
        $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        $pdo->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
        $pdo->exec('PRAGMA journal_mode=WAL');
        $pdo->exec('PRAGMA foreign_keys=ON');
    }
    return $pdo;
}
function q(string $sql, array $args = []): PDOStatement {
    $st = db()->prepare($sql); $st->execute($args); return $st;
}
function qv(string $sql, array $args = []) { return q($sql, $args)->fetch(); }
function qx(string $sql, array $args = []) { return q($sql, $args)->fetchColumn(); }

function erp_install(): void {
    db()->exec("
    CREATE TABLE IF NOT EXISTS settings(key TEXT PRIMARY KEY, value TEXT);
    CREATE TABLE IF NOT EXISTS users(id INTEGER PRIMARY KEY AUTOINCREMENT, username TEXT UNIQUE, password_hash TEXT, created_at TEXT DEFAULT (datetime('now','localtime')));
    CREATE TABLE IF NOT EXISTS channels(id INTEGER PRIMARY KEY AUTOINCREMENT, code TEXT UNIQUE, name TEXT, type TEXT DEFAULT 'woocommerce', currency TEXT DEFAULT 'USD', commission_rate REAL DEFAULT 0, fixed_fee REAL DEFAULT 0, rate REAL DEFAULT 1, color TEXT DEFAULT '#4F46E5', enabled INTEGER DEFAULT 1);
    CREATE TABLE IF NOT EXISTS products(id INTEGER PRIMARY KEY AUTOINCREMENT, sku TEXT UNIQUE, name TEXT, category TEXT DEFAULT '', cost REAL DEFAULT 0, price REAL DEFAULT 0, weight_kg REAL DEFAULT 0, image TEXT DEFAULT '', local_image TEXT DEFAULT '', status TEXT DEFAULT 'active', woo_id INTEGER, woo_type TEXT DEFAULT 'simple', parent_sku TEXT DEFAULT '', supplier TEXT DEFAULT '', notes TEXT DEFAULT '', updated_at TEXT DEFAULT (datetime('now','localtime')));
    CREATE TABLE IF NOT EXISTS listings(id INTEGER PRIMARY KEY AUTOINCREMENT, product_id INTEGER, channel_id INTEGER, external_id TEXT, title TEXT, url TEXT DEFAULT '', price REAL DEFAULT 0, status TEXT DEFAULT 'active', last_sync TEXT);
    CREATE TABLE IF NOT EXISTS fitment(id INTEGER PRIMARY KEY AUTOINCREMENT, product_id INTEGER, make TEXT, model TEXT, year_start INTEGER, year_end INTEGER);
    CREATE TABLE IF NOT EXISTS inventory(id INTEGER PRIMARY KEY AUTOINCREMENT, product_id INTEGER UNIQUE, warehouse TEXT DEFAULT '默认仓', qty INTEGER DEFAULT 0, reorder_point INTEGER DEFAULT 2);
    CREATE TABLE IF NOT EXISTS inventory_log(id INTEGER PRIMARY KEY AUTOINCREMENT, product_id INTEGER, warehouse TEXT, delta INTEGER, balance_after INTEGER, source TEXT, ref TEXT DEFAULT '', note TEXT DEFAULT '', created_at TEXT DEFAULT (datetime('now','localtime')));
    CREATE TABLE IF NOT EXISTS purchase_orders(id INTEGER PRIMARY KEY AUTOINCREMENT, po_no TEXT UNIQUE, supplier TEXT DEFAULT '', status TEXT DEFAULT 'draft', note TEXT DEFAULT '', est_amount REAL DEFAULT 0, created_at TEXT DEFAULT (datetime('now','localtime')), received_at TEXT);
    CREATE TABLE IF NOT EXISTS po_items(id INTEGER PRIMARY KEY AUTOINCREMENT, po_id INTEGER, product_id INTEGER, sku TEXT, name TEXT, qty INTEGER, received INTEGER DEFAULT 0, cost REAL DEFAULT 0);
    CREATE TABLE IF NOT EXISTS shipping_rules(id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, dest TEXT DEFAULT 'US', first_weight_kg REAL DEFAULT 1, first_fee REAL DEFAULT 0, per_kg REAL DEFAULT 0, carrier TEXT DEFAULT '', enabled INTEGER DEFAULT 1);
    CREATE TABLE IF NOT EXISTS orders(id INTEGER PRIMARY KEY AUTOINCREMENT, order_no TEXT UNIQUE, channel_id INTEGER, external_id TEXT, buyer TEXT DEFAULT '', country TEXT DEFAULT '', state TEXT DEFAULT '', currency TEXT DEFAULT 'USD', total REAL DEFAULT 0, items_count INTEGER DEFAULT 0, weight_kg REAL DEFAULT 0, status TEXT DEFAULT 'review', cost REAL DEFAULT 0, shipping_fee REAL DEFAULT 0, pay_fee REAL DEFAULT 0, commission REAL DEFAULT 0, ad_alloc REAL DEFAULT 0, profit REAL DEFAULT 0, carrier TEXT DEFAULT '', tracking_no TEXT DEFAULT '', ordered_at TEXT, shipped_at TEXT, note TEXT DEFAULT '', exception TEXT DEFAULT '', updated_at TEXT DEFAULT (datetime('now','localtime')));
    CREATE TABLE IF NOT EXISTS order_items(id INTEGER PRIMARY KEY AUTOINCREMENT, order_id INTEGER, product_id INTEGER, sku TEXT, name TEXT, qty INTEGER, price REAL, cost REAL DEFAULT 0);
    CREATE TABLE IF NOT EXISTS aftersales(id INTEGER PRIMARY KEY AUTOINCREMENT, no TEXT UNIQUE, type TEXT DEFAULT 'refund', order_id INTEGER, order_no TEXT DEFAULT '', channel_id INTEGER, buyer TEXT DEFAULT '', amount REAL DEFAULT 0, status TEXT DEFAULT 'open', reason TEXT DEFAULT '', resolution TEXT DEFAULT '', created_at TEXT DEFAULT (datetime('now','localtime')), updated_at TEXT);
    CREATE TABLE IF NOT EXISTS tickets(id INTEGER PRIMARY KEY AUTOINCREMENT, no TEXT UNIQUE, buyer TEXT DEFAULT '', subject TEXT, type TEXT DEFAULT 'pre-sale', priority TEXT DEFAULT 'normal', status TEXT DEFAULT 'open', order_no TEXT DEFAULT '', last_msg_at TEXT, created_at TEXT DEFAULT (datetime('now','localtime')));
    CREATE TABLE IF NOT EXISTS ticket_messages(id INTEGER PRIMARY KEY AUTOINCREMENT, ticket_id INTEGER, direction TEXT DEFAULT 'in', body TEXT, created_at TEXT DEFAULT (datetime('now','localtime')));
    CREATE TABLE IF NOT EXISTS mail_accounts(id INTEGER PRIMARY KEY AUTOINCREMENT, email TEXT, host TEXT, port INTEGER DEFAULT 993, mail_user TEXT, mail_pass TEXT, ssl INTEGER DEFAULT 1, last_error TEXT DEFAULT '', last_check TEXT);
    CREATE TABLE IF NOT EXISTS ads_daily(id INTEGER PRIMARY KEY AUTOINCREMENT, date TEXT, channel_id INTEGER DEFAULT 1, spend REAL DEFAULT 0, impressions INTEGER DEFAULT 0, clicks INTEGER DEFAULT 0, orders INTEGER DEFAULT 0, sales REAL DEFAULT 0, UNIQUE(date, channel_id));
    CREATE TABLE IF NOT EXISTS ads_keywords(id INTEGER PRIMARY KEY AUTOINCREMENT, date TEXT, keyword TEXT, campaign TEXT DEFAULT '', impressions INTEGER DEFAULT 0, clicks INTEGER DEFAULT 0, spend REAL DEFAULT 0, sales REAL DEFAULT 0, orders INTEGER DEFAULT 0);
    CREATE TABLE IF NOT EXISTS img_dump(id INTEGER PRIMARY KEY AUTOINCREMENT, hash TEXT UNIQUE, orig_name TEXT DEFAULT '', src TEXT DEFAULT '', ext TEXT DEFAULT '', size INTEGER DEFAULT 0, created_at TEXT DEFAULT (datetime('now','localtime')));
    CREATE INDEX IF NOT EXISTS idx_imgdump_hash ON img_dump(hash);
    CREATE INDEX IF NOT EXISTS idx_orders_status ON orders(status);
    CREATE INDEX IF NOT EXISTS idx_orders_date ON orders(ordered_at);
    CREATE INDEX IF NOT EXISTS idx_fitment ON fitment(make, model);
    ");
    $v = setting('schema_version', '0');
    if ($v === '0') set_setting('schema_version', '1');
    // seeds
    if (!qx("SELECT COUNT(*) FROM channels")) {
        q("INSERT INTO channels(code,name,type,currency,commission_rate,fixed_fee,rate,color,enabled) VALUES('WOO','WooCommerce 独立站','woocommerce','USD',0,0,1,'#4F46E5',1)");
    }
    if (!qx("SELECT COUNT(*) FROM users")) {
        q("INSERT INTO users(username,password_hash) VALUES(?,?)", ['admin', password_hash('admin123', PASSWORD_DEFAULT)]);
    }
    if (!qx("SELECT COUNT(*) FROM shipping_rules")) {
        q("INSERT INTO shipping_rules(name,dest,first_weight_kg,first_fee,per_kg,carrier,enabled) VALUES
          ('美国经济小包','US',1,6.90,2.30,'4PX-US-ECON',1),
          ('美国标准专线','US',1,9.50,3.20,'YunExpress-US-STD',1),
          ('全球其他','*',1,8.00,3.00,'4PX-GLB',1)");
    }
}

/* ---------- helpers ---------- */
function h($s): string { return htmlspecialchars((string)$s, ENT_QUOTES, 'UTF-8'); }
function money($n, string $cur = 'USD'): string {
    if ($cur === 'CNY') return '¥ ' . number_format((float)$n, 2);
    return 'USD ' . number_format((float)$n, 2);
}
function &erp_settings_cache(): array {
    static $cache = null;
    if ($cache === null) { $cache = []; foreach (q("SELECT key,value FROM settings")->fetchAll() as $r) $cache[$r['key']] = $r['value']; }
    return $cache;
}
function setting(string $k, $def = '') {
    $c = &erp_settings_cache();
    return $c[$k] ?? $def;
}
function set_setting(string $k, string $v): void {
    q("INSERT INTO settings(key,value) VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value", [$k, $v]);
    $c = &erp_settings_cache();
    $c[$k] = $v;
}
function redirect(string $to): void { header('Location: ' . $to); exit; }
function flash(?string $msg = null, string $type = 'ok') {
    if ($msg !== null) { $_SESSION['flash'] = [$msg, $type]; return null; }
    if (!empty($_SESSION['flash'])) { $f = $_SESSION['flash']; unset($_SESSION['flash']); return $f; }
    return null;
}
function csrf_token(): string { if (empty($_SESSION['csrf'])) $_SESSION['csrf'] = bin2hex(random_bytes(16)); return $_SESSION['csrf']; }
function csrf_ok(): bool { return hash_equals($_SESSION['csrf'] ?? '', $_POST['_csrf'] ?? ''); }
function require_csrf(): void { if (!csrf_ok()) { flash('表单校验失败，请重试', 'err'); redirect($_SERVER['HTTP_REFERER'] ?? '?page=dashboard'); } }
function post_str(string $k, string $def = ''): string { return trim((string)($_POST[$k] ?? $def)); }
function post_num(string $k, float $def = 0): float { $v = $_POST[$k] ?? $def; return is_numeric($v) ? (float)$v : $def; }
function get_str(string $k, string $def = ''): string { return trim((string)($_GET[$k] ?? $def)); }
function uid(): int { return (int)($_SESSION['uid'] ?? 0); }
function gen_no(string $prefix): string { return $prefix . date('ymd') . strtoupper(substr(bin2hex(random_bytes(2)), 0, 4)); }

/* order status maps */
function order_statuses(): array { return ['review' => '待审核', 'processing' => '备货中', 'shipped' => '已发货', 'completed' => '已完成', 'hold' => '已挂起', 'cancelled' => '已取消']; }
function aftersale_statuses(): array { return ['open' => '待处理', 'processing' => '处理中', 'done' => '已完成', 'rejected' => '已拒绝']; }
function ticket_statuses(): array { return ['open' => '处理中', 'pending' => '待客户', 'closed' => '已关闭']; }
function ticket_priorities(): array { return ['low' => '低', 'normal' => '普通', 'high' => '高', 'urgent' => '紧急']; }

function status_pill(string $s): string {
    $map = [
        'review' => 'pill-warn', 'processing' => 'pill-info', 'shipped' => 'pill-blue', 'completed' => 'pill-ok',
        'hold' => 'pill-gray', 'cancelled' => 'pill-gray',
        'open' => 'pill-warn', 'pending' => 'pill-info', 'done' => 'pill-ok', 'closed' => 'pill-gray', 'rejected' => 'pill-gray',
        'draft' => 'pill-gray', 'ordered' => 'pill-info', 'received' => 'pill-ok',
        'active' => 'pill-ok', 'urgent' => 'pill-err', 'high' => 'pill-warn', 'normal' => 'pill-info', 'low' => 'pill-gray',
    ];
    $label = order_statuses()[$s] ?? aftersale_statuses()[$s] ?? ticket_statuses()[$s] ?? ticket_priorities()[$s] ?? ucfirst($s);
    return '<span class="pill ' . ($map[$s] ?? 'pill-gray') . '">' . h($label) . '</span>';
}

/* csv download */
function csv_out(string $filename, array $headers, array $rows): void {
    header('Content-Type: text/csv; charset=UTF-8');
    header('Content-Disposition: attachment; filename="' . $filename . '"');
    echo "\xEF\xBB\xBF";
    $out = fopen('php://output', 'w');
    fputcsv($out, $headers);
    foreach ($rows as $r) fputcsv($out, array_map(fn($v) => (string)$v, $r));
    fclose($out); exit;
}

/* ---------- profit engine ---------- */
function order_weight(int $orderId): float {
    $w = (float)qx("SELECT COALESCE(SUM(p.weight_kg*oi.qty),0) FROM order_items oi LEFT JOIN products p ON p.id=oi.product_id WHERE oi.order_id=?", [$orderId]);
    return $w > 0 ? $w : 0.8; // 默认按 0.8kg 估
}
function shipping_fee_for(float $weightKg, string $country): array {
    $rules = q("SELECT * FROM shipping_rules WHERE enabled=1 AND (dest=? OR dest='*') ORDER BY dest='*' ASC", [$country ?: '*'])->fetchAll();
    if (!$rules) return [0.0, ''];
    $r = $rules[0];
    $w = max($weightKg, (float)$r['first_weight_kg']);
    $fee = (float)$r['first_fee'] + ceil(max(0, $w - (float)$r['first_weight_kg']) * 10) / 10 * (float)$r['per_kg'];
    return [round($fee, 2), (string)$r['carrier']];
}
function recalc_order(int $orderId): void {
    $o = qv("SELECT * FROM orders WHERE id=?", [$orderId]);
    if (!$o) return;
    $cost = (float)qx("SELECT COALESCE(SUM(COALESCE(oi.cost,p.cost,0)*oi.qty),0) FROM order_items oi LEFT JOIN products p ON p.id=oi.product_id WHERE oi.order_id=?", [$orderId]);
    [$ship, $carrier] = shipping_fee_for(order_weight($orderId), $o['country']);
    $ch = qv("SELECT * FROM channels WHERE id=?", [$o['channel_id'] ?: 0]);
    $rate = (float)setting('pay_rate', '0.029');
    $fixed = (float)setting('pay_fixed', '0.30');
    $pay = round($o['total'] * $rate + $fixed, 2);
    $comm = round($o['total'] * (float)($ch['commission_rate'] ?? 0) + (float)($ch['fixed_fee'] ?? 0) * (float)($ch['rate'] ?? 1), 2);
    $profit = round($o['total'] - $cost - $ship - $pay - $comm - (float)$o['ad_alloc'], 2);
    q("UPDATE orders SET cost=?, shipping_fee=?, pay_fee=?, commission=?, profit=?, carrier=CASE WHEN ?<>'' THEN ? ELSE carrier END, updated_at=datetime('now','localtime') WHERE id=?",
        [$cost, $ship, $pay, $comm, $profit, $carrier, $carrier, $orderId]);
}
function recalc_all_orders(): void {
    foreach (q("SELECT id FROM orders")->fetchAll() as $r) recalc_order((int)$r['id']);
}
/* 按销售额比例把区间广告费分摊到订单 */
function alloc_ads(string $from, string $to): void {
    $spend = (float)qx("SELECT COALESCE(SUM(spend),0) FROM ads_daily WHERE date BETWEEN ? AND ?", [$from, $to]);
    q("UPDATE orders SET ad_alloc=0 WHERE ordered_at BETWEEN ? AND ?", [$from, $to]);
    if ($spend <= 0) return;
    $sales = (float)qx("SELECT COALESCE(SUM(total),0) FROM orders WHERE ordered_at BETWEEN ? AND ? AND status<>'cancelled'", [$from, $to]);
    if ($sales <= 0) return;
    q("UPDATE orders SET ad_alloc=ROUND(total/?*?,2) WHERE ordered_at BETWEEN ? AND ? AND status<>'cancelled'", [$sales, $spend, $from, $to]);
    foreach (q("SELECT id FROM orders WHERE ordered_at BETWEEN ? AND ?", [$from, $to])->fetchAll() as $r) recalc_order((int)$r['id']);
}

/* ---------- inventory ---------- */
function inv_get(int $productId): array {
    $r = qv("SELECT * FROM inventory WHERE product_id=?", [$productId]);
    if (!$r) { q("INSERT INTO inventory(product_id) VALUES(?)", [$productId]); $r = qv("SELECT * FROM inventory WHERE product_id=?", [$productId]); }
    return $r;
}
function inv_move(int $productId, int $delta, string $source, string $ref = '', string $note = '', string $warehouse = '默认仓'): void {
    inv_get($productId);
    q("UPDATE inventory SET qty=qty+? WHERE product_id=?", [$delta, $productId]);
    $bal = (int)qx("SELECT qty FROM inventory WHERE product_id=?", [$productId]);
    q("INSERT INTO inventory_log(product_id,warehouse,delta,balance_after,source,ref,note) VALUES(?,?,?,?,?,?,?)",
        [$productId, $warehouse, $delta, $bal, $source, $ref, $note]);
}
/* 订单发货占用/释放库存 */
function order_inventory_effect(array $order, string $newStatus, string $oldStatus): void {
    $occupy = ['processing', 'shipped'];
    $was = in_array($oldStatus, $occupy, true);
    $now = in_array($newStatus, $occupy, true);
    if ($was === $now) return;
    $sign = $now ? -1 : 1; // 备货/发货时占用（扣可用），回退则返还
    foreach (q("SELECT * FROM order_items WHERE order_id=?", [$order['id']])->fetchAll() as $it) {
        if (!$it['product_id']) continue;
        inv_move((int)$it['product_id'], $sign * (int)$it['qty'], 'order', $order['order_no'], $now ? '订单占用库存' : '释放订单占用');
    }
}

/* ---------- rule engine: 一键审核 ---------- */
function run_rules(): array {
    $auto = 0; $ex = 0;
    $rows = q("SELECT * FROM orders WHERE status='review'")->fetchAll();
    foreach ($rows as $o) {
        $reason = '';
        if ((float)$o['total'] >= 500) $reason = '高风险：客单价 ≥ $500，人工复核';
        elseif (!$o['country']) $reason = '缺少收货国家';
        elseif (!filter_var($o['buyer'], FILTER_VALIDATE_EMAIL) && $o['buyer'] === '') $reason = '缺少买家信息';
        if ($reason === '') {
            // 物流匹配
            [$fee, $carrier] = shipping_fee_for(order_weight((int)$o['id']), $o['country']);
            q("UPDATE orders SET status='processing', carrier=?, exception='' WHERE id=?", [$carrier, $o['id']]);
            recalc_order((int)$o['id']);
            order_inventory_effect($o, 'processing', 'review');
            $auto++;
        } else { q("UPDATE orders SET exception=? WHERE id=?", [$reason, $o['id']]); $ex++; }
    }
    return [$auto, $ex, count($rows)];
}

/* ---------- svg charts ---------- */
function svg_line(array $points, int $w = 560, int $ht = 160, string $color = '#4F46E5', string $fill = 'rgba(79,70,229,.08)'): string {
    if (count($points) < 2) return '<div class="empty">暂无数据</div>';
    $max = max($points); $min = min($points);
    if ($max == $min) { $max += 1; }
    $n = count($points); $pad = 6;
    $pts = []; $area = [];
    foreach ($points as $i => $v) {
        $x = $pad + $i * ($w - 2 * $pad) / ($n - 1);
        $y = $ht - $pad - ($v - $min) / ($max - $min) * ($ht - 2 * $pad);
        $pts[] = round($x, 1) . ',' . round($y, 1);
        $area[] = round($x, 1) . ',' . round($ht - $pad, 1);
        $area[] = round($x, 1) . ',' . round($y, 1);
    }
    return '<svg viewBox="0 0 ' . $w . ' ' . $ht . '" class="chart">' .
        '<polygon points="' . h(implode(' ', $area)) . '" fill="' . $fill . '"/>' .
        '<polyline points="' . h(implode(' ', $pts)) . '" fill="none" stroke="' . $color . '" stroke-width="2.5" stroke-linejoin="round" stroke-linecap="round"/></svg>';
}
function svg_bars(array $labels, array $values, int $w = 560, int $ht = 180, string $color = '#4F46E5'): string {
    if (!$values) return '<div class="empty">暂无数据</div>';
    $max = max($values) ?: 1;
    $n = count($values); $bw = ($w - 20) / $n;
    $s = '<svg viewBox="0 0 ' . $w . ' ' . $ht . '" class="chart">';
    foreach ($values as $i => $v) {
        $bh = ($v / $max) * ($ht - 40);
        $x = 10 + $i * $bw + $bw * 0.15;
        $s .= '<rect x="' . round($x, 1) . '" y="' . round($ht - 24 - $bh, 1) . '" width="' . round($bw * 0.7, 1) . '" height="' . round($bh, 1) . '" rx="3" fill="' . $color . '"/>';
        if ($n <= 14) $s .= '<text x="' . round($x + $bw * 0.35, 1) . '" y="' . ($ht - 8) . '" font-size="10" text-anchor="middle" fill="#94a3b8">' . h($labels[$i]) . '</text>';
    }
    return $s . '</svg>';
}

/* ---------- badge counts ---------- */
function badge_counts(): array {
    return [
        'review' => (int)qx("SELECT COUNT(*) FROM orders WHERE status='review'"),
        'lowstock' => (int)qx("SELECT COUNT(*) FROM inventory i JOIN products p ON p.id=i.product_id WHERE p.status='active' AND i.qty<=i.reorder_point"),
        'aftersale' => (int)qx("SELECT COUNT(*) FROM aftersales WHERE status IN('open','processing')"),
        'tickets' => (int)qx("SELECT COUNT(*) FROM tickets WHERE status<>'closed'"),
    ];
}

/* date range for dashboard */
function range_dates(string $range): array {
    switch ($range) {
        case 'today': return [date('Y-m-d 00:00:00'), date('Y-m-d 23:59:59'), date('Y-m-d')];
        case '7d': return [date('Y-m-d 00:00:00', strtotime('-6 days')), date('Y-m-d 23:59:59'), date('Y-m-d', strtotime('-6 days'))];
        case 'mtd': return [date('Y-m-01 00:00:00'), date('Y-m-d 23:59:59'), date('Y-m-01')];
        case '90d': return [date('Y-m-d 00:00:00', strtotime('-89 days')), date('Y-m-d 23:59:59'), date('Y-m-d', strtotime('-89 days'))];
        default: return [date('Y-m-d 00:00:00', strtotime('-29 days')), date('Y-m-d 23:59:59'), date('Y-m-d', strtotime('-29 days'))];
    }
}

/* ---------- demo data ---------- */
function seed_demo_data(): void {
    $fits = [
        ['DEMO-Ram-1500-13', 'For Dodge Ram 1500 2013-2018 Android Head Unit Carplay 10.1"', '车机', 96.00, 269.00, 3.2, 'Dodge', 'Ram 1500', 2013, 2018],
        ['DEMO-Charger-11', 'For Dodge Charger 2011-2014 Android Stereo GPS Carplay', '车机', 92.00, 269.00, 3.0, 'Dodge', 'Charger', 2011, 2014],
        ['DEMO-F150-15', 'For Ford F-150 2015-2020 12.1" Android 13 Head Unit', '车机', 118.00, 329.00, 3.8, 'Ford', 'F-150', 2015, 2020],
        ['DEMO-Civic-16', 'For Honda Civic 2016-2021 Wireless CarPlay Android Auto Head Unit', '车机', 88.00, 259.00, 2.6, 'Honda', 'Civic', 2016, 2021],
        ['DEMO-Camry-18', 'For Toyota Camry 2018-2024 10.1" Android Car Stereo', '车机', 99.00, 279.00, 2.8, 'Toyota', 'Camry', 2018, 2024],
        ['DEMO-Silverado-14', 'For Chevrolet Silverado 2014-2018 Android Head Unit', '车机', 102.00, 289.00, 3.3, 'Chevrolet', 'Silverado', 2014, 2018],
        ['DEMO-ACC-KIT', 'Universal Dash Kit & Wiring Harness for Installation', '配件', 6.50, 24.99, 0.3, '', '', 0, 0],
        ['DEMO-CAM-BK', 'HD Backup Camera Reverse Parking Camera', '配件', 11.00, 39.99, 0.2, '', '', 0, 0],
    ];
    foreach ($fits as $f) {
        if (qv("SELECT id FROM products WHERE sku=?", [$f[0]])) continue;
        q("INSERT INTO products(sku,name,category,cost,price,weight_kg,supplier,status) VALUES(?,?,?,?,?,?,?, 'active')",
            [$f[0], $f[1], $f[2], $f[3], $f[4], $f[5], 'Demo Supplier 深圳华强北']);
        $pid = (int)db()->lastInsertId();
        q("INSERT INTO inventory(product_id,qty,reorder_point) VALUES(?,?,2)", [$pid, random_int(2, 40)]);
        if ($f[6] !== '') q("INSERT INTO fitment(product_id,make,model,year_start,year_end) VALUES(?,?,?,?,?)", [$pid, $f[6], $f[7], $f[8], $f[9]]);
    }
    $pids = q("SELECT id,sku,price,cost,weight_kg FROM products WHERE sku LIKE 'DEMO-%'")->fetchAll();
    $chId = (int)(qx("SELECT id FROM channels WHERE code='WOO'") ?: 1);
    $names = ['Mike J', 'Sarah K', 'Tom W', 'Emily R', 'David L', 'Anna P', 'Chris B', 'Laura T'];
    $states = [['US', 'CA'], ['US', 'TX'], ['US', 'NY'], ['US', 'FL'], ['US', 'WA'], ['CA', 'ON']];
    for ($i = 90; $i >= 0; $i--) {
        $day = date('Y-m-d', strtotime("-$i days"));
        // 每天订单量：基础 0-3 单，周末略高，偶发爆单
        $n = random_int(0, 3) + (random_int(1, 100) <= 12 ? random_int(2, 6) : 0);
        for ($j = 0; $j < $n; $j++) {
            $ext = 'DEMO' . $i . $j . random_int(1000, 9999);
            if (qv("SELECT id FROM orders WHERE external_id=?", [$ext])) continue;
            $p = $pids[array_rand($pids)];
            $qty = random_int(1, 2);
            $st = $states[array_rand($states)];
            $total = round($p['price'] * $qty, 2);
            $ts = $day . ' ' . sprintf('%02d:%02d:00', random_int(6, 23), random_int(0, 59));
            q("INSERT INTO orders(order_no,channel_id,external_id,buyer,country,state,currency,total,items_count,status,ordered_at,note) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)",
                ['WOO-' . $ext, $chId, $ext, $names[array_rand($names)], $st[0], $st[1], 'USD', $total, $qty, 'review', $ts, 'demo']);
            $oid = (int)db()->lastInsertId();
            q("INSERT INTO order_items(order_id,product_id,sku,name,qty,price,cost) VALUES(?,?,?,?,?,?,?)",
                [$oid, $p['id'], $p['sku'], 'Demo Item', $qty, $p['price'], $p['cost']]);
            recalc_order($oid);
            // 状态推进
            $age = 90 - $i;
            if ($age > 2) {
                $o = qv("SELECT * FROM orders WHERE id=?", [$oid]);
                $stt = $age > 10 ? (random_int(1, 100) <= 88 ? 'completed' : 'shipped') : ($age > 4 ? 'shipped' : 'processing');
                order_inventory_effect($o, $stt, 'review');
                q("UPDATE orders SET status=?, shipped_at=datetime(?, '+2 days') WHERE id=?", [$stt, $ts, $oid]);
            }
        }
        // 广告日报
        if (random_int(1, 100) <= 85) {
            $spend = round(random_int(15, 120) + random_int(0, 99) / 100, 2);
            $sales = round($spend * (random_int(80, 350) / 100), 2);
            q("INSERT INTO ads_daily(date,channel_id,spend,impressions,clicks,orders,sales) VALUES(?,?,?,?,?,?,?)
               ON CONFLICT(date,channel_id) DO UPDATE SET spend=excluded.spend, sales=excluded.sales, impressions=excluded.impressions, clicks=excluded.clicks, orders=excluded.orders",
                [$day, $chId, $spend, random_int(2000, 20000), random_int(80, 900), random_int(0, 4), $sales]);
        }
    }
}

erp_install();
