private getValueCompletions()

in language-service/src/services/yamlCompletion.ts [301:378]
65 lines of code
31 McCabe index (conditional complexity)

    private getValueCompletions(schema: SchemaService.ResolvedSchema, doc: SingleYAMLDocument, node: Parser.ASTNode, offset: number, document: TextDocument, collector: CompletionsCollector, types: { [type: string]: boolean }): void {


        let offsetForSeparator = offset;
        let parentKey: string = null;

        if (node && (node.type === 'string' || node.type === 'number' || node.type === 'boolean')) {
            offsetForSeparator = node.end;
            node = node.parent;
        }

        if (node && node.type === 'null') {
            let nodeParent = node.parent;

			/*
			 * This is going to be an object for some reason and we need to find the property
			 * Its an issue with the null node
			 */
            if (nodeParent && nodeParent.type === "object") {
                for (let prop in nodeParent["properties"]) {
                    let currNode = nodeParent["properties"][prop];
                    if (currNode.key && currNode.key.location === node.location) {
                        node = currNode;
                    }
                }
            }
        }

        if (!node) {
            this.addSchemaValueCompletions(schema.schema, collector, types, "");
            return;
        }

        if ((node.type === 'property') && offset > (<Parser.PropertyASTNode>node).colonOffset) {
            let propertyNode = <Parser.PropertyASTNode>node;
            let valueNode = propertyNode.value;
            if (valueNode && offset > valueNode.end) {
                return; // we are past the value node
            }
            parentKey = propertyNode.key.value;
            node = node.parent;
        }

        let separatorAfter = this.evaluateSeparatorAfter(document, offsetForSeparator);
        if (node && (parentKey !== null || node.type === 'array')) {
            let matchingSchemas = doc.getMatchingSchemas(schema.schema);
            matchingSchemas.forEach(s => {
                if (s.node === node && !s.inverted && s.schema) {
                    if (s.schema.items) {
                        if (Array.isArray(s.schema.items)) {
                            let index = this.findItemAtOffset(node, document, offset);
                            if (index < s.schema.items.length) {
                                this.addSchemaValueCompletions(s.schema.items[index], collector, types, separatorAfter);
                            }
                        } else {
                            this.addSchemaValueCompletions(s.schema.items, collector, types, separatorAfter);
                        }
                    }
                    if (s.schema.properties) {
                        //console.log('property schema');
                        let propertySchema = s.schema.properties[parentKey];
                        if (propertySchema) {
                            this.addSchemaValueCompletions(propertySchema, collector, types, separatorAfter);
                        }
                    }
                }
            });
        }
        if (node) {
            if (types['boolean']) {
                this.addBooleanValueCompletion(true, collector, separatorAfter);
                this.addBooleanValueCompletion(false, collector, separatorAfter);
            }
            if (types['null']) {
                this.addNullValueCompletion(collector, separatorAfter);
            }
        }
    }