import { copy } from './common';
import DefinitionPattern from './DefinitionPattern';
import sparqljs from 'sparqljs';
import attributeGetter from '../SparqlAttribute/getter';

// We pass json pointers as references
function values(rootReference: string, definition: DefinitionPattern, json_pointers: string[], values: Array<string | number>[]) {
    // We assume that every n-uplet of the values array match the size of bindings
    if (values.some((n_uplet) => {
        return n_uplet.length !== json_pointers.length;
    })) {
        throw 'At least one N-uplet doesn\'t match the bindings[] length'
    }
    let incremented_definition = copy(definition);

    let variableBindings = json_pointers.map((pointer) => {
        let attribute = attributeGetter(rootReference, pointer).attribute;
        return '?' + attribute.name
    })
    let dictArray: {[key: string]: string}[] = [];
    values.forEach((tupleValues) => {
        let element: { [key: string]: string } = {}
        tupleValues.forEach((value, index) => {
            element[variableBindings[index]] = <string>value;
        })
        dictArray.push(element);
    })
    let _values = {
        type: 'values',
        values: dictArray
    }
    // Find the relevant definition in case of nesting
    let nestedPath = attributeGetter(rootReference, json_pointers[0]).nestedPath;
    let pointerToDefinition = incremented_definition;
    nestedPath.forEach((path) => {
        pointerToDefinition = pointerToDefinition.subQuery[path];
    });
    // console.log(_values);
    (<sparqljs.Pattern[]>pointerToDefinition.query.where).push(<sparqljs.ValuesPattern>_values);
    return incremented_definition;
}

export default values;