import {
    clearBlackboard,
    getBlackboardModel,
    getBranchesAndTags,
    getResourceGroups,
    isSameResource,
    isSameResourceGroup,
    isSameResourceLink,
    logInDepiClient,
    logInDepiClientWithToken,
    ping,
    setBranch,
} from '../src/depiUtils';
import { depiPassword, depiUrl, depiUser } from './helpers/config';
import { closeSession } from './helpers/session';

describe('depiUtils integration', () => {
    it('logs in, pings, and logs out', async () => {
        const session = await logInDepiClient(depiUrl, depiUser, depiPassword);

        expect(session.sessionId).toBeTruthy();
        expect(session.user).toBe(depiUser);
        expect(session.token).toBeTruthy();

        const pingResult = await ping(session);
        expect(pingResult.token).toBeTruthy();

        await closeSession(session);
    });

    it('rejects invalid credentials', async () => {
        await expect(
            logInDepiClient(depiUrl, depiUser, 'wrong-password'),
        ).rejects.toThrow(/Could not loginAsync/);
    });

    it('logs in with a token from a previous session', async () => {
        const firstSession = await logInDepiClient(depiUrl, depiUser, depiPassword);
        const token = firstSession.token;
        await closeSession(firstSession);

        const secondSession = await logInDepiClientWithToken(depiUrl, token);

        expect(secondSession.user).toBe(depiUser);
        expect(secondSession.token).toBeTruthy();

        await closeSession(secondSession);
    });

    it('lists branches and tags on a fresh server', async () => {
        const session = await logInDepiClient(depiUrl, depiUser, depiPassword);

        const { branches, tags } = await getBranchesAndTags(session);

        expect(branches).toContain('main');
        expect(tags).toEqual([]);

        await closeSession(session);
    });

    it('returns resource groups as an array', async () => {
        const session = await logInDepiClient(depiUrl, depiUser, depiPassword);

        const resourceGroups = await getResourceGroups(session);

        expect(Array.isArray(resourceGroups)).toBe(true);

        await closeSession(session);
    });

    it('switches to the main branch', async () => {
        const session = await logInDepiClient(depiUrl, depiUser, depiPassword);

        const activeBranch = await setBranch(session, 'main');
        expect(activeBranch).toBe('main');

        await closeSession(session);
    });

    it('manages blackboard resources', async () => {
        const session = await logInDepiClient(depiUrl, depiUser, depiPassword);

        await clearBlackboard(session);

        const emptyModel = await getBlackboardModel(session);
        expect(emptyModel.resources).toEqual([]);
        expect(emptyModel.links).toEqual([]);

        await clearBlackboard(session);
        await closeSession(session);
    });
});

describe('depiUtils comparison helpers', () => {
    const resourceA = {
        toolId: 'git',
        resourceGroupUrl: '/project/a',
        url: '/file/a.txt',
    };
    const resourceB = {
        toolId: 'git',
        resourceGroupUrl: '/project/b',
        url: '/file/b.txt',
    };

    it('compares resources', () => {
        expect(isSameResource(resourceA, resourceA)).toBe(true);
        expect(isSameResource(resourceA, resourceB)).toBe(false);
        expect(isSameResource(undefined, resourceA)).toBe(false);
    });

    it('compares resource groups', () => {
        const groupA = { toolId: 'git', url: '/project/a' };
        const groupB = { toolId: 'git', url: '/project/b' };

        expect(isSameResourceGroup(groupA, groupA)).toBe(true);
        expect(isSameResourceGroup(groupA, groupB)).toBe(false);
    });

    it('compares resource links', () => {
        const link = {
            source: resourceA,
            target: resourceB,
        };

        expect(isSameResourceLink(link, link)).toBe(true);
        expect(isSameResourceLink(link, { source: resourceB, target: resourceA })).toBe(false);
    });
});