import assert from 'node:assert/strict';
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import test from 'node:test';
import bcrypt from 'bcryptjs';
import express from 'express';
import { initDb } from '../src/db.js';
import { createAdminRouter } from '../src/routes/admin.js';
import { createAuthRouter } from '../src/routes/auth.js';

test('삭제한 계정의 사용자명을 새 계정이 사용해도 기존 정보가 연결되지 않는다', () => {
    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'uniare-account-delete-'));
    const dbPath = path.join(tempDir, 'test.db');
    const db = initDb(dbPath);

    try {
        const oldUserId = Number(
            db.prepare(`
                INSERT INTO users (
                    email, username, password_hash, display_name, email_verified_at
                )
                VALUES (?, ?, ?, ?, datetime('now'))
            `).run('old@example.com', 'test', 'old-password-hash', 'test').lastInsertRowid,
        );

        db.prepare(`
            INSERT INTO decks (
                share_code, share_type, user_id, series, series_name, name, cards_json, is_public
            )
            VALUES ('OLDDECK1', 'user', ?, 'ua01', '테스트', '기존 덱', '[]', 1)
        `).run(oldUserId);
        db.prepare(`
            INSERT INTO deck_favorites (user_id, share_code)
            VALUES (?, 'OLDDECK1')
        `).run(oldUserId);
        db.prepare(`
            INSERT INTO auth_tokens (user_id, type, token_hash, expires_at)
            VALUES (?, 'verify_email', 'old-token', datetime('now', '+1 day'))
        `).run(oldUserId);
        db.prepare(`
            INSERT INTO email_send_logs (user_id, type, month_key, status)
            VALUES (?, 'verify_email', '2026-06', 'sent')
        `).run(oldUserId);

        db.prepare('DELETE FROM users WHERE id = ?').run(oldUserId);

        const newUserId = Number(
            db.prepare(`
                INSERT INTO users (
                    email, username, password_hash, display_name, email_verified_at
                )
                VALUES (?, ?, ?, ?, datetime('now'))
            `).run('new@example.com', 'test', 'new-password-hash', 'test').lastInsertRowid,
        );

        const oldDeck = db.prepare(`
            SELECT user_id AS userId FROM decks WHERE share_code = 'OLDDECK1'
        `).get();

        assert.ok(newUserId > oldUserId);
        assert.equal(oldDeck.userId, null);
        assert.equal(
            db.prepare('SELECT COUNT(*) AS count FROM deck_favorites WHERE user_id = ?').get(oldUserId).count,
            0,
        );
        assert.equal(
            db.prepare('SELECT COUNT(*) AS count FROM auth_tokens WHERE user_id = ?').get(oldUserId).count,
            0,
        );
        assert.equal(
            db.prepare('SELECT COUNT(*) AS count FROM email_send_logs WHERE user_id = ?').get(oldUserId).count,
            0,
        );
        assert.equal(
            db.prepare(`
                SELECT COUNT(*) AS count FROM decks
                WHERE share_code = 'OLDDECK1' AND user_id = ?
            `).get(newUserId).count,
            0,
        );
    } finally {
        db.close();
        fs.rmSync(tempDir, { recursive: true, force: true });
    }
});

test('관리자는 미인증 회원의 이메일 인증을 수동 승인할 수 있다', async () => {
    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'uniare-admin-verify-'));
    const dbPath = path.join(tempDir, 'test.db');
    const db = initDb(dbPath);
    process.env.JWT_SECRET = 'test-secret-for-admin-email-verification';

    const adminPassword = 'admin-password';
    db.prepare(`
        INSERT INTO users (
            email, username, password_hash, display_name, role, email_verified_at
        )
        VALUES (?, ?, ?, ?, 'admin', datetime('now'))
    `).run(
        'admin@example.com',
        'admin',
        bcrypt.hashSync(adminPassword, 4),
        'admin',
    );
    const targetUserId = Number(
        db.prepare(`
            INSERT INTO users (
                email, username, password_hash, display_name, email_verified_at
            )
            VALUES (?, ?, ?, ?, NULL)
        `).run(
            'pending@example.com',
            'pending',
            bcrypt.hashSync('pending-password', 4),
            'pending',
        ).lastInsertRowid,
    );
    db.prepare(`
        INSERT INTO auth_tokens (user_id, type, token_hash, expires_at)
        VALUES (?, 'verify_email', 'pending-token', datetime('now', '+1 day'))
    `).run(targetUserId);

    const app = express();
    app.use(express.json());
    app.use('/api/v1/auth', createAuthRouter(db));
    app.use('/api/v1/admin', createAdminRouter(db));
    const server = app.listen(0);

    try {
        await new Promise((resolve) => server.once('listening', resolve));
        const address = server.address();
        const baseUrl = `http://127.0.0.1:${address.port}/api/v1`;

        const loginResponse = await fetch(`${baseUrl}/auth/login`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                email: 'admin@example.com',
                password: adminPassword,
            }),
        });
        assert.equal(loginResponse.status, 200);
        const { token } = await loginResponse.json();

        const approveResponse = await fetch(
            `${baseUrl}/admin/users/${targetUserId}/verify-email`,
            {
                method: 'POST',
                headers: { Authorization: `Bearer ${token}` },
            },
        );
        assert.equal(approveResponse.status, 200);

        const target = db.prepare(`
            SELECT email_verified_at AS emailVerifiedAt
            FROM users WHERE id = ?
        `).get(targetUserId);
        const pendingToken = db.prepare(`
            SELECT used_at AS usedAt
            FROM auth_tokens WHERE user_id = ? AND type = 'verify_email'
        `).get(targetUserId);
        assert.ok(target.emailVerifiedAt);
        assert.ok(pendingToken.usedAt);
    } finally {
        await new Promise((resolve, reject) => {
            server.close((error) => (error ? reject(error) : resolve()));
        });
        db.close();
        fs.rmSync(tempDir, { recursive: true, force: true });
    }
});