import { afterEach, describe, expect, it, vi } from 'vitest';
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import { DatabaseSync } from 'node:sqlite';
import type { MessageElement } from '@snowluma/protocol/events';
import {
    convertEvent,
    elementsToOneBotSegments,
    type ConverterContext,
} from '../src/event-converter';
import { MediaIndexer } from '../src/media-indexer';
import { MediaStore, MEDIA_DATA_MAX_CHARS } from '../src/media-store';
import { migrateLegacyMedia } from '../src/media-store-migration';
import { MessageStore } from '../src/message-store';
import type { OneBotInstanceContext } from '../src/instance-context';
import { forwardSingleMessage, sendGroupForwardMessage } from '../src/modules/message-actions';

const directories: string[] = [];
afterEach(() => {
    for (const dir of directories.splice(0)) {
        fs.rmSync(dir, { recursive: true, force: true });
    }
});

function location() {
    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'historical-media-'));
    directories.push(directory);
    return {
        directory,
        dbPath: path.join(directory, 'messages.db'),
        legacyPath: path.join(directory, 'media.db'),
    };
}

const image = {
    file: 'same.png',
    fileName: 'same.png',
    url: '',
    imageUrl: '',
    fileSize: 120,
    md5Hex: 'aa'.repeat(16),
    sha1Hex: 'bb'.repeat(20),
    width: 32,
    height: 24,
    picFormat: 1001,
    subType: 0,
    summary: '',
    isGroup: true,
    sessionId: 123,
};

function converter(media: MediaStore): ConverterContext {
    const indexer = new MediaIndexer(media);
    return {
        selfId: 10001,
        imageUrlResolver: null,
        mediaUrlResolver: null,
        messageIdResolver: null,
        mediaSegmentSink: async (...args) => await indexer.remember(...args),
    };
}

function context(messages: MessageStore, media: MediaStore) {
    const sendGroup = vi.fn(async () => ({
        sequence: 234,
        clientSequence: 0,
        random: 1,
        timestamp: 1700000001,
    }));
    const upload = vi.fn(async (_nodes: unknown) => 'forward-id');
    const ref = {
        selfId: 10001,
        messageStore: messages,
        mediaStore: media,
        converterCtx: converter(media),
        cacheMessageMeta: vi.fn(),
        bridge: {
            identity: { nickname: 'self' },
            apis: { message: { sendGroup }, forward: { upload } },
        },
    } as unknown as OneBotInstanceContext;
    return { ref, sendGroup, upload };
}

describe('durable historical media', () => {
    it.each(['image', 'record', 'video'] as const)(
        'forwards %s after cache churn, alias replacement and reopen',
        async (type) => {
            const { dbPath } = location();
            let messages = new MessageStore(dbPath);
            await messages.initialization;
            let media = new MediaStore(dbPath, 2);
            await media.initialization;
            const element = {
                type,
                fileId: 'same.png',
                fileName: 'same.png',
                fileSize: 120,
                md5Hex: image.md5Hex,
                sha1Hex: image.sha1Hex,
                width: 32,
                height: 24,
                picFormat: 1001,
                duration: 3,
                voiceFormat: 1,
                videoFormat: 0,
            } as MessageElement;
            const event = await convertEvent(converter(media), {
                kind: 'group_message',
                groupName: '',
                time: 1700000000,
                selfUin: 10001,
                groupId: 123,
                senderUin: 456,
                senderNick: 'peer',
                senderCard: '',
                senderRole: 'member',
                msgSeq: 10,
                msgId: 10,
                elements: [element],
            });
            event!.message_id = 42;
            await messages.storeHistoryEvent(42, true, 123, 10, 'GroupMessage', event!);
            expect(JSON.stringify(event)).not.toContain('md5Hex');
            expect(JSON.stringify(await messages.findEvent(42))).not.toContain('sha1Hex');

            // Repeated names and many new resources must not change the old message.
            for (let i = 0; i < 80; i++) {
                await elementsToOneBotSegments(
                    converter(media),
                    [{ ...element, md5Hex: 'cc'.repeat(16) }],
                    true,
                    123,
                );
                await media.rememberImage({ ...image, file: `other-${i}`, fileName: `other-${i}` });
                await media.findImage(`other-${i}`);
            }

            await media.close();
            await messages.close();
            messages = new MessageStore(dbPath);
            await messages.initialization;
            media = new MediaStore(dbPath, 2);
            await media.initialization;

            try {
                const { ref, sendGroup, upload } = context(messages, media);
                await forwardSingleMessage(ref, 42, { groupId: 999 });
                expect(sendGroup).toHaveBeenCalledWith(999, [
                    expect.objectContaining({
                        type,
                        md5Hex: image.md5Hex,
                        sha1Hex: image.sha1Hex,
                        noByteFallback: true,
                    }),
                ]);
                await sendGroupForwardMessage(ref, 999, [{ type: 'node', data: { id: 42 } }]);
                expect(upload.mock.calls[0]?.[0]).toEqual([
                    expect.objectContaining({
                        elements: [
                            expect.objectContaining({
                                type,
                                md5Hex: image.md5Hex,
                                noByteFallback: true,
                            }),
                        ],
                    }),
                ]);
                expect((await messages.findEvent(42))?.message_id).toBe(42);
            } finally {
                await media.close();
                await messages.close();
            }
        },
    );

    it('stores the body and media snapshot atomically and strips inline bytes', async () => {
        const { dbPath } = location();
        const messages = new MessageStore(dbPath);
        await messages.initialization;
        const media = new MediaStore(dbPath);
        await media.initialization;
        const db = new DatabaseSync(dbPath);

        try {
            const segments = await elementsToOneBotSegments(
                converter(media),
                [
                    {
                        type: 'image',
                        ...image,
                        url: `base64://${'A'.repeat(100000)}`,
                        imageUrl: '',
                        fileId: 'same.png',
                    },
                ],
                true,
                123,
            );
            const event = { time: 1, message: segments };
            db.exec(
                "CREATE TRIGGER fail_media BEFORE INSERT ON messages WHEN NEW.media_data IS NOT NULL BEGIN SELECT RAISE(ABORT, 'test media write failure'); END",
            );
            await expect(
                async () => await messages.storeEvent(1, true, 123, 1, 'GroupMessage', event),
            ).rejects.toThrow('test media write failure');
            expect(await messages.findEvent(1)).toBeNull();
            db.exec('DROP TRIGGER fail_media');
            await messages.storeEvent(1, true, 123, 1, 'GroupMessage', event);
            expect((await messages.findMedia(1))?.[0].md5Hex).toBe(image.md5Hex);
            expect(JSON.stringify(await messages.findMedia(1))).not.toContain('base64://');
        } finally {
            db.close();
            await media.close();
            await messages.close();
        }
    });

    it('propagates media persistence failures instead of silently skipping segments', async () => {
        const { dbPath } = location();
        const media = new MediaStore(dbPath);
        await media.initialization;
        await media.close();
        await expect(
            elementsToOneBotSegments(
                converter(media),
                [{ type: 'image', fileId: 'test' }],
                true,
                123,
            ),
        ).rejects.toThrow();
    });

    it('does not substitute another same-named resource for an incomplete snapshot', async () => {
        const { dbPath } = location();
        const messages = new MessageStore(dbPath);
        await messages.initialization;
        const media = new MediaStore(dbPath);
        await media.initialization;

        try {
            const segments = await elementsToOneBotSegments(
                converter(media),
                [{ type: 'image', fileId: image.file }],
                true,
                123,
            );
            await messages.storeEvent(42, true, 123, 1, 'GroupMessage', { message: segments });
            await media.rememberImage(image);
            const { ref, sendGroup } = context(messages, media);
            await expect(forwardSingleMessage(ref, 42, { groupId: 999 })).rejects.toThrow(
                'metadata is incomplete',
            );
            expect(sendGroup).not.toHaveBeenCalled();
        } finally {
            await media.close();
            await messages.close();
        }
    });

    it('preserves complete metadata across an incomplete repeat and rejects conflicting resources', async () => {
        const { dbPath } = location();
        let messages = new MessageStore(dbPath);
        await messages.initialization;
        let media = new MediaStore(dbPath);
        await media.initialization;
        const complete: MessageElement = { type: 'image', ...image, fileId: image.file };

        const save = async (element: MessageElement) => {
            const segments = await elementsToOneBotSegments(converter(media), [element], true, 123);
            await messages.storeEvent(42, true, 123, 1, 'GroupMessage', { message: segments });
        };

        await save(complete);
        await save({
            type: 'image',
            fileId: image.file,
            md5Hex: image.md5Hex,
            width: 0,
            height: 0,
        });
        await expect(save({ ...complete, md5Hex: 'cc'.repeat(16) })).rejects.toThrow('conflicting');
        await media.close();
        await messages.close();
        messages = new MessageStore(dbPath);
        await messages.initialization;
        media = new MediaStore(dbPath);
        await media.initialization;

        try {
            const { ref, sendGroup } = context(messages, media);
            await forwardSingleMessage(ref, 42, { groupId: 999 });
            expect(sendGroup).toHaveBeenCalledWith(999, [
                expect.objectContaining({
                    md5Hex: image.md5Hex,
                    sha1Hex: image.sha1Hex,
                    width: image.width,
                    height: image.height,
                }),
            ]);
        } finally {
            await media.close();
            await messages.close();
        }
    });

    it('does not combine disjoint image fingerprints merely because fileId is the same filename', async () => {
        const { dbPath } = location();
        const messages = new MessageStore(dbPath);
        await messages.initialization;
        const media = new MediaStore(dbPath);
        await media.initialization;

        try {
            const original = await elementsToOneBotSegments(
                converter(media),
                [{ type: 'image', fileId: 'photo.jpg', md5Hex: image.md5Hex, width: 32 }],
                true,
                123,
            );
            await messages.storeEvent(42, true, 123, 1, 'GroupMessage', { message: original });
            const different = await elementsToOneBotSegments(
                converter(media),
                [{ type: 'image', fileId: 'photo.jpg', sha1Hex: image.sha1Hex, width: 64 }],
                true,
                123,
            );
            await expect(
                async () =>
                    await messages.storeEvent(42, true, 123, 1, 'GroupMessage', {
                        message: different,
                    }),
            ).rejects.toThrow('unverified media association');
            expect(await messages.findMedia(42)).toEqual([
                { type: 'image', fileId: 'photo.jpg', md5Hex: image.md5Hex, width: 32 },
            ]);
        } finally {
            await media.close();
            await messages.close();
        }
    });

    it('rejects corrupt and oversized metadata without deleting history', async () => {
        const { dbPath } = location();
        const media = new MediaStore(dbPath);
        await media.initialization;
        const db = new DatabaseSync(dbPath);

        try {
            await expect(
                async () =>
                    await media.rememberImage({
                        ...image,
                        summary: 'x'.repeat(MEDIA_DATA_MAX_CHARS),
                    }),
            ).rejects.toThrow('storage limit');
            await media.rememberImage(image);
            db.exec("UPDATE media_entries SET data = '{broken'");
            await expect(async () => await media.findImage(image.file)).rejects.toThrow();
            db.exec("UPDATE media_entries SET data = 'null'");
            await expect(async () => await media.findImage(image.file)).rejects.toThrow(
                'invalid persisted',
            );
            expect((await media.size()).images).toBe(1);
        } finally {
            db.close();
            await media.close();
        }
    });

    it.each(['image', 'record', 'video'] as const)(
        'keeps migrated %s history independent of new same-named resources',
        async (type) => {
            const { dbPath, legacyPath } = location();
            const old = new MediaStore(legacyPath);
            await old.initialization;
            const element = {
                type,
                fileId: 'same.png',
                fileName: 'same.png',
                fileSize: 120,
                md5Hex: image.md5Hex,
                sha1Hex: image.sha1Hex,
                width: 32,
                height: 24,
                picFormat: 1001,
                duration: 3,
                voiceFormat: 1,
                videoFormat: 0,
            } as MessageElement;
            await elementsToOneBotSegments(converter(old), [element], true, 123);
            await old.close();
            const source = fs.readFileSync(legacyPath);
            const messages = new MessageStore(dbPath);
            await messages.initialization;
            await messages.storeEvent(42, true, 123, 1, 'GroupMessage', {
                user_id: 456,
                message_id: 42,
                message_type: 'group',
                message: [{ type, data: { file: image.file } }],
            });
            await migrateLegacyMedia(dbPath);
            expect(fs.readFileSync(legacyPath)).toEqual(source);
            fs.rmSync(legacyPath);
            await migrateLegacyMedia(dbPath);
            const media = new MediaStore(dbPath);
            await media.initialization;

            try {
                await elementsToOneBotSegments(
                    converter(media),
                    [{ ...element, md5Hex: 'cc'.repeat(16) }],
                    true,
                    123,
                );
                const { ref, sendGroup } = context(messages, media);
                await forwardSingleMessage(ref, 42, { groupId: 999 });
                expect(sendGroup).toHaveBeenCalledWith(999, [
                    expect.objectContaining({ md5Hex: image.md5Hex }),
                ]);
            } finally {
                await media.close();
                await messages.close();
            }
        },
    );

    it('rolls back a failed legacy batch and resumes after the source is repaired', async () => {
        const { dbPath, legacyPath } = location();
        const old = new MediaStore(legacyPath);
        await old.initialization;
        await old.rememberImage(image);
        await old.close();
        const source = new DatabaseSync(legacyPath);
        source.prepare("INSERT INTO media_entries VALUES ('image', 'broken', ?, 1)").run('{broken');
        source.close();
        await expect(migrateLegacyMedia(dbPath)).rejects.toThrow();
        const destination = new MediaStore(dbPath);
        await destination.initialization;
        expect((await destination.size()).images).toBe(0);
        await destination.close();
        const repaired = new DatabaseSync(legacyPath);
        repaired
            .prepare("UPDATE media_entries SET data = ? WHERE primary_key = 'broken'")
            .run(JSON.stringify({ ...image, file: 'broken' }));
        repaired.close();
        await migrateLegacyMedia(dbPath);
        const reopened = new MediaStore(dbPath);
        await reopened.initialization;
        expect((await reopened.size()).images).toBe(2);
        await reopened.close();
    });

    it('normalizes legacy inline payloads without discarding their metadata', async () => {
        const { dbPath, legacyPath } = location();
        const old = new MediaStore(legacyPath);
        await old.initialization;
        await old.close();
        const inline = `base64://${'Z'.repeat(100000)}`;
        const source = new DatabaseSync(legacyPath);
        source
            .prepare("INSERT INTO media_entries VALUES ('image', ?, ?, 1)")
            .run(inline, JSON.stringify({ ...image, file: inline, url: inline, imageUrl: inline }));
        source.prepare("INSERT INTO media_keys VALUES ('image', ?, ?)").run(inline, inline);
        source.close();
        await migrateLegacyMedia(dbPath);
        const media = new MediaStore(dbPath);
        await media.initialization;

        try {
            expect(await media.findImage(inline)).toMatchObject({
                md5Hex: image.md5Hex,
                url: '',
                imageUrl: '',
            });
            expect(JSON.stringify(await media.findImage(inline))).not.toContain('base64://');
        } finally {
            await media.close();
        }
    });

    it('resumes a cancelled migration from its committed batch cursor', async () => {
        const { dbPath, legacyPath } = location();
        const old = new MediaStore(legacyPath);
        await old.initialization;

        for (let i = 0; i < 205; i++) {
            await old.rememberImage({ ...image, file: `entry-${i}` });
        }

        await old.close();
        let checks = 0;
        await migrateLegacyMedia(dbPath, () => ++checks > 1);
        const partial = new MediaStore(dbPath);
        await partial.initialization;
        expect((await partial.size()).images).toBe(200);
        await partial.close();
        await migrateLegacyMedia(dbPath);
        const complete = new MediaStore(dbPath);
        await complete.initialization;
        expect((await complete.size()).images).toBe(205);
        expect((await complete.findImage('entry-204'))?.md5Hex).toBe(image.md5Hex);
        await complete.close();
    });
});