intra.noxus.fi/db.php

<?php
/**
 * Noxus Intra — Tietokantakerros (PDO/MySQL)
 *
 * Korvaa kaikki JSON-tiedosto-operaatiot MySQL-kutsuilla.
 * Funktiot palauttavat samat tietorakenteet kuin vanhat JSON-funktiot.
 */

// ==================== YHTEYS ====================

function getDb(): PDO {
    static $pdo = null;
    if ($pdo === null) {
        $configFile = __DIR__ . '/db_config.php';
        if (!file_exists($configFile)) {
            throw new RuntimeException('db_config.php puuttuu! Kopioi db_config.php.example ja täytä tiedot.');
        }
        $cfg = require $configFile;
        $dsn = "mysql:host={$cfg['host']};dbname={$cfg['dbname']};charset={$cfg['charset']}";
        $pdo = new PDO($dsn, $cfg['username'], $cfg['password'], [
            PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_EMULATE_PREPARES   => false,
        ]);
    }
    return $pdo;
}

// ==================== TAULUJEN LUONTI ====================

function initDatabase(): void {
    $db = getDb();

    // Jokainen CREATE TABLE omana exec()-kutsuna — MySQL/PDO ei tue useaa lausetta kerralla
    $tables = [
        "CREATE TABLE IF NOT EXISTS companies (
            id VARCHAR(50) PRIMARY KEY,
            nimi VARCHAR(255) NOT NULL,
            luotu DATETIME,
            aktiivinen BOOLEAN DEFAULT TRUE,
            primary_color VARCHAR(7) DEFAULT '#0f3460',
            subtitle VARCHAR(255) DEFAULT '',
            logo_file VARCHAR(255) DEFAULT '',
            api_key VARCHAR(64) DEFAULT '',
            cors_origins TEXT DEFAULT ''
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",

        "CREATE TABLE IF NOT EXISTS company_domains (
            id INT AUTO_INCREMENT PRIMARY KEY,
            company_id VARCHAR(50) NOT NULL,
            domain VARCHAR(255) NOT NULL,
            FOREIGN KEY (company_id) REFERENCES companies(id) ON DELETE CASCADE,
            UNIQUE KEY udx_domain (domain)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",

        "CREATE TABLE IF NOT EXISTS users (
            id VARCHAR(20) PRIMARY KEY,
            username VARCHAR(100) NOT NULL UNIQUE,
            password_hash VARCHAR(255) NOT NULL,
            nimi VARCHAR(255) NOT NULL,
            role ENUM('admin','user') DEFAULT 'user',
            email VARCHAR(255) DEFAULT '',
            luotu DATETIME
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",

        "CREATE TABLE IF NOT EXISTS user_companies (
            user_id VARCHAR(20) NOT NULL,
            company_id VARCHAR(50) NOT NULL,
            PRIMARY KEY (user_id, company_id),
            FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
            FOREIGN KEY (company_id) REFERENCES companies(id) ON DELETE CASCADE
        ) ENGINE=InnoDB",

        "CREATE TABLE IF NOT EXISTS user_signatures (
            id INT AUTO_INCREMENT PRIMARY KEY,
            user_id VARCHAR(20) NOT NULL,
            mailbox_id VARCHAR(20) NOT NULL,
            signature TEXT,
            FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
            UNIQUE KEY udx_user_mailbox (user_id, mailbox_id)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",

        "CREATE TABLE IF NOT EXISTS config (
            config_key VARCHAR(100) PRIMARY KEY,
            config_value TEXT
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",

        "CREATE TABLE IF NOT EXISTS reset_tokens (
            id INT AUTO_INCREMENT PRIMARY KEY,
            user_id VARCHAR(20) NOT NULL,
            token VARCHAR(64) NOT NULL UNIQUE,
            created_at DATETIME NOT NULL,
            FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
        ) ENGINE=InnoDB",

        "CREATE TABLE IF NOT EXISTS login_attempts (
            id INT AUTO_INCREMENT PRIMARY KEY,
            ip VARCHAR(45) NOT NULL,
            attempted_at DATETIME NOT NULL,
            INDEX idx_ip_time (ip, attempted_at)
        ) ENGINE=InnoDB",

        "CREATE TABLE IF NOT EXISTS customers (
            id VARCHAR(20) PRIMARY KEY,
            company_id VARCHAR(50) NOT NULL,
            yritys VARCHAR(255),
            yhteyshenkilö VARCHAR(255),
            puhelin VARCHAR(100),
            sahkoposti VARCHAR(255),
            laskutusosoite TEXT,
            laskutuspostinumero VARCHAR(20),
            laskutuskaupunki VARCHAR(100),
            laskutussahkoposti VARCHAR(255),
            elaskuosoite VARCHAR(100),
            elaskuvalittaja VARCHAR(100),
            ytunnus VARCHAR(20),
            lisatiedot TEXT,
            luotu DATETIME,
            muokattu DATETIME NULL,
            muokkaaja VARCHAR(100) DEFAULT '',
            FOREIGN KEY (company_id) REFERENCES companies(id) ON DELETE CASCADE,
            INDEX idx_company (company_id)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",

        "CREATE TABLE IF NOT EXISTS customer_connections (
            id INT AUTO_INCREMENT PRIMARY KEY,
            customer_id VARCHAR(20) NOT NULL,
            asennusosoite VARCHAR(255) DEFAULT '',
            postinumero VARCHAR(20) DEFAULT '',
            kaupunki VARCHAR(100) DEFAULT '',
            liittymanopeus VARCHAR(50) DEFAULT '',
            hinta DECIMAL(10,2) DEFAULT 0,
            sopimuskausi VARCHAR(100) DEFAULT '',
            alkupvm VARCHAR(20) DEFAULT '',
            FOREIGN KEY (customer_id) REFERENCES customers(id) ON DELETE CASCADE
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",

        "CREATE TABLE IF NOT EXISTS leads (
            id VARCHAR(20) PRIMARY KEY,
            company_id VARCHAR(50) NOT NULL,
            yritys VARCHAR(255),
            yhteyshenkilo VARCHAR(255),
            puhelin VARCHAR(100),
            sahkoposti VARCHAR(255),
            osoite TEXT,
            kaupunki VARCHAR(100),
            tila VARCHAR(50) DEFAULT 'uusi',
            muistiinpanot TEXT,
            luotu DATETIME,
            luoja VARCHAR(100),
            muokattu DATETIME NULL,
            muokkaaja VARCHAR(100) DEFAULT '',
            FOREIGN KEY (company_id) REFERENCES companies(id) ON DELETE CASCADE,
            INDEX idx_company (company_id)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",

        "CREATE TABLE IF NOT EXISTS tickets (
            id VARCHAR(20) PRIMARY KEY,
            company_id VARCHAR(50) NOT NULL,
            subject VARCHAR(500),
            from_email VARCHAR(255),
            from_name VARCHAR(255),
            status VARCHAR(20) DEFAULT 'uusi',
            type VARCHAR(20) DEFAULT 'muu',
            assigned_to VARCHAR(100) DEFAULT '',
            customer_id VARCHAR(20) DEFAULT '',
            customer_name VARCHAR(255) DEFAULT '',
            message_id VARCHAR(500) DEFAULT '',
            mailbox_id VARCHAR(20) DEFAULT '',
            auto_close_at VARCHAR(30) DEFAULT '',
            created DATETIME,
            updated DATETIME,
            FOREIGN KEY (company_id) REFERENCES companies(id) ON DELETE CASCADE,
            INDEX idx_company (company_id),
            INDEX idx_status (status),
            INDEX idx_message_id (message_id(255))
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",

        "CREATE TABLE IF NOT EXISTS ticket_messages (
            id VARCHAR(20) PRIMARY KEY,
            ticket_id VARCHAR(20) NOT NULL,
            type VARCHAR(20) NOT NULL,
            from_email VARCHAR(255) DEFAULT '',
            from_name VARCHAR(255) DEFAULT '',
            body LONGTEXT,
            timestamp DATETIME,
            message_id VARCHAR(500) DEFAULT '',
            FOREIGN KEY (ticket_id) REFERENCES tickets(id) ON DELETE CASCADE,
            INDEX idx_ticket (ticket_id)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",

        "CREATE TABLE IF NOT EXISTS ticket_tags (
            ticket_id VARCHAR(20) NOT NULL,
            tag VARCHAR(100) NOT NULL,
            PRIMARY KEY (ticket_id, tag),
            FOREIGN KEY (ticket_id) REFERENCES tickets(id) ON DELETE CASCADE
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",

        "CREATE TABLE IF NOT EXISTS archives (
            id VARCHAR(20) PRIMARY KEY,
            company_id VARCHAR(50) NOT NULL,
            data JSON NOT NULL,
            archived_at DATETIME DEFAULT CURRENT_TIMESTAMP,
            FOREIGN KEY (company_id) REFERENCES companies(id) ON DELETE CASCADE,
            INDEX idx_company (company_id)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",

        "CREATE TABLE IF NOT EXISTS changelog (
            id VARCHAR(20) PRIMARY KEY,
            company_id VARCHAR(50) NOT NULL,
            timestamp DATETIME NOT NULL,
            user VARCHAR(100),
            action VARCHAR(100),
            customer_id VARCHAR(20) DEFAULT '',
            customer_name VARCHAR(255) DEFAULT '',
            details TEXT,
            FOREIGN KEY (company_id) REFERENCES companies(id) ON DELETE CASCADE,
            INDEX idx_company_time (company_id, timestamp)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",

        "CREATE TABLE IF NOT EXISTS mailboxes (
            id VARCHAR(20) PRIMARY KEY,
            company_id VARCHAR(50) NOT NULL,
            nimi VARCHAR(255),
            imap_host VARCHAR(255),
            imap_port INT DEFAULT 993,
            imap_user VARCHAR(255),
            imap_encryption VARCHAR(10) DEFAULT 'ssl',
            imap_password VARCHAR(255),
            smtp_from_email VARCHAR(255),
            smtp_from_name VARCHAR(255),
            aktiivinen BOOLEAN DEFAULT TRUE,
            FOREIGN KEY (company_id) REFERENCES companies(id) ON DELETE CASCADE,
            INDEX idx_company (company_id)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",

        "CREATE TABLE IF NOT EXISTS ticket_rules (
            id VARCHAR(20) PRIMARY KEY,
            company_id VARCHAR(50) NOT NULL,
            name VARCHAR(255),
            from_contains VARCHAR(255),
            priority INT DEFAULT 0,
            tag VARCHAR(100) DEFAULT '',
            assign_to VARCHAR(100) DEFAULT '',
            status_set VARCHAR(20) DEFAULT '',
            type_set VARCHAR(20) DEFAULT '',
            auto_close_days INT DEFAULT 0,
            FOREIGN KEY (company_id) REFERENCES companies(id) ON DELETE CASCADE,
            INDEX idx_company (company_id)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",

        "CREATE TABLE IF NOT EXISTS files (
            id INT AUTO_INCREMENT PRIMARY KEY,
            company_id VARCHAR(50) NOT NULL,
            customer_id VARCHAR(20) NOT NULL,
            filename VARCHAR(255) NOT NULL,
            original_name VARCHAR(255),
            size INT DEFAULT 0,
            uploaded_at DATETIME,
            uploaded_by VARCHAR(100),
            FOREIGN KEY (company_id) REFERENCES companies(id) ON DELETE CASCADE,
            INDEX idx_company_customer (company_id, customer_id)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",
    ];

    foreach ($tables as $i => $sql) {
        try {
            $db->exec($sql);
        } catch (PDOException $e) {
            throw new RuntimeException("Taulun luonti epäonnistui (taulu #" . ($i+1) . "): " . $e->getMessage());
        }
    }
}

// ==================== YRITYKSET ====================

function dbLoadCompanies(): array {
    $db = getDb();
    $companies = $db->query("SELECT * FROM companies ORDER BY nimi")->fetchAll();

    // Liitä domainit
    foreach ($companies as &$c) {
        $stmt = $db->prepare("SELECT domain FROM company_domains WHERE company_id = ?");
        $stmt->execute([$c['id']]);
        $c['domains'] = $stmt->fetchAll(PDO::FETCH_COLUMN);
        $c['aktiivinen'] = (bool)$c['aktiivinen'];
    }
    return $companies;
}

function dbSaveCompany(array $company): void {
    $db = getDb();
    $db->beginTransaction();
    try {
        $stmt = $db->prepare("
            INSERT INTO companies (id, nimi, luotu, aktiivinen, primary_color, subtitle, logo_file, api_key, cors_origins)
            VALUES (:id, :nimi, :luotu, :aktiivinen, :primary_color, :subtitle, :logo_file, :api_key, :cors_origins)
            ON DUPLICATE KEY UPDATE
                nimi = VALUES(nimi), aktiivinen = VALUES(aktiivinen),
                primary_color = VALUES(primary_color), subtitle = VALUES(subtitle),
                logo_file = VALUES(logo_file), api_key = VALUES(api_key), cors_origins = VALUES(cors_origins)
        ");
        $stmt->execute([
            'id'            => $company['id'],
            'nimi'          => $company['nimi'],
            'luotu'         => $company['luotu'] ?? date('Y-m-d H:i:s'),
            'aktiivinen'    => $company['aktiivinen'] ?? true,
            'primary_color' => $company['primary_color'] ?? '#0f3460',
            'subtitle'      => $company['subtitle'] ?? '',
            'logo_file'     => $company['logo_file'] ?? '',
            'api_key'       => $company['api_key'] ?? '',
            'cors_origins'  => $company['cors_origins'] ?? '',
        ]);

        // Päivitä domainit
        $db->prepare("DELETE FROM company_domains WHERE company_id = ?")->execute([$company['id']]);
        if (!empty($company['domains'])) {
            $ins = $db->prepare("INSERT INTO company_domains (company_id, domain) VALUES (?, ?)");
            foreach ($company['domains'] as $domain) {
                $domain = trim($domain);
                if ($domain) $ins->execute([$company['id'], $domain]);
            }
        }
        $db->commit();
    } catch (Exception $e) {
        $db->rollBack();
        throw $e;
    }
}

function dbDeleteCompany(string $companyId): void {
    $db = getDb();
    $db->prepare("DELETE FROM companies WHERE id = ?")->execute([$companyId]);
}

function dbGetBranding(string $host): array {
    $db = getDb();
    $host = strtolower(trim($host));

    $stmt = $db->prepare("
        SELECT c.* FROM companies c
        JOIN company_domains cd ON c.id = cd.company_id
        WHERE LOWER(cd.domain) = ?
        LIMIT 1
    ");
    $stmt->execute([$host]);
    $company = $stmt->fetch();

    if ($company) {
        $logoUrl = !empty($company['logo_file'])
            ? "api.php?action=company_logo&company_id=" . urlencode($company['id'])
            : '';
        return [
            'found'         => true,
            'company_id'    => $company['id'],
            'nimi'          => $company['nimi'],
            'primary_color' => $company['primary_color'] ?? '#0f3460',
            'subtitle'      => $company['subtitle'] ?? '',
            'logo_url'      => $logoUrl,
        ];
    }

    return [
        'found'         => false,
        'company_id'    => '',
        'nimi'          => 'Noxus Intra',
        'primary_color' => '#0f3460',
        'subtitle'      => 'Hallintapaneeli',
        'logo_url'      => '',
    ];
}

function dbGetCompanyByDomain(string $host): ?array {
    $db = getDb();
    $stmt = $db->prepare("
        SELECT c.* FROM companies c
        JOIN company_domains cd ON c.id = cd.company_id
        WHERE LOWER(cd.domain) = ?
        LIMIT 1
    ");
    $stmt->execute([strtolower(trim($host))]);
    return $stmt->fetch() ?: null;
}

function dbGetCompanyByApiKey(string $apiKey): ?array {
    $db = getDb();
    $stmt = $db->prepare("SELECT * FROM companies WHERE api_key = ? AND api_key != '' LIMIT 1");
    $stmt->execute([$apiKey]);
    return $stmt->fetch() ?: null;
}

// ==================== KÄYTTÄJÄT ====================

function dbLoadUsers(): array {
    $db = getDb();
    $users = $db->query("SELECT * FROM users ORDER BY luotu")->fetchAll();

    foreach ($users as &$u) {
        // Yritykset
        $stmt = $db->prepare("SELECT company_id FROM user_companies WHERE user_id = ?");
        $stmt->execute([$u['id']]);
        $u['companies'] = $stmt->fetchAll(PDO::FETCH_COLUMN);

        // Allekirjoitukset
        $stmt = $db->prepare("SELECT mailbox_id, signature FROM user_signatures WHERE user_id = ?");
        $stmt->execute([$u['id']]);
        $sigs = [];
        foreach ($stmt->fetchAll() as $row) {
            $sigs[$row['mailbox_id']] = $row['signature'];
        }
        $u['signatures'] = $sigs;
    }
    return $users;
}

function dbGetUser(string $id): ?array {
    $db = getDb();
    $stmt = $db->prepare("SELECT * FROM users WHERE id = ?");
    $stmt->execute([$id]);
    $u = $stmt->fetch();
    if (!$u) return null;

    $stmt = $db->prepare("SELECT company_id FROM user_companies WHERE user_id = ?");
    $stmt->execute([$id]);
    $u['companies'] = $stmt->fetchAll(PDO::FETCH_COLUMN);

    $stmt = $db->prepare("SELECT mailbox_id, signature FROM user_signatures WHERE user_id = ?");
    $stmt->execute([$id]);
    $sigs = [];
    foreach ($stmt->fetchAll() as $row) {
        $sigs[$row['mailbox_id']] = $row['signature'];
    }
    $u['signatures'] = $sigs;

    return $u;
}

function dbGetUserByUsername(string $username): ?array {
    $db = getDb();
    $stmt = $db->prepare("SELECT * FROM users WHERE username = ?");
    $stmt->execute([$username]);
    $u = $stmt->fetch();
    if (!$u) return null;

    $stmt = $db->prepare("SELECT company_id FROM user_companies WHERE user_id = ?");
    $stmt->execute([$u['id']]);
    $u['companies'] = $stmt->fetchAll(PDO::FETCH_COLUMN);

    $stmt = $db->prepare("SELECT mailbox_id, signature FROM user_signatures WHERE user_id = ?");
    $stmt->execute([$u['id']]);
    $sigs = [];
    foreach ($stmt->fetchAll() as $row) {
        $sigs[$row['mailbox_id']] = $row['signature'];
    }
    $u['signatures'] = $sigs;

    return $u;
}

function dbSaveUser(array $user): void {
    $db = getDb();
    $db->beginTransaction();
    try {
        $stmt = $db->prepare("
            INSERT INTO users (id, username, password_hash, nimi, role, email, luotu)
            VALUES (:id, :username, :password_hash, :nimi, :role, :email, :luotu)
            ON DUPLICATE KEY UPDATE
                username = VALUES(username), password_hash = VALUES(password_hash),
                nimi = VALUES(nimi), role = VALUES(role), email = VALUES(email)
        ");
        $stmt->execute([
            'id'            => $user['id'],
            'username'      => $user['username'],
            'password_hash' => $user['password_hash'],
            'nimi'          => $user['nimi'],
            'role'          => $user['role'] ?? 'user',
            'email'         => $user['email'] ?? '',
            'luotu'         => $user['luotu'] ?? date('Y-m-d H:i:s'),
        ]);

        // Yritykset
        $db->prepare("DELETE FROM user_companies WHERE user_id = ?")->execute([$user['id']]);
        if (!empty($user['companies'])) {
            $ins = $db->prepare("INSERT IGNORE INTO user_companies (user_id, company_id) VALUES (?, ?)");
            foreach ($user['companies'] as $cid) {
                $ins->execute([$user['id'], $cid]);
            }
        }

        // Allekirjoitukset
        $db->prepare("DELETE FROM user_signatures WHERE user_id = ?")->execute([$user['id']]);
        if (!empty($user['signatures'])) {
            $ins = $db->prepare("INSERT INTO user_signatures (user_id, mailbox_id, signature) VALUES (?, ?, ?)");
            foreach ($user['signatures'] as $mbId => $sig) {
                $ins->execute([$user['id'], $mbId, $sig]);
            }
        }

        $db->commit();
    } catch (Exception $e) {
        $db->rollBack();
        throw $e;
    }
}

function dbDeleteUser(string $userId): void {
    $db = getDb();
    $db->prepare("DELETE FROM users WHERE id = ?")->execute([$userId]);
}

// ==================== ASETUKSET (global) ====================

function dbLoadConfig(): array {
    $db = getDb();
    $rows = $db->query("SELECT config_key, config_value FROM config")->fetchAll();
    $config = [];
    foreach ($rows as $row) {
        $decoded = json_decode($row['config_value'], true);
        $config[$row['config_key']] = $decoded !== null ? $decoded : $row['config_value'];
    }
    return $config;
}

function dbSaveConfig(array $config): void {
    $db = getDb();
    $stmt = $db->prepare("
        INSERT INTO config (config_key, config_value) VALUES (?, ?)
        ON DUPLICATE KEY UPDATE config_value = VALUES(config_value)
    ");
    foreach ($config as $key => $value) {
        $stmt->execute([$key, is_array($value) ? json_encode($value) : $value]);
    }
}

// ==================== SALASANAN PALAUTUS ====================

function dbSaveToken(string $userId, string $token): void {
    $db = getDb();
    $stmt = $db->prepare("INSERT INTO reset_tokens (user_id, token, created_at) VALUES (?, ?, NOW())");
    $stmt->execute([$userId, hash('sha256', $token)]);
}

function dbValidateToken(string $token): ?string {
    $db = getDb();
    $hash = hash('sha256', $token);
    $stmt = $db->prepare("SELECT user_id FROM reset_tokens WHERE token = ? AND created_at > DATE_SUB(NOW(), INTERVAL 1 HOUR)");
    $stmt->execute([$hash]);
    $row = $stmt->fetch();
    return $row ? $row['user_id'] : null;
}

function dbRemoveToken(string $token): void {
    $db = getDb();
    $db->prepare("DELETE FROM reset_tokens WHERE token = ?")->execute([hash('sha256', $token)]);
    // Siivoa vanhentuneet
    $db->exec("DELETE FROM reset_tokens WHERE created_at < DATE_SUB(NOW(), INTERVAL 1 HOUR)");
}

// ==================== RATE LIMITING ====================

function dbCheckRateLimit(string $ip): bool {
    $db = getDb();
    $stmt = $db->prepare("SELECT COUNT(*) FROM login_attempts WHERE ip = ? AND attempted_at > DATE_SUB(NOW(), INTERVAL 15 MINUTE)");
    $stmt->execute([$ip]);
    return $stmt->fetchColumn() < 10;
}

function dbRecordLoginAttempt(string $ip): void {
    $db = getDb();
    $db->prepare("INSERT INTO login_attempts (ip, attempted_at) VALUES (?, NOW())")->execute([$ip]);
    // Siivoa vanhat (yli 1h)
    $db->exec("DELETE FROM login_attempts WHERE attempted_at < DATE_SUB(NOW(), INTERVAL 1 HOUR)");
}

// ==================== ASIAKKAAT ====================

function dbLoadCustomers(string $companyId): array {
    $db = getDb();
    $stmt = $db->prepare("SELECT * FROM customers WHERE company_id = ? ORDER BY yritys");
    $stmt->execute([$companyId]);
    $customers = $stmt->fetchAll();

    // Liitä liittymät
    $connStmt = $db->prepare("SELECT * FROM customer_connections WHERE customer_id = ?");
    foreach ($customers as &$c) {
        $connStmt->execute([$c['id']]);
        $conns = $connStmt->fetchAll();
        $c['liittymat'] = array_map(function($conn) {
            return [
                'asennusosoite'  => $conn['asennusosoite'] ?? '',
                'postinumero'    => $conn['postinumero'] ?? '',
                'kaupunki'       => $conn['kaupunki'] ?? '',
                'liittymanopeus' => $conn['liittymanopeus'] ?? '',
                'hinta'          => (float)($conn['hinta'] ?? 0),
                'sopimuskausi'   => $conn['sopimuskausi'] ?? '',
                'alkupvm'        => $conn['alkupvm'] ?? '',
            ];
        }, $conns);
        // Poista company_id vastauksesta (ei tarvita frontissa)
        unset($c['company_id']);
    }
    return $customers;
}

function dbSaveCustomer(string $companyId, array $customer): void {
    $db = getDb();
    $db->beginTransaction();
    try {
        $stmt = $db->prepare("
            INSERT INTO customers (id, company_id, yritys, yhteyshenkilö, puhelin, sahkoposti,
                laskutusosoite, laskutuspostinumero, laskutuskaupunki, laskutussahkoposti,
                elaskuosoite, elaskuvalittaja, ytunnus, lisatiedot, luotu, muokattu, muokkaaja)
            VALUES (:id, :company_id, :yritys, :yhteyshenkilö, :puhelin, :sahkoposti,
                :laskutusosoite, :laskutuspostinumero, :laskutuskaupunki, :laskutussahkoposti,
                :elaskuosoite, :elaskuvalittaja, :ytunnus, :lisatiedot, :luotu, :muokattu, :muokkaaja)
            ON DUPLICATE KEY UPDATE
                yritys = VALUES(yritys), yhteyshenkilö = VALUES(yhteyshenkilö),
                puhelin = VALUES(puhelin), sahkoposti = VALUES(sahkoposti),
                laskutusosoite = VALUES(laskutusosoite), laskutuspostinumero = VALUES(laskutuspostinumero),
                laskutuskaupunki = VALUES(laskutuskaupunki), laskutussahkoposti = VALUES(laskutussahkoposti),
                elaskuosoite = VALUES(elaskuosoite), elaskuvalittaja = VALUES(elaskuvalittaja),
                ytunnus = VALUES(ytunnus), lisatiedot = VALUES(lisatiedot),
                muokattu = VALUES(muokattu), muokkaaja = VALUES(muokkaaja)
        ");
        $stmt->execute([
            'id'                    => $customer['id'],
            'company_id'            => $companyId,
            'yritys'                => $customer['yritys'] ?? '',
            'yhteyshenkilö'         => $customer['yhteyshenkilö'] ?? '',
            'puhelin'               => $customer['puhelin'] ?? '',
            'sahkoposti'            => $customer['sahkoposti'] ?? '',
            'laskutusosoite'        => $customer['laskutusosoite'] ?? '',
            'laskutuspostinumero'   => $customer['laskutuspostinumero'] ?? '',
            'laskutuskaupunki'      => $customer['laskutuskaupunki'] ?? '',
            'laskutussahkoposti'    => $customer['laskutussahkoposti'] ?? '',
            'elaskuosoite'          => $customer['elaskuosoite'] ?? '',
            'elaskuvalittaja'       => $customer['elaskuvalittaja'] ?? '',
            'ytunnus'               => $customer['ytunnus'] ?? '',
            'lisatiedot'            => $customer['lisatiedot'] ?? '',
            'luotu'                 => $customer['luotu'] ?? date('Y-m-d H:i:s'),
            'muokattu'              => $customer['muokattu'] ?? null,
            'muokkaaja'             => $customer['muokkaaja'] ?? '',
        ]);

        // Päivitä liittymät
        $db->prepare("DELETE FROM customer_connections WHERE customer_id = ?")->execute([$customer['id']]);
        if (!empty($customer['liittymat'])) {
            $ins = $db->prepare("
                INSERT INTO customer_connections (customer_id, asennusosoite, postinumero, kaupunki, liittymanopeus, hinta, sopimuskausi, alkupvm)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
            ");
            foreach ($customer['liittymat'] as $l) {
                $ins->execute([
                    $customer['id'],
                    $l['asennusosoite'] ?? '',
                    $l['postinumero'] ?? '',
                    $l['kaupunki'] ?? '',
                    $l['liittymanopeus'] ?? '',
                    $l['hinta'] ?? 0,
                    $l['sopimuskausi'] ?? '',
                    $l['alkupvm'] ?? '',
                ]);
            }
        }
        $db->commit();
    } catch (Exception $e) {
        $db->rollBack();
        throw $e;
    }
}

function dbDeleteCustomer(string $customerId): void {
    $db = getDb();
    $db->prepare("DELETE FROM customers WHERE id = ?")->execute([$customerId]);
}

// ==================== LIIDIT ====================

function dbLoadLeads(string $companyId): array {
    $db = getDb();
    $stmt = $db->prepare("SELECT * FROM leads WHERE company_id = ? ORDER BY luotu DESC");
    $stmt->execute([$companyId]);
    $leads = $stmt->fetchAll();
    foreach ($leads as &$l) {
        unset($l['company_id']);
    }
    return $leads;
}

function dbSaveLead(string $companyId, array $lead): void {
    $db = getDb();
    $stmt = $db->prepare("
        INSERT INTO leads (id, company_id, yritys, yhteyshenkilo, puhelin, sahkoposti, osoite, kaupunki, tila, muistiinpanot, luotu, luoja, muokattu, muokkaaja)
        VALUES (:id, :company_id, :yritys, :yhteyshenkilo, :puhelin, :sahkoposti, :osoite, :kaupunki, :tila, :muistiinpanot, :luotu, :luoja, :muokattu, :muokkaaja)
        ON DUPLICATE KEY UPDATE
            yritys = VALUES(yritys), yhteyshenkilo = VALUES(yhteyshenkilo),
            puhelin = VALUES(puhelin), sahkoposti = VALUES(sahkoposti),
            osoite = VALUES(osoite), kaupunki = VALUES(kaupunki),
            tila = VALUES(tila), muistiinpanot = VALUES(muistiinpanot),
            muokattu = VALUES(muokattu), muokkaaja = VALUES(muokkaaja)
    ");
    $stmt->execute([
        'id'             => $lead['id'],
        'company_id'     => $companyId,
        'yritys'         => $lead['yritys'] ?? '',
        'yhteyshenkilo'  => $lead['yhteyshenkilo'] ?? '',
        'puhelin'        => $lead['puhelin'] ?? '',
        'sahkoposti'     => $lead['sahkoposti'] ?? '',
        'osoite'         => $lead['osoite'] ?? '',
        'kaupunki'       => $lead['kaupunki'] ?? '',
        'tila'           => $lead['tila'] ?? 'uusi',
        'muistiinpanot'  => $lead['muistiinpanot'] ?? '',
        'luotu'          => $lead['luotu'] ?? date('Y-m-d H:i:s'),
        'luoja'          => $lead['luoja'] ?? '',
        'muokattu'       => $lead['muokattu'] ?? null,
        'muokkaaja'      => $lead['muokkaaja'] ?? '',
    ]);
}

function dbDeleteLead(string $leadId): void {
    $db = getDb();
    $db->prepare("DELETE FROM leads WHERE id = ?")->execute([$leadId]);
}

// ==================== TIKETIT ====================

function dbLoadTickets(string $companyId): array {
    $db = getDb();
    $stmt = $db->prepare("SELECT * FROM tickets WHERE company_id = ? ORDER BY updated DESC");
    $stmt->execute([$companyId]);
    $tickets = $stmt->fetchAll();

    $msgStmt = $db->prepare("SELECT * FROM ticket_messages WHERE ticket_id = ? ORDER BY timestamp");
    $tagStmt = $db->prepare("SELECT tag FROM ticket_tags WHERE ticket_id = ?");

    foreach ($tickets as &$t) {
        // Viestit
        $msgStmt->execute([$t['id']]);
        $t['messages'] = array_map(function($m) {
            return [
                'id'         => $m['id'],
                'type'       => $m['type'],
                'from'       => $m['from_email'],
                'from_name'  => $m['from_name'],
                'body'       => $m['body'],
                'timestamp'  => $m['timestamp'],
                'message_id' => $m['message_id'] ?? '',
            ];
        }, $msgStmt->fetchAll());

        // Tagit
        $tagStmt->execute([$t['id']]);
        $t['tags'] = $tagStmt->fetchAll(PDO::FETCH_COLUMN);

        unset($t['company_id']);
    }
    return $tickets;
}

function dbSaveTicket(string $companyId, array $ticket): void {
    $db = getDb();
    $db->beginTransaction();
    try {
        $stmt = $db->prepare("
            INSERT INTO tickets (id, company_id, subject, from_email, from_name, status, type,
                assigned_to, customer_id, customer_name, message_id, mailbox_id, auto_close_at, created, updated)
            VALUES (:id, :company_id, :subject, :from_email, :from_name, :status, :type,
                :assigned_to, :customer_id, :customer_name, :message_id, :mailbox_id, :auto_close_at, :created, :updated)
            ON DUPLICATE KEY UPDATE
                subject = VALUES(subject), from_email = VALUES(from_email), from_name = VALUES(from_name),
                status = VALUES(status), type = VALUES(type), assigned_to = VALUES(assigned_to),
                customer_id = VALUES(customer_id), customer_name = VALUES(customer_name),
                message_id = VALUES(message_id), mailbox_id = VALUES(mailbox_id),
                auto_close_at = VALUES(auto_close_at), updated = VALUES(updated)
        ");
        $stmt->execute([
            'id'             => $ticket['id'],
            'company_id'     => $companyId,
            'subject'        => $ticket['subject'] ?? '',
            'from_email'     => $ticket['from_email'] ?? '',
            'from_name'      => $ticket['from_name'] ?? '',
            'status'         => $ticket['status'] ?? 'uusi',
            'type'           => $ticket['type'] ?? 'muu',
            'assigned_to'    => $ticket['assigned_to'] ?? '',
            'customer_id'    => $ticket['customer_id'] ?? '',
            'customer_name'  => $ticket['customer_name'] ?? '',
            'message_id'     => $ticket['message_id'] ?? '',
            'mailbox_id'     => $ticket['mailbox_id'] ?? '',
            'auto_close_at'  => $ticket['auto_close_at'] ?? '',
            'created'        => $ticket['created'] ?? date('Y-m-d H:i:s'),
            'updated'        => $ticket['updated'] ?? date('Y-m-d H:i:s'),
        ]);

        // Viestit — lisää vain uudet (ei poista vanhoja)
        if (!empty($ticket['messages'])) {
            $ins = $db->prepare("
                INSERT IGNORE INTO ticket_messages (id, ticket_id, type, from_email, from_name, body, timestamp, message_id)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
            ");
            foreach ($ticket['messages'] as $m) {
                $ins->execute([
                    $m['id'],
                    $ticket['id'],
                    $m['type'],
                    $m['from'] ?? $m['from_email'] ?? '',
                    $m['from_name'] ?? '',
                    $m['body'] ?? '',
                    $m['timestamp'] ?? date('Y-m-d H:i:s'),
                    $m['message_id'] ?? '',
                ]);
            }
        }

        // Tagit — korvaa kaikki
        $db->prepare("DELETE FROM ticket_tags WHERE ticket_id = ?")->execute([$ticket['id']]);
        if (!empty($ticket['tags'])) {
            $ins = $db->prepare("INSERT INTO ticket_tags (ticket_id, tag) VALUES (?, ?)");
            foreach ($ticket['tags'] as $tag) {
                if ($tag) $ins->execute([$ticket['id'], $tag]);
            }
        }

        $db->commit();
    } catch (Exception $e) {
        $db->rollBack();
        throw $e;
    }
}

function dbDeleteTicket(string $ticketId): void {
    $db = getDb();
    $db->prepare("DELETE FROM tickets WHERE id = ?")->execute([$ticketId]);
}

function dbFindTicketByMessageId(string $companyId, string $messageId): ?array {
    $db = getDb();
    // Ensin tikettitasolla
    $stmt = $db->prepare("SELECT * FROM tickets WHERE company_id = ? AND message_id = ? LIMIT 1");
    $stmt->execute([$companyId, $messageId]);
    $t = $stmt->fetch();
    if ($t) return $t;

    // Sitten viestien message_id:stä
    $stmt = $db->prepare("
        SELECT t.* FROM tickets t
        JOIN ticket_messages tm ON t.id = tm.ticket_id
        WHERE t.company_id = ? AND tm.message_id = ?
        LIMIT 1
    ");
    $stmt->execute([$companyId, $messageId]);
    return $stmt->fetch() ?: null;
}

// ==================== ARKISTO ====================

function dbLoadArchive(string $companyId): array {
    $db = getDb();
    $stmt = $db->prepare("SELECT * FROM archives WHERE company_id = ? ORDER BY archived_at DESC");
    $stmt->execute([$companyId]);
    $rows = $stmt->fetchAll();
    return array_map(function($row) {
        $data = json_decode($row['data'], true) ?? [];
        $data['id'] = $row['id'];
        $data['archived_at'] = $row['archived_at'];
        return $data;
    }, $rows);
}

function dbArchiveCustomer(string $companyId, array $customerData): void {
    $db = getDb();
    $stmt = $db->prepare("INSERT INTO archives (id, company_id, data, archived_at) VALUES (?, ?, ?, NOW())");
    $stmt->execute([$customerData['id'], $companyId, json_encode($customerData, JSON_UNESCAPED_UNICODE)]);
}

function dbRestoreArchive(string $archiveId): ?array {
    $db = getDb();
    $stmt = $db->prepare("SELECT * FROM archives WHERE id = ?");
    $stmt->execute([$archiveId]);
    $row = $stmt->fetch();
    if (!$row) return null;
    $db->prepare("DELETE FROM archives WHERE id = ?")->execute([$archiveId]);
    return json_decode($row['data'], true);
}

function dbDeleteArchive(string $archiveId): void {
    $db = getDb();
    $db->prepare("DELETE FROM archives WHERE id = ?")->execute([$archiveId]);
}

// ==================== CHANGELOG ====================

function dbAddLog(string $companyId, string $user, string $action, string $customerId = '', string $customerName = '', string $details = ''): void {
    if (empty($companyId)) return;
    $db = getDb();

    $id = bin2hex(random_bytes(8));
    $stmt = $db->prepare("
        INSERT INTO changelog (id, company_id, timestamp, user, action, customer_id, customer_name, details)
        VALUES (?, ?, NOW(), ?, ?, ?, ?, ?)
    ");
    $stmt->execute([$id, $companyId, $user, $action, $customerId, $customerName, $details]);

    // Pidä max 500 per yritys
    $db->prepare("
        DELETE FROM changelog WHERE company_id = ? AND id NOT IN (
            SELECT id FROM (SELECT id FROM changelog WHERE company_id = ? ORDER BY timestamp DESC LIMIT 500) tmp
        )
    ")->execute([$companyId, $companyId]);
}

function dbLoadChangelog(string $companyId, int $limit = 100): array {
    $db = getDb();
    $stmt = $db->prepare("SELECT * FROM changelog WHERE company_id = ? ORDER BY timestamp DESC LIMIT ?");
    $stmt->execute([$companyId, $limit]);
    return $stmt->fetchAll();
}

// ==================== POSTILAATIKOT ====================

function dbLoadMailboxes(string $companyId): array {
    $db = getDb();
    $stmt = $db->prepare("SELECT * FROM mailboxes WHERE company_id = ?");
    $stmt->execute([$companyId]);
    $boxes = $stmt->fetchAll();
    foreach ($boxes as &$b) {
        $b['aktiivinen'] = (bool)$b['aktiivinen'];
        $b['imap_port'] = (int)$b['imap_port'];
        unset($b['company_id']);
    }
    return $boxes;
}

function dbSaveMailbox(string $companyId, array $mailbox): void {
    $db = getDb();
    $stmt = $db->prepare("
        INSERT INTO mailboxes (id, company_id, nimi, imap_host, imap_port, imap_user, imap_encryption, imap_password, smtp_from_email, smtp_from_name, aktiivinen)
        VALUES (:id, :company_id, :nimi, :imap_host, :imap_port, :imap_user, :imap_encryption, :imap_password, :smtp_from_email, :smtp_from_name, :aktiivinen)
        ON DUPLICATE KEY UPDATE
            nimi = VALUES(nimi), imap_host = VALUES(imap_host), imap_port = VALUES(imap_port),
            imap_user = VALUES(imap_user), imap_encryption = VALUES(imap_encryption),
            imap_password = VALUES(imap_password), smtp_from_email = VALUES(smtp_from_email),
            smtp_from_name = VALUES(smtp_from_name), aktiivinen = VALUES(aktiivinen)
    ");
    $stmt->execute([
        'id'              => $mailbox['id'],
        'company_id'      => $companyId,
        'nimi'            => $mailbox['nimi'] ?? '',
        'imap_host'       => $mailbox['imap_host'] ?? '',
        'imap_port'       => $mailbox['imap_port'] ?? 993,
        'imap_user'       => $mailbox['imap_user'] ?? '',
        'imap_encryption' => $mailbox['imap_encryption'] ?? 'ssl',
        'imap_password'   => $mailbox['imap_password'] ?? '',
        'smtp_from_email' => $mailbox['smtp_from_email'] ?? '',
        'smtp_from_name'  => $mailbox['smtp_from_name'] ?? '',
        'aktiivinen'      => $mailbox['aktiivinen'] ?? true,
    ]);
}

function dbDeleteMailbox(string $mailboxId): void {
    $db = getDb();
    $db->prepare("DELETE FROM mailboxes WHERE id = ?")->execute([$mailboxId]);
}

function dbGetMailbox(string $mailboxId): ?array {
    $db = getDb();
    $stmt = $db->prepare("SELECT * FROM mailboxes WHERE id = ?");
    $stmt->execute([$mailboxId]);
    $b = $stmt->fetch();
    if ($b) {
        $b['aktiivinen'] = (bool)$b['aktiivinen'];
        $b['imap_port'] = (int)$b['imap_port'];
    }
    return $b ?: null;
}

// ==================== TIKETTISÄÄNNÖT ====================

function dbLoadTicketRules(string $companyId): array {
    $db = getDb();
    $stmt = $db->prepare("SELECT * FROM ticket_rules WHERE company_id = ? ORDER BY priority");
    $stmt->execute([$companyId]);
    $rules = $stmt->fetchAll();
    foreach ($rules as &$r) {
        $r['priority'] = (int)$r['priority'];
        $r['auto_close_days'] = (int)$r['auto_close_days'];
        unset($r['company_id']);
    }
    return $rules;
}

function dbSaveTicketRule(string $companyId, array $rule): void {
    $db = getDb();
    $stmt = $db->prepare("
        INSERT INTO ticket_rules (id, company_id, name, from_contains, priority, tag, assign_to, status_set, type_set, auto_close_days)
        VALUES (:id, :company_id, :name, :from_contains, :priority, :tag, :assign_to, :status_set, :type_set, :auto_close_days)
        ON DUPLICATE KEY UPDATE
            name = VALUES(name), from_contains = VALUES(from_contains), priority = VALUES(priority),
            tag = VALUES(tag), assign_to = VALUES(assign_to), status_set = VALUES(status_set),
            type_set = VALUES(type_set), auto_close_days = VALUES(auto_close_days)
    ");
    $stmt->execute([
        'id'              => $rule['id'],
        'company_id'      => $companyId,
        'name'            => $rule['name'] ?? '',
        'from_contains'   => $rule['from_contains'] ?? '',
        'priority'        => $rule['priority'] ?? 0,
        'tag'             => $rule['tag'] ?? '',
        'assign_to'       => $rule['assign_to'] ?? '',
        'status_set'      => $rule['status_set'] ?? '',
        'type_set'        => $rule['type_set'] ?? '',
        'auto_close_days' => $rule['auto_close_days'] ?? 0,
    ]);
}

function dbDeleteTicketRule(string $ruleId): void {
    $db = getDb();
    $db->prepare("DELETE FROM ticket_rules WHERE id = ?")->execute([$ruleId]);
}

// ==================== YRITYKSEN API-ASETUKSET ====================

function dbGetCompanyConfig(string $companyId): array {
    return [
        'mailboxes'    => dbLoadMailboxes($companyId),
        'ticket_rules' => dbLoadTicketRules($companyId),
        'api_key'      => dbGetCompanyApiKey($companyId),
        'cors_origins' => dbGetCompanyCorsOrigins($companyId),
    ];
}

function dbGetCompanyApiKey(string $companyId): string {
    $db = getDb();
    $stmt = $db->prepare("SELECT api_key FROM companies WHERE id = ?");
    $stmt->execute([$companyId]);
    return $stmt->fetchColumn() ?: '';
}

function dbGetCompanyCorsOrigins(string $companyId): array {
    $db = getDb();
    $stmt = $db->prepare("SELECT cors_origins FROM companies WHERE id = ?");
    $stmt->execute([$companyId]);
    $val = $stmt->fetchColumn();
    if (!$val) return [];
    $decoded = json_decode($val, true);
    return is_array($decoded) ? $decoded : [];
}

function dbSetCompanyApiKey(string $companyId, string $apiKey): void {
    $db = getDb();
    $db->prepare("UPDATE companies SET api_key = ? WHERE id = ?")->execute([$apiKey, $companyId]);
}

function dbSetCompanyCorsOrigins(string $companyId, array $origins): void {
    $db = getDb();
    $db->prepare("UPDATE companies SET cors_origins = ? WHERE id = ?")->execute([json_encode($origins), $companyId]);
}