import fs from 'node:fs/promises';
import assert from 'node:assert/strict';

const proposal = JSON.parse(await fs.readFile('docs/proofs/pilot-access-proposal.json', 'utf8'));
const applied = JSON.parse(await fs.readFile('docs/proofs/pilot-access-activation.json', 'utf8'));
assert.equal(applied.result, 'applied');
const source = await fs.readFile('scripts/supplier-evaluation-check.mjs', 'utf8');
const common = source.slice(source.indexOf('const base ='), source.indexOf('const author ='));
await new Function('fs', 'assert', 'proposal', 'applied', 'return (async()=>{' + common + `
    const viewer = client();
    await viewer.enter('admin');
    const parameters = await viewer.request('/administracao/parametrizacao');
    assert.equal(parameters.status, 200);
    const p = parameters.page.props;
    assert.equal(p.active, true);
    assert.equal(p.version, applied.active_version);
    assert.equal(p.profiles.length, 11);
    assert.equal(p.memberships.length, 17);
    assert.equal(p.users.length, 12);
    assert.equal(p.activationPreview.permanent_administrators, 2);
    assert.equal(p.activationPreview.losing_access, 0);
    for (const person of proposal.users) {
        const actual = p.activationPreview.users.find(user => user.id === person.id);
        assert.equal(actual.name, person.name);
        assert.deepEqual([...actual.current_permissions].sort(), [...person.planned_permissions].sort());
        assert.deepEqual(actual.current_contexts, person.current_contexts);
        assert.equal(actual.current_can_request, person.current_can_request);
        assert.equal(p.users.find(user => user.id === person.id).department_id, person.department_id);
    }
    assert.equal(p.companyRules.first_limit, proposal.proposed_rules.first_limit);
    assert.equal(p.companyRules.second_limit, proposal.proposed_rules.second_limit);
    assert.equal(p.companyRules.includes_tax, proposal.proposed_rules.includes_tax);
    assert.equal(p.companyRules.default_tax_rate, proposal.current_rules.default_tax_rate);
    assert.equal(p.companyRules.provisional, false);
    async function selectInternal(client, area = 'procurement') {
        const response = await client.request('/contexto', 'POST', { area, option: area + '.internal' });
        assert.equal(response.status, 302);
    }
    await selectInternal(viewer);
    const readiness = await viewer.request('/stock/piloto');
    assert.equal(readiness.status, 200);
    const report = readiness.page.props.report;
    for (const [group, ids] of [['prepare', [9]], ['review', [10]], ['deliver', [13]], ['supply_prepare', [11]], ['supply_review', [12]]]) {
        assert.deepEqual(report.participants[group].map(user => user.id).sort((a, b) => a - b), ids);
    }
    assert.equal(report.checks.find(check => check.key === 'participants').ok, true);
    assert.equal(report.participants.purchase_requester.length, 12);
    const roles = [];
    for (const [role, path, capability] of [
        ['requester', '/stock/requisicoes', 'canPrepare'],
        ['department_head', '/stock/requisicoes?view=review', null],
        ['warehouse', '/stock/requisicoes?view=delivery', null],
        ['procurement', '/stock/reposicao', 'canPrepare'],
        ['finance', '/stock/reposicao', 'canReview']
    ]) {
        const person = client();
        await person.enter(role);
        await selectInternal(person);
        const response = await person.request(path);
        assert.equal(response.status, 200, role + ' ' + path);
        if (capability) assert.equal(response.page.props[capability], true);
        if (role === 'procurement') assert.equal(response.page.props.canReview, false);
        if (role === 'finance') assert.equal(response.page.props.canPrepare, false);
        if (['warehouse', 'department_head'].includes(role)) assert.equal(response.page.props.canPrepare, false);
        assert.equal((await person.request('/administracao/parametrizacao')).status, 403);
        const tasks = await person.request('/requisicoes/tarefas');
        assert.equal(tasks.status, 200);
        roles.push({ role, route: path, result: 'passed', tasks: tasks.page.props.tasks.total });
    }
    await selectInternal(viewer, 'people');
    assert.equal((await viewer.request('/pessoas/tarefas')).status, 200);
    const proof = {
        checked_at: new Date().toISOString(), environment: base, result: 'passed', active: true,
        version: p.version, users: 12, profiles: 11, memberships: 17, permanent_administrators: 2,
        original_access_and_contexts_preserved: true, first_limit: p.companyRules.first_limit,
        second_limit: p.companyRules.second_limit, includes_tax: p.companyRules.includes_tax, provisional_rules: false,
        participants_separated: true, roles, readiness: {
            warehouse_scenario_ready: report.warehouse_scenario_ready,
            replenishment_scenario_ready: report.replenishment_scenario_ready,
            client_configuration_complete: report.client_configuration_complete,
            checks: report.checks.map(check => ({ key: check.key, ok: check.ok, detail: check.detail }))
        }, business_commands_executed: false, new_accounts: false, sgf_changes: false, visual_review: false
    };
    await fs.writeFile('docs/proofs/pilot-access-activation-http.json', JSON.stringify(proof, null, 2));
    console.log(JSON.stringify(proof, null, 2));
` + '})()')(fs, assert, proposal, applied);