import { describe, expect, it } from 'vitest';
import type { LogStoragePolicy, LogStorageStatus } from '@snowluma/common/log-file-transport';
import type { RuntimeConfig } from '@snowluma/common/runtime';
import {
    LogStorageSettingsManager,
    StorageSettingsInputError,
    StorageSettingsLockedError,
    StorageSettingsTransactionError,
} from '../src/webui/storage-settings';

const persisted: RuntimeConfig = {
    webuiPort: 5099,
    hookAutoLoad: false,
    webuiHost: '0.0.0.0',
    webuiTls: { enabled: false },
    trustProxy: '',
    logMaxTotalMb: 1024,
    logRetainDays: 7,
    logPerUin: false,
};

const persistedPolicy: LogStoragePolicy = {
    maxTotalMb: 1024,
    retainDays: 7,
    perUinEnabled: false,
};

function status(
    policy: LogStoragePolicy,
    state: LogStorageStatus['state'] = 'healthy',
): LogStorageStatus {
    return {
        state,
        directory: '/private/logs',
        totalBytes: state === 'degraded' ? policy.maxTotalMb * 1024 * 1024 + 1 : 0,
        maxTotalBytes: policy.maxTotalMb * 1024 * 1024,
        retainDays: policy.retainDays,
        perUinEnabled: policy.perUinEnabled,
        fileCount: 0,
        activeFileCount: 0,
        droppedLines: 0,
        ...(state === 'healthy' ? {} : { lastError: 'quota could not be enforced' }),
    };
}

describe('LogStorageSettingsManager', () => {
    it('reports persisted, effective, and environment-locked settings separately', () => {
        const manager = new LogStorageSettingsManager({
            readPersisted: () => persisted,
            readEnvOverrides: () => ({ logRetainDays: 0, logPerUin: true }),
            readEffective: () =>
                status({
                    maxTotalMb: 1024,
                    retainDays: 0,
                    perUinEnabled: true,
                }),
            persist: () => {
                throw new Error('not used');
            },
            apply: async (policy) => status(policy),
        });

        expect(manager.read()).toEqual({
            saved: {
                logMaxTotalMb: 1024,
                logRetainDays: 7,
                logPerUin: false,
            },
            effective: {
                logMaxTotalMb: 1024,
                logRetainDays: 0,
                logPerUin: true,
            },
            envOverrides: ['logRetainDays', 'logPerUin'],
        });
    });

    it('reports the actual live policy separately from externally changed disk values', () => {
        const manager = new LogStorageSettingsManager({
            readPersisted: () => ({ ...persisted, logRetainDays: 30 }),
            readEnvOverrides: () => ({}),
            readEffective: () => status(persistedPolicy),
            persist: () => {
                throw new Error('not used');
            },
            apply: async (policy) => status(policy),
        });

        expect(manager.read()).toMatchObject({
            saved: { logRetainDays: 30 },
            effective: { logRetainDays: 7 },
        });
    });

    it('strictly rejects malformed, unknown, and empty patches', async () => {
        const manager = new LogStorageSettingsManager({
            readPersisted: () => persisted,
            readEnvOverrides: () => ({}),
            readEffective: () => status(persistedPolicy),
            persist: () => persisted,
            apply: async (policy) => status(policy),
        });

        await expect(manager.update(null)).rejects.toThrow(StorageSettingsInputError);
        await expect(manager.update({})).rejects.toThrow(StorageSettingsInputError);
        await expect(manager.update({ unknown: 1 })).rejects.toThrow(StorageSettingsInputError);
        await expect(manager.update({ logMaxTotalMb: 0 })).rejects.toThrow(
            StorageSettingsInputError,
        );
        await expect(manager.update({ logRetainDays: -1 })).rejects.toThrow(
            StorageSettingsInputError,
        );
        await expect(manager.update({ logPerUin: 1 })).rejects.toThrow(StorageSettingsInputError);
    });

    it('rejects edits to fields pinned by environment variables', async () => {
        let applied = false;
        const manager = new LogStorageSettingsManager({
            readPersisted: () => persisted,
            readEnvOverrides: () => ({ logMaxTotalMb: 2048 }),
            readEffective: () =>
                status({
                    maxTotalMb: 2048,
                    retainDays: 7,
                    perUinEnabled: false,
                }),
            persist: () => persisted,
            apply: async (policy) => {
                applied = true;
                return status(policy);
            },
        });

        await expect(manager.update({ logMaxTotalMb: 512 })).rejects.toThrow(
            StorageSettingsLockedError,
        );
        expect(applied).toBe(false);
    });

    it('applies before persisting and returns the new effective settings', async () => {
        const order: string[] = [];
        let current = persisted;
        const manager = new LogStorageSettingsManager({
            readPersisted: () => current,
            readEnvOverrides: () => ({}),
            readEffective: () =>
                status({
                    maxTotalMb: current.logMaxTotalMb ?? 1024,
                    retainDays: current.logRetainDays ?? 7,
                    perUinEnabled: current.logPerUin ?? false,
                }),
            persist: (patch) => {
                order.push('persist');
                current = { ...current, ...patch };
                return current;
            },
            apply: async (policy) => {
                order.push('apply');
                return status(policy);
            },
        });

        await expect(
            manager.update({
                logMaxTotalMb: 512,
                logRetainDays: 0,
                logPerUin: true,
            }),
        ).resolves.toMatchObject({
            settings: {
                saved: {
                    logMaxTotalMb: 512,
                    logRetainDays: 0,
                    logPerUin: true,
                },
                effective: {
                    logMaxTotalMb: 512,
                    logRetainDays: 0,
                    logPerUin: true,
                },
            },
            status: {
                state: 'healthy',
                maxTotalBytes: 512 * 1024 * 1024,
            },
        });
        expect(order).toEqual(['apply', 'persist']);
    });

    it('does not persist a policy that cannot be enforced and rolls runtime state back', async () => {
        const applied: LogStoragePolicy[] = [];
        let persistCalls = 0;
        const manager = new LogStorageSettingsManager({
            readPersisted: () => persisted,
            readEnvOverrides: () => ({}),
            readEffective: () => status(persistedPolicy),
            persist: () => {
                persistCalls += 1;
                return persisted;
            },
            apply: async (policy) => {
                applied.push(policy);
                return status(policy, applied.length === 1 ? 'degraded' : 'healthy');
            },
        });

        await expect(manager.update({ logMaxTotalMb: 1 })).rejects.toThrow(
            StorageSettingsTransactionError,
        );
        expect(persistCalls).toBe(0);
        expect(applied).toEqual([
            { maxTotalMb: 1, retainDays: 7, perUinEnabled: false },
            { maxTotalMb: 1024, retainDays: 7, perUinEnabled: false },
        ]);
    });

    it('restores both runtime state and persisted settings when persistence fails', async () => {
        const applied: LogStoragePolicy[] = [];
        const persistedPatches: Partial<RuntimeConfig>[] = [];
        let persistCalls = 0;
        const manager = new LogStorageSettingsManager({
            readPersisted: () => persisted,
            readEnvOverrides: () => ({}),
            readEffective: () => status(persistedPolicy),
            persist: (patch) => {
                persistedPatches.push(patch);
                persistCalls += 1;

                if (persistCalls === 1) {
                    throw new Error('disk full');
                }

                return persisted;
            },
            apply: async (policy) => {
                applied.push(policy);
                return status(policy);
            },
        });

        await expect(manager.update({ logRetainDays: 30 })).rejects.toThrow(
            StorageSettingsTransactionError,
        );
        expect(applied).toEqual([
            { maxTotalMb: 1024, retainDays: 30, perUinEnabled: false },
            { maxTotalMb: 1024, retainDays: 7, perUinEnabled: false },
        ]);
        expect(persistedPatches).toEqual([{ logRetainDays: 30 }, persisted]);
    });

    it('serializes concurrent updates so invocation order remains authoritative', async () => {
        let current = persisted;
        let livePolicy = persistedPolicy;
        const applied: LogStoragePolicy[] = [];
        const releases: Array<() => void> = [];
        let notifySecondStarted!: () => void;
        const secondStarted = new Promise<void>((resolve) => {
            notifySecondStarted = resolve;
        });
        const manager = new LogStorageSettingsManager({
            readPersisted: () => current,
            readEnvOverrides: () => ({}),
            readEffective: () => status(livePolicy),
            persist: (patch) => {
                current = { ...current, ...patch };
                return current;
            },
            apply: async (policy) => {
                applied.push(policy);

                if (applied.length === 2) {
                    notifySecondStarted();
                }

                await new Promise<void>((resolve) => releases.push(resolve));
                livePolicy = policy;
                return status(policy);
            },
        });

        const first = manager.update({ logRetainDays: 30 });
        const second = manager.update({ logRetainDays: 60 });
        await Promise.resolve();
        expect(applied).toHaveLength(1);

        releases.shift()?.();
        await secondStarted;
        expect(applied).toHaveLength(2);
        releases.shift()?.();
        await Promise.all([first, second]);

        expect(current.logRetainDays).toBe(60);
        expect(applied.map((policy) => policy.retainDays)).toEqual([30, 60]);
    });
});