import { expect } from '@jest/globals';
import { type Stdio, CaptureStdio, StdioMultiplexer, TargetedStdio } from '../../src/stdio';

describe('CaptureStdio', () => {
    it('captured streams are initialized to empty string', () => {
        let stdio = new CaptureStdio();
        expect(stdio.captured_stdout).toBe('');
        expect(stdio.captured_stderr).toBe('');
    });

    it('stdout() and stderr() captures', () => {
        let stdio = new CaptureStdio();
        stdio.stdout_writeline('hello');
        stdio.stdout_writeline('world');
        stdio.stderr_writeline('this is an error');
        expect(stdio.captured_stdout).toBe('hello\nworld\n');
        expect(stdio.captured_stderr).toBe('this is an error\n');
    });

    it('reset() works', () => {
        let stdio = new CaptureStdio();
        stdio.stdout_writeline('aaa');
        stdio.stderr_writeline('bbb');
        stdio.reset();
        expect(stdio.captured_stdout).toBe('');
        expect(stdio.captured_stderr).toBe('');
    });
});

describe('StdioMultiplexer', () => {
    let a: CaptureStdio;
    let b: CaptureStdio;
    let multi: StdioMultiplexer;

    beforeEach(() => {
        a = new CaptureStdio();
        b = new CaptureStdio();
        multi = new StdioMultiplexer();
    });

    it('works without listeners', () => {
        // no listeners, messages are ignored
        multi.stdout_writeline('out 1');
        multi.stderr_writeline('err 1');
        expect(a.captured_stdout).toBe('');
        expect(a.captured_stderr).toBe('');
        expect(b.captured_stdout).toBe('');
        expect(b.captured_stderr).toBe('');
    });

    it('redirects to multiple listeners', () => {
        multi.addListener(a);
        multi.stdout_writeline('out 1');
        multi.stderr_writeline('err 1');

        multi.addListener(b);
        multi.stdout_writeline('out 2');
        multi.stderr_writeline('err 2');

        expect(a.captured_stdout).toBe('out 1\nout 2\n');
        expect(a.captured_stderr).toBe('err 1\nerr 2\n');

        expect(b.captured_stdout).toBe('out 2\n');
        expect(b.captured_stderr).toBe('err 2\n');
    });
});

describe('TargetedStdio', () => {
    let capture: CaptureStdio;
    let targeted: TargetedStdio;
    let error_targeted: TargetedStdio;
    let multi: StdioMultiplexer;

    beforeEach(() => {
        //DOM element to capture stdout and stderr
        let target_div = document.getElementById('output-id');

        if (target_div === null) {
            target_div = document.createElement('div');
            target_div.id = 'output-id';
            document.body.appendChild(target_div);
        } else {
            target_div.innerHTML = '';
        }

        //DOM element to capture stderr
        let error_div = document.getElementById('error-id');

        if (error_div === null) {
            error_div = document.createElement('div');
            error_div.id = 'error-id';
            document.body.appendChild(error_div);
        } else {
            error_div.innerHTML = '';
        }

        const tag = document.createElement('div');
        tag.setAttribute('output', 'output-id');
        tag.setAttribute('stderr', 'error-id');

        capture = new CaptureStdio();
        targeted = new TargetedStdio(tag, 'output', true, true);
        error_targeted = new TargetedStdio(tag, 'stderr', false, true);

        multi = new StdioMultiplexer();
        multi.addListener(capture);
        multi.addListener(targeted);
        multi.addListener(error_targeted);
    });

    it('targeted id is set by constructor', () => {
        expect(targeted.source_attribute).toBe('output');
    });

    it('targeted stdio/stderr also goes to multiplexer', () => {
        multi.stdout_writeline('out 1');
        multi.stderr_writeline('out 2');
        expect(capture.captured_stdout).toBe('out 1\n');
        expect(capture.captured_stderr).toBe('out 2\n');
        expect(document.getElementById('output-id')?.innerHTML).toBe('out 1<br>out 2<br>');
        expect(document.getElementById('error-id')?.innerHTML).toBe('out 2<br>');
    });

    it('Add and remove targeted listener', () => {
        multi.stdout_writeline('out 1');
        multi.removeListener(targeted);
        multi.stdout_writeline('out 2');
        multi.addListener(targeted);
        multi.stdout_writeline('out 3');

        //all three should be captured by multiplexer
        expect(capture.captured_stdout).toBe('out 1\nout 2\nout 3\n');
        //out 2 should not be present in the DOM element
        expect(document.getElementById('output-id')?.innerHTML).toBe('out 1<br>out 3<br>');
    });
});