import {
	newSystemClient,
	readLayerProfile,
	ResourceInstance,
	ResourceSpecials,
	ResourceValue,
	ServiceError
} from '../node';
import {newServiceClient as newServiceClient} from '../node';
import {resolve, Universe} from '../node';
import {Id, IdMap, Obj} from '../node';
import {ListMapping, PrimitiveMapping, SystemError} from '../node';
import {ResourceSchema} from '../node';
import {globalApiUrl, globalSystemUrl, globalUniverse, layerProfileStr} from './config';

async function loadUniverseFromApi(name: string, url: string): Promise<Universe | undefined> {
	const client = newServiceClient(url);
	const id = await client.resolveUniverse(name);
	if (id instanceof ServiceError) {
		return undefined;
	}
	return await client.loadUniverse(id);
}

test('newClient returns instance', () => {
	const client = newSystemClient();
	expect(client).toBeTruthy();
});

test('getInfo returns info object', async () => {
	const client = newSystemClient(globalSystemUrl);
	const info = await client.getInfo();
	if (info instanceof SystemError) {
		expect(true).toBeFalsy();
		return;
	}
	expect(info).toBeTruthy();
	expect(info.apiVersion).toBe('1.0');
	expect(info.unixTime).toBeTruthy();
	expect(info.layers).toHaveLength(0);
});

test('getInfo with token returns info object', async () => {
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);
	const info = await client.getInfo();
	if (info instanceof SystemError) {
		expect(true).toBeFalsy();
		return;
	}
	expect(info).toBeTruthy();
	expect(info.apiVersion).toBe('1.0');
	expect(info.unixTime).toBeTruthy();
	expect(info.layers).toHaveLength(4);
});

test('createObject creates object', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);
	const absId = resolve(universe, 'base.object/')!;
	const obj = await client.createObject(absId, 'test123') as Obj;
	expect(obj).toBeTruthy();
	expect(obj.name).toEqual('test123');
	expect(obj.created).toBeTruthy();
	expect(obj.user).toBeTruthy();
});

/*test('multiple tokens for same space', async () => {
	const modeling = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	await client.addAccessTokens(tokenToAccess(['main_read'], globalTokenRead));
	await client.addAccessTokens(tokenToAccess(['main_write'], globalTokenWrite));
	expect(client.getAccessTokens(['main_read', 'main_write'])).toHaveLength(2);
	const absId = resolve(modeling, 'base.object/')!;
	const obj = await client.createObject(absId, 'test123', false, 'main_write', {accessNames: ['main_write']}) as Obj;
	expect(obj.name).toEqual('test123');
	const obj2 = await client.getObject(obj.id, {accessNames: ['main_write']});
	expect(obj2).toBeInstanceOf(SystemError);
	const obj3 = await client.getObject(obj.id) as Obj;
	expect(obj3.name).toEqual('test123');
	const obj4 = await client.createObject(absId, 'test124', false, 'main_write') as Obj;
	expect(obj4.name).toEqual('test124');
});*/

test('getName returns name', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);
	const obj = await client.createObject(resolve(universe, 'base.object/')!, 'test123') as Obj;
	const objName = await client.getName(obj.id);
	expect(objName).toEqual('test123');
});

test('setName changes name', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);
	const obj = await client.createObject(resolve(universe, 'base.object/')!, 'test123') as Obj;
	await client.setName(obj.id, 'newTest');
	const objName = await client.getName(obj.id);
	expect(objName).toEqual('newTest');
});

test('getData returns string', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);
	const obj = await client.createObject(resolve(universe, 'base.object/')!, 'test123') as Obj;
	await client.setData(obj.id, 'newTest', 'string');
	const objData = await client.getData(obj.id, 'string');
	expect(objData).toEqual('newTest');
});

test('getData returns integer', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);
	const obj = await client.createObject(resolve(universe, 'base.object/')!, 'test123') as Obj;
	await client.setData(obj.id, 12, 'integer');
	const objData = await client.getData(obj.id, 'integer');
	expect(objData).toEqual(12);
});

test('getData returns float', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);
	const obj = await client.createObject(resolve(universe, 'base.object/')!, 'test123') as Obj;
	await client.setData(obj.id, 12, 'float');
	const objData = await client.getData(obj.id, 'float');
	expect(objData).toEqual(12);
});

test('getData returns boolean', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);
	const obj = await client.createObject(resolve(universe, 'base.object/')!, 'test123') as Obj;
	await client.setData(obj.id, true, 'boolean');
	const objData = await client.getData(obj.id, 'boolean');
	expect(objData).toEqual(true);
});

test('getData returns raw', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);
	const obj = await client.createObject(resolve(universe, 'base.object/')!, 'test123') as Obj;
	await client.setData(obj.id, new Uint8Array([1, 2, 3]), 'raw');
	const objData = await client.getData(obj.id, 'raw') as ArrayBuffer;
	expect(Array.from(new Uint8Array(objData))).toEqual([1, 2, 3]);
});

test('getData returns chunked raw', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);
	const obj = await client.createObject(resolve(universe, 'base.object/')!, 'test123') as Obj;
	await client.setData(obj.id, new Uint8Array([1, 2, 3]), 'raw');
	const updates: [ArrayBuffer, number, number][] = [];
	const objData = await client.getData(obj.id, 'raw', 1, function (chunk: ArrayBuffer, offset: number, length: number): void {
		updates.push([chunk, offset, length]);
	}) as ArrayBuffer;
	expect(Array.from(new Uint8Array(objData))).toEqual([1, 2, 3]);
	expect(updates.map((v) => [Array.from(new Uint8Array(v[0])), v[1], v[2]])).toEqual(
		[[[1], 0, 3], [[2], 1, 3], [[3], 2, 3]]);
});

test('getSpecials returns specials', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);
	const specs = await client.getSpecials(resolve(universe, 'base.object/')!) as string[];
	expect(specs.length).toBeGreaterThan(10);
});

test('getSpecials returns abstracts', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);
	const abs = await client.getAbstracts(resolve(universe, 'data.@integer/')!) as string[];
	expect(abs.length).toEqual(2);
});

test('getTargets returns targets', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);

	const obj1 = await client.createObject(universe.resolve('base.object/')!, 'obj1') as Obj;
	const obj2 = await client.createObject(universe.resolve('base.object/')!, 'obj2') as Obj;
	const obj3 = await client.createObject(universe.resolve('base.object/')!, 'obj3') as Obj;

	const rel1 = await client.createRelation(obj1.id, obj2.id, universe.resolve('base.object#relation/')!);
	const rel2 = await client.createRelation(obj1.id, obj3.id, universe.resolve('base.object#relation/')!);

	const tgs1 = await client.getTargets(obj1.id) as IdMap;
	expect(Object.values(tgs1).length).toEqual(2);
	const tgs2 = await client.getTargets(obj1.id, 'objects') as Id[];
	expect(tgs2.length).toEqual(2);
	const tgs3 = await client.getTargets(obj1.id, 'relations') as Id[];
	expect(tgs3.length).toEqual(2);
});

test('getOrigins returns origins', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);

	const obj1 = await client.createObject(universe.resolve('base.object/')!, 'obj1') as Obj;
	const obj2 = await client.createObject(universe.resolve('base.object/')!, 'obj2') as Obj;
	const obj3 = await client.createObject(universe.resolve('base.object/')!, 'obj3') as Obj;

	const rel1 = await client.createRelation(obj1.id, obj2.id, universe.resolve('base.object#relation/')!);
	const rel2 = await client.createRelation(obj1.id, obj3.id, universe.resolve('base.object#relation/')!);

	let tgs: any = await client.getOrigins(obj2.id);
	expect(Object.values(tgs).length).toEqual(1);
	tgs = await client.getOrigins(obj2.id, 'objects') as Id[];
	expect(tgs.length).toEqual(1);
	tgs = await client.getOrigins(obj2.id, 'relations') as Id[];
	expect(tgs.length).toEqual(1);
});

test('getKeyedTargets returns targets with integer keys', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);

	const obj1 = await client.createObject(universe.resolve('base.object/')!, 'obj1') as Obj;
	const obj2 = await client.createObject(universe.resolve('base.object/')!, 'obj2') as Obj;
	const obj3 = await client.createObject(universe.resolve('base.object/')!, 'obj3') as Obj;

	const rel1 = await client.createRelation(obj1.id, obj2.id, universe.resolve('base.object#relation/')!, 1, 'integer') as Obj;
	const rel2 = await client.createRelation(obj1.id, obj3.id, universe.resolve('base.object#relation/')!, 2, 'integer') as Obj;

	const targets1 = await client.getKeyedTargets(obj1.id, universe.resolve('base.object#relation/')!, 'keyed_objects', 'integer') as [number, Id][];
	expect(targets1).toEqual([[1, obj2.id], [2, obj3.id]]);

	const targets2 = await client.getKeyedTargets(obj1.id, universe.resolve('base.object#relation/')!, 'keyed_relations', 'integer') as [number, Id][];
	expect(targets2).toEqual([[1, rel1.id], [2, rel2.id]]);

	const targets3 = await client.getKeyedTargets(obj1.id, universe.resolve('base.object#relation/')!, 'keyed_pairs', 'integer') as [number, Id, Id][];
	expect(targets3).toEqual([[1, rel1.id, obj2.id], [2, rel2.id, obj3.id]]);
});

test('getKeyedTargets returns targets with string keys', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);

	const obj1 = await client.createObject(universe.resolve('base.object/')!, 'obj1') as Obj;
	const obj2 = await client.createObject(universe.resolve('base.object/')!, 'obj2') as Obj;
	const obj3 = await client.createObject(universe.resolve('base.object/')!, 'obj3') as Obj;

	const rel1 = await client.createRelation(obj1.id, obj2.id, universe.resolve('base.object#relation/')!, 'a', 'string') as Obj;
	const rel2 = await client.createRelation(obj1.id, obj3.id, universe.resolve('base.object#relation/')!, 'b', 'string') as Obj;

	const targets1 = await client.getKeyedTargets(obj1.id, universe.resolve('base.object#relation/')!, 'keyed_objects', 'string') as [string, Id][];
	expect(targets1).toEqual([['a', obj2.id], ['b', obj3.id]]);

	const targets2 = await client.getKeyedTargets(obj1.id, universe.resolve('base.object#relation/')!, 'keyed_relations', 'string') as [string, Id][];
	expect(targets2).toEqual([['a', rel1.id], ['b', rel2.id]]);

	const targets3 = await client.getKeyedTargets(obj1.id, universe.resolve('base.object#relation/')!, 'keyed_pairs', 'string') as [string, Id, Id][];
	expect(targets3).toEqual([['a', rel1.id, obj2.id], ['b', rel2.id, obj3.id]]);
});

test('getKeyedTargets returns targets with hex keys', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);

	const obj1 = await client.createObject(universe.resolve('base.object/')!, 'obj1') as Obj;
	const obj2 = await client.createObject(universe.resolve('base.object/')!, 'obj2') as Obj;
	const obj3 = await client.createObject(universe.resolve('base.object/')!, 'obj3') as Obj;

	const rel1 = await client.createRelation(obj1.id, obj2.id, universe.resolve('base.object#relation/')!, 'babe', 'hex') as Obj;
	const rel2 = await client.createRelation(obj1.id, obj3.id, universe.resolve('base.object#relation/')!, 'ebab', 'hex') as Obj;

	const targets1 = await client.getKeyedTargets(obj1.id, universe.resolve('base.object#relation/')!, 'keyed_objects', 'hex') as [string, Id][];
	expect(targets1).toEqual([['babe', obj2.id], ['ebab', obj3.id]]);

	const targets2 = await client.getKeyedTargets(obj1.id, universe.resolve('base.object#relation/')!, 'keyed_relations', 'hex') as [string, Id][];
	expect(targets2).toEqual([['babe', rel1.id], ['ebab', rel2.id]]);

	const targets3 = await client.getKeyedTargets(obj1.id, universe.resolve('base.object#relation/')!, 'keyed_pairs', 'hex') as [string, Id, Id][];
	expect(targets3).toEqual([['babe', rel1.id, obj2.id], ['ebab', rel2.id, obj3.id]]);
});

test('getValue returns value', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);

	const obj1 = await client.createObject(universe.resolve('base.object/')!, 'obj1') as Obj;
	const obj2 = await client.createObject(universe.resolve('base.object/')!, 'obj2') as Obj;
	const rel1 = await client.createRelation(obj1.id, obj2.id, universe.resolve('base.object#relation/')!) as Obj;
	const rel2 = await client.createRelation(obj1.id, obj2.id, rel1.id) as Obj;

	await client.setData(obj2.id, 'test', 'string');
	const val = await client.getValue(obj1.id, rel1.id, 'data', 'string', new PrimitiveMapping());
	expect(val).toEqual('test');
});

test('getValue returns name', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);

	const obj1 = await client.createObject(universe.resolve('base.object/')!, 'obj1') as Obj;
	const obj2 = await client.createObject(universe.resolve('base.object/')!, 'obj2') as Obj;
	const rel1 = await client.createRelation(obj1.id, obj2.id, universe.resolve('base.object#relation/')!) as Obj;
	const rel2 = await client.createRelation(obj1.id, obj2.id, rel1.id) as Obj;

	const val = await client.getValue(obj1.id, rel1.id, 'name', 'string', new PrimitiveMapping());
	expect(val).toEqual('obj2');
});

test('getValue returns reverse value', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);

	const obj1 = await client.createObject(universe.resolve('base.object/')!, 'obj1') as Obj;
	const obj2 = await client.createObject(universe.resolve('base.object/')!, 'obj2') as Obj;
	const rel1 = await client.createRelation(obj1.id, obj2.id, universe.resolve('base.object#relation/')!) as Obj;
	const rel2 = await client.createRelation(obj1.id, obj2.id, rel1.id) as Obj;

	const val = await client.getValue(obj1.id, rel1.id, 'id', 'hex', new PrimitiveMapping());
	expect(val).toEqual(obj2.id);
	const val2 = await client.getValue(obj2.id, '-' + rel1.id, 'id', 'hex', new PrimitiveMapping());
	expect(val2).toEqual(obj1.id);
	const val3 = await client.getValue(obj2.id, universe.resolve('-base.object#relation/')!, 'id', 'hex', new PrimitiveMapping());
	expect(val3).toEqual(obj1.id);
});

test('setValue sets value', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);

	const obj1 = await client.createObject(universe.resolve('base.object/')!, 'obj1') as Obj;
	const obj2 = await client.createObject(universe.resolve('base.object/')!, 'obj2') as Obj;
	const rel1 = await client.createRelation(obj1.id, obj2.id, universe.resolve('base.object#relation/')!) as Obj;

	const resp = await client.putValue(obj1.id, rel1.id, 'test', 'data', 'string', new PrimitiveMapping());
	const val = await client.getValue(obj1.id, rel1.id, 'data', 'string', new PrimitiveMapping());
	expect(val).toEqual('test');
});

test('lookupData works', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);

	const obj1 = await client.createObject(universe.resolve('base.object/')!, 'obj1') as Obj;

	const obja = await client.createObject(obj1.id) as Obj;
	const objb = await client.createObject(obj1.id) as Obj;
	const objc = await client.createObject(obj1.id) as Obj;
	const objd = await client.createObject(obj1.id) as Obj;
	const obje = await client.createObject(obj1.id) as Obj;

	await client.setData(obja.id, 'test', 'string');
	await client.setData(objb.id, 123, 'integer');
	await client.setData(objc.id, 5.8, 'float');
	await client.setData(objd.id, true, 'boolean');
	await client.setData(obje.id, new Uint8Array([1, 2, 3, 4, 5]), 'raw');

	expect(await client.lookupData(obj1.id, 'test', 'string', new PrimitiveMapping())).toEqual(obja.id);
	expect(await client.lookupData(obj1.id, 123, 'integer', new ListMapping())).toEqual([objb.id]);
	expect(await client.lookupData(obj1.id, 5.8, 'float', new PrimitiveMapping())).toEqual(objc.id);
	expect(await client.lookupData(obj1.id, true, 'boolean', new ListMapping())).toEqual([objd.id]);
	expect(await client.lookupData(obj1.id, new Uint8Array([1, 2, 3, 4, 5]), 'raw', new PrimitiveMapping())).toEqual(obje.id);
});

test('lookupValue works', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);

	const obj1 = await client.createObject(universe.resolve('base.object/')!, 'obj1') as Obj;
	const obj2 = await client.createObject(universe.resolve('base.object/')!, 'obj1') as Obj;
	const rel = await client.createRelation(obj1.id, obj2.id, universe.resolve('base.object#relation/')!) as Obj;

	const obj1a = await client.createObject(obj1.id, 'obj1') as Obj;
	const obj1b = await client.createObject(obj1.id, 'obj1') as Obj;

	await client.putValue(obj1a.id, rel.id, 'test1', 'data', 'string', new PrimitiveMapping());
	await client.putValue(obj1b.id, rel.id, 'test2', 'data', 'string', new PrimitiveMapping());
	await client.putValue(obj1a.id, rel.id, 12, 'data', 'integer', new PrimitiveMapping());
	await client.putValue(obj1b.id, rel.id, 24, 'data', 'integer', new PrimitiveMapping());
	await client.putValue(obj1a.id, rel.id, 7.32, 'data', 'float', new PrimitiveMapping());
	await client.putValue(obj1b.id, rel.id, -7.32, 'data', 'float', new PrimitiveMapping());
	await client.putValue(obj1a.id, rel.id, true, 'data', 'boolean', new PrimitiveMapping());
	await client.putValue(obj1b.id, rel.id, false, 'data', 'boolean', new PrimitiveMapping());

	expect(await client.lookupValue(rel.id, 'test1', 'string', new PrimitiveMapping()) as Id).toEqual(obj1a.id);
	expect(await client.lookupValue(rel.id, 'test2', 'string', new PrimitiveMapping()) as Id).toEqual(obj1b.id);
	expect(await client.lookupValue(rel.id, 12, 'integer', new PrimitiveMapping()) as Id).toEqual(obj1a.id);
	expect(await client.lookupValue(rel.id, 24, 'integer', new PrimitiveMapping()) as Id).toEqual(obj1b.id);
	expect(await client.lookupValue(rel.id, 7.32, 'float', new PrimitiveMapping()) as Id).toEqual(obj1a.id);
	expect(await client.lookupValue(rel.id, -7.32, 'float', new PrimitiveMapping()) as Id).toEqual(obj1b.id);
	expect(await client.lookupValue(rel.id, true, 'boolean', new PrimitiveMapping()) as Id).toEqual(obj1a.id);
	expect(await client.lookupValue(rel.id, false, 'boolean', new PrimitiveMapping()) as Id).toEqual(obj1b.id);
});

test('ResourceSchema object fields work', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);

	const obj1 = await client.createObject(universe.resolve('base.object/')!, 'obj1') as Obj;
	const obj1a = await client.createObject(obj1.id, 'obj1') as Obj;
	await client.setData(obj1a.id, 12, 'integer');

	const schema = new ResourceSchema();
	schema.addField('idHex', 'id', 'hex');
	schema.addField('idBase64', 'id', 'base64');
	schema.addField('name', 'name', 'string');
	schema.addField('value', 'data', 'integer');
	schema.addField('valueBase64', 'data', 'base64');

	const result = await client.getResourceInstance(new ResourceInstance(obj1a.id, schema)) as ResourceValue;
	expect(result['idHex']).toEqual(obj1a.id);
	expect(result['idBase64']).toBeTruthy();
	expect(result['name']).toEqual('obj1');
	expect(result['value']).toEqual(12);
	expect(result['valueBase64']).toBeTruthy();

	const results = await client.getResourceSpecials(new ResourceSpecials(obj1.id, schema)) as ResourceValue[];
	expect(results).toHaveLength(1);
	expect(results[0]).toEqual(result);
});

test('ResourceSchema relation fields work', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);

	const obj1 = await client.createObject(universe.resolve('base.object/')!, 'obj1') as Obj;
	const obj2 = await client.createObject(universe.resolve('base.object/')!, 'obj2') as Obj;
	const rel = await client.createRelation(obj1.id, obj2.id, universe.resolve('base.object#relation/')!) as Obj;

	const obj1a = await client.createObject(obj1.id, 'obj1a') as Obj;
	const obj2a = await client.createObject(obj2.id, 'obj2a') as Obj;
	await client.setData(obj2a.id, true, 'boolean');

	await client.createRelation(obj1a.id, obj2a.id, rel.id);

	const schema = new ResourceSchema();
	schema.addField('myId', 'id', 'hex');
	schema.addField('idHex', 'id', 'hex', rel.id, new PrimitiveMapping());
	schema.addField('name', 'name', 'string', rel.id, new PrimitiveMapping());
	schema.addField('value', 'data', 'boolean', rel.id, new PrimitiveMapping());

	const result = await client.getResourceInstance(new ResourceInstance(obj1a.id, schema)) as ResourceValue;
	expect(result['myId']).toEqual(obj1a.id);
	expect(result['idHex']).toEqual(obj2a.id);
	expect(result['name']).toEqual('obj2a');
	expect(result['value']).toEqual(true);

	const results = await client.getResourceSpecials(new ResourceSpecials(obj1.id, schema)) as ResourceValue[];
	expect(results).toHaveLength(1);
	expect(results[0]).toEqual(result);
});

test('ResourceSchema filtering and ordering works', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);

	const obj1 = await client.createObject(universe.resolve('base.object/')!, 'obj1') as Obj;

	for (let i = 0; i < 10; i++) {
		const obj1i = await client.createObject(obj1.id, `obji${i}`) as Obj;
		await client.setData(obj1i.id, i, 'integer');
	}

	const schema = new ResourceSchema();
	schema.addField('id', 'id', 'hex');
	schema.addField('val', 'data', 'integer');
	const results = await client.getResourceSpecials(
		new ResourceSpecials(obj1.id, schema)
			.addFilter('val', 5, 'gt')
			.addOrder('val')) as ResourceValue[];

	const resultsReturned = Array.from(results.filter((a) => a['val']! > 5));
	results.sort((a, b) => {
		if (a['val']! < b['val']!) {
			return -1;
		}
		return 1;
	});

	expect(results).toEqual(resultsReturned);
});

test('ResourceSchema writing works', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);

	const obj1 = await client.createObject(universe.resolve('base.object/')!, 'obj1') as Obj;

	const schema = new ResourceSchema();
	schema.addField('name', 'name', 'string');
	schema.addField('value', 'data', 'integer');

	const values = [
		{
			'name': 'test1',
			'value': 1,
		},
		{
			'name': 'test2',
			'value': 2,
		},
	];
	await client.putResourceSpecials(new ResourceSpecials(obj1.id, schema), values);

	const results = await client.getResourceSpecials(new ResourceSpecials(obj1.id, schema).addOrder('value')) as ResourceValue[];
	expect(results).toEqual(values);
});

test('basic getNode works', async () => {
	const universe = (await loadUniverseFromApi(globalUniverse, globalApiUrl))!;
	const client = newSystemClient(globalSystemUrl);
	client.layerProfile = readLayerProfile(layerProfileStr);
	const obj = await client.createObject(resolve(universe, 'base.object/')!, 'test123') as Obj;
	const objName = await client.getNode({
		type: 'context',
		context: {
			context: {
				environment: {
					type: 'primitive',
				},
				value: obj.id,
			},
			node: {
				type: 'value',
				value: {
					field: 'name',
					format: 'string',
				}
			}
		}
	});
	expect(objName).toEqual('test123');
});