export function addAggregateSupport(addressSpace: AddressSpace) {
    const aggregateConfigurationType = addressSpace.getNamespace(0).findObjectType("AggregateConfigurationType");
    if (!aggregateConfigurationType) {
        throw new Error("addressSpace do not expose AggregateConfigurationType");
    }

    const aggregateFunctionType = addressSpace.getNamespace(0).findObjectType("AggregateFunctionType");
    if (!aggregateFunctionType) {
        throw new Error("addressSpace do not expose AggregateFunctionType");
    }

    const serverObject = addressSpace.rootFolder.objects.getFolderElementByName("Server");
    if (!serverObject) {
        throw new Error("addressSpace do not expose a ServerObject");
    }
    // xx serverObject.

    const serverCapabilities = serverObject.getChildByName("ServerCapabilities")! as UAServerCapabilities;

    // Let see if HistoryServer Capabilities object exists
    let historyServerCapabilities = serverCapabilities.getChildByName("HistoryServerCapabilities");
    if (!historyServerCapabilities) {
        historyServerCapabilities = createHistoryServerCapabilities(addressSpace, serverCapabilities);
    }

    setHistoricalServerCapabilities(historyServerCapabilities, historicalCapabilitiesDefaultProperties);

    addAggregateFunctionSupport(addressSpace, AggregateFunction.Interpolative);
    addAggregateFunctionSupport(addressSpace, AggregateFunction.Minimum);
    addAggregateFunctionSupport(addressSpace, AggregateFunction.Maximum);

}

 before(async () => {
     const xmlFiles = [
         nodesets.standard
     ];
     addressSpace = AddressSpace.create();
     await generateAddressSpace(addressSpace, xmlFiles);
     addressSpace.registerNamespace("Own");
 });

    before(async () => {
        await initializeHelpers();

        await applicationGroup.initialize();
        await userTokenGroup.initialize();

        addressSpace = AddressSpace.create();
        await generateAddressSpace(addressSpace, xmlFiles);
        addressSpace.registerNamespace("Private");

    });

export function createHistorian1(addressSpace: AddressSpace): UAVariable {

    const node = addressSpace.getOwnNamespace().addVariable({
        browseName: "History1",
        dataType: "Float"
    });

    const options = {

        historian: undefined,
        percentDataBad: 100,
        percentDataGood: 100,  // Therefore if all values are Good then the
        // quality will be Good, or if all values are Bad then the quality will be Bad, but if there is
        // some Good and some Bad then the quality will be Uncertain
        stepped: false, // Therefore SlopedInterpolation is used between data points.
        treatUncertainAsBad: false, // Therefore Uncertain values are included in Aggregate calls.
        useSlopedExtrapolation: false, // Therefore SteppedExtrapolation is used at end boundary conditions.
    };

    addressSpace.installHistoricalDataNode(node, options);

    installAggregateConfigurationOptions(node, options);

    // 12:00:00 - BadNoData First archive entry, Point created
    addHistory(node, "12:00:00", null, StatusCodes.BadNoData);
    // 12:00:10 10 Raw, Good
    addHistory(node, "12:00:10", 10, StatusCodes.Good);
    // 12:00:20 20 Raw, Good
    addHistory(node, "12:00:20", 20, StatusCodes.Good);
    // 12:00:30 30 Raw, Good
    addHistory(node, "12:00:30", 30, StatusCodes.Good);
    // 12:00:40 40 Raw, Bad         ANNOTATION: Operator 1
    //                                          Jan-02-2012 8:00:00 Scan failed, Bad data entered
    //                              ANNOTATION:
    //                                          Jan-04-2012 7:10:00 Value cannot be verified
    addHistory(node, "12:00:40", 40, StatusCodes.Bad);
    // 12:00:50 50 Raw, Good        ANNOTATION: Engineer1
    //                                          Jan-04-2012 7:00:00 Scanner fixed
    addHistory(node, "12:00:50", 50, StatusCodes.Good);
    // 12:01:00 60 Raw, Good
    addHistory(node, "12:01:00", 60, StatusCodes.Good);
    // 12:01:10 70 Raw, Uncertain   ANNOTATION: Technician_1
    //                                          Jan-02-2012 8:00:00 Value flagged as questionable
    addHistory(node, "12:01:10", 70, StatusCodes.Uncertain);
    // 12:01:20 80 Raw, Good
    addHistory(node, "12:01:20", 80, StatusCodes.Good);
    // 12:01:30 90 Raw, Good
    addHistory(node, "12:01:30", 90, StatusCodes.Good);

    return node;

}

        generateAddressSpace(addressSpace, namespaces, (err?: Error) => {

            const namespace = addressSpace.registerNamespace("PRIVATENAMESPACE");
            namespace.index.should.eql(1);
            should.exist(addressSpace.getOwnNamespace());

            addAggregateSupport(addressSpace);

            h1 = createHistorian1(addressSpace);
            h2 = createHistorian2(addressSpace);
            h3 = createHistorian3(addressSpace);
            h4 = createHistorian4(addressSpace);

            done(err!);
        });

function addAggregateFunctionSupport(
  addressSpace: AddressSpace, functionName: number): void {
    if (!functionName) {
        throw new Error("Invalid function name");
    }

    const serverCapabilities = addressSpace.rootFolder.objects.server.serverCapabilities;

    /* istanbul ignore next */
    if (!serverCapabilities.historyServerCapabilities) {
        throw new Error("missing serverCapabilities.historyServerCapabilities");
    }

    const aggregateFunctions = serverCapabilities.aggregateFunctions;

    const aggregateFunctionsInHist = serverCapabilities.historyServerCapabilities.aggregateFunctions;

    const functionNodeId = makeNodeId(functionName);
    const functionNode = addressSpace.getNamespace(0).findNode(functionNodeId);
    if (!functionNode) {
        throw new Error("Cannot find node " + functionName + " in addressSpace");
    }
    aggregateFunctions.addReference({
        nodeId: functionNode.nodeId,
        referenceType: "Organizes"
    });
    aggregateFunctionsInHist.addReference({
        nodeId: functionNode.nodeId,
        referenceType: "Organizes"
    });
}

    before(async () => {

        addressSpace = await getMiniAddressSpace();

        const group = addressSpace.getOwnNamespace().addObject({
            browseName: "Group",
            organizedBy: addressSpace.rootFolder.objects
        });

        for (let i = 0; i < 10; i++) {
            addressSpace.getOwnNamespace().addObject({
                browseName: "Object" + i,
                organizedBy: group
            });
        }
        groupNodeId = group.nodeId;
    });

    beforeEach((done) => {

        addressSpace = AddressSpace.create();

        const namespaces: string[] = [
            nodesets.standard_nodeset_file
        ];
        generateAddressSpace(addressSpace, namespaces, (err?: Error) => {
            done(err);
        });
    });

export function installCertificateExpirationAlarm(addressSpace: AddressSpace) {

    debugLog("installCertificateExpirationAlarm");

    const server = addressSpace.rootFolder.objects.server;

    const namespace = addressSpace.getOwnNamespace();

    const certificateExpirationAlarmType = addressSpace.findEventType("CertificateExpirationAlarmType");

    const options = {
        browseName: "ServerCertificateAlarm",
        conditionSource: null,
        eventSourceOf: server,
        inputNode: NodeId.nullNodeId,
        normalState: NodeId.nullNodeId,
    };
    const data = {};
    const alarm = UACertificateExpirationAlarm.instantiate(namespace, options, data);
    // const alarm = namespace.instantiateOffNormalAlarm({) as UACertificateExpirationAlarm;
    alarm.currentBranch().setRetain(true);
    alarm.activeState.setValue(true);
}

    before(async () => {
        const namespace = addressSpace.getOwnNamespace();

        const fileType = addressSpace.findObjectType("FileType")!;
        should.exists(fileType);

        // install file 1
        opcuaFile = fileType.instantiate({
            browseName: "FileTransferObj",
            organizedBy: addressSpace.rootFolder.objects.server
        }) as UAFileType;

        const tempFolder = await promisify(fs.mkdtemp)(path.join(os.tmpdir(), "test-"));

        const filename = path.join(tempFolder, "tempFile1.txt");
        await promisify(fs.writeFile)(filename, "content", "utf8");

        installFileType(opcuaFile, { filename });

        // install file 2
        opcuaFile2 = fileType.instantiate({
            browseName: "FileTransferObj2",
            organizedBy: addressSpace.rootFolder.objects.server
        }) as UAFileType;
        const filename2 = path.join(tempFolder, "tempFile2.txt");
        installFileType(opcuaFile2, { filename: filename2 });

    });