'use strict';

const test = require('node:test');
const assert = require('node:assert/strict');

const convert = require('../../src/convert/index.js');

test('convert.possibilities — exported as a top-level function', () => {
    assert.equal(typeof convert.possibilities, 'function');
});

test('convert.possibilities(volumeFlowRate) returns common flow units', () => {
    const units = convert.possibilities('volumeFlowRate');
    assert.ok(Array.isArray(units));
    assert.ok(units.length > 0);
    for (const u of ['m3/s', 'm3/h', 'l/s', 'l/min', 'l/h']) {
        assert.ok(units.includes(u), `expected '${u}' in volumeFlowRate possibilities`);
    }
});

test('convert.possibilities(pressure) returns common pressure units', () => {
    const units = convert.possibilities('pressure');
    for (const u of ['Pa', 'kPa', 'bar', 'mbar', 'psi']) {
        assert.ok(units.includes(u), `expected '${u}' in pressure possibilities`);
    }
});

test('convert.possibilities(power) returns common power units', () => {
    const units = convert.possibilities('power');
    for (const u of ['W', 'kW', 'MW']) {
        assert.ok(units.includes(u), `expected '${u}' in power possibilities`);
    }
});

test('convert.possibilities(temperature) returns K, C, F', () => {
    const units = convert.possibilities('temperature');
    for (const u of ['K', 'C', 'F']) {
        assert.ok(units.includes(u), `expected '${u}' in temperature possibilities`);
    }
});

test('convert.possibilities for length / mass / volume return non-empty', () => {
    assert.ok(convert.possibilities('length').includes('m'));
    assert.ok(convert.possibilities('mass').includes('kg'));
    assert.ok(convert.possibilities('volume').includes('l'));
});

test('convert.possibilities(unknown) returns []', () => {
    assert.deepEqual(convert.possibilities('foo'), []);
    assert.deepEqual(convert.possibilities('bogus-measure'), []);
});

test('convert.possibilities handles invalid input safely', () => {
    assert.deepEqual(convert.possibilities(), []);
    assert.deepEqual(convert.possibilities(null), []);
    assert.deepEqual(convert.possibilities(''), []);
    assert.deepEqual(convert.possibilities(42), []);
});

test('convert.possibilities is sorted and deduplicated', () => {
    const units = convert.possibilities('pressure');
    const sorted = [...units].sort();
    assert.deepEqual(units, sorted, 'result should be alphabetically sorted');
    const set = new Set(units);
    assert.equal(set.size, units.length, 'result should have no duplicates');
});

test('convert.possibilities returns stable / cached results across calls', () => {
    const a = convert.possibilities('volumeFlowRate');
    const b = convert.possibilities('volumeFlowRate');
    assert.deepEqual(a, b, 'two calls must return equal arrays');
    // Mutating the returned array must not poison the cache.
    a.push('SHOULD_NOT_PERSIST');
    const c = convert.possibilities('volumeFlowRate');
    assert.ok(!c.includes('SHOULD_NOT_PERSIST'), 'cached array must be defensively copied');
    assert.deepEqual(c, b);
});

test('convert.measures lists known measure names', () => {
    const m = convert.measures();
    assert.ok(Array.isArray(m));
    for (const name of ['length', 'mass', 'volume', 'pressure', 'power', 'temperature', 'volumeFlowRate']) {
        assert.ok(m.includes(name), `expected measure '${name}'`);
    }
});

test('convert factory still works (regression — no breakage of existing API)', () => {
    const result = convert(1).from('m').to('cm');
    assert.equal(result, 100);
});