import { IRecord, IRecordValue } from '../interfaces/record';
import { INerScoreRow } from '../interfaces/metadata';
import { IRelationType, IRelation } from '../interfaces/relation';

/*
 * Receive one node  of neo4j and transform it no IRecord object
 */

export function neo4jObjectToRecord (neo4jRecord: any): IRecord|string {

    let record: IRecord = {id: '', values: []};
    let property: string;
    //I must be sure that neo4jRecord has a correct structure
    try {

        // Change structure neo4jObject to IRecord
        for (property in neo4jRecord) {

            if (property === 'id') {

                record.id = neo4jRecord[property];

            }else {

                let recordValue: IRecordValue = {} as IRecordValue;

                recordValue.key = property;
                recordValue.value = neo4jRecord[property];
                record.values.push(recordValue);

            }

        }

        return record

    }catch(e) {

        return e;

    }

}

/*
 * Transform neo4j Relations types in IRelationsTypes
 */

export function neo4jRelationsTypesToIRelationTypes (neo4jRelation: any): IRelationType|string {

    let relationType: IRelationType = {} as IRelationType;

    try {

        relationType.name = neo4jRelation.name;
        relationType.id = neo4jRelation.id;
        relationType.symmetric = neo4jRelation.symmetric;
        relationType.transitive = neo4jRelation.transitive;
        relationType.reflexive = neo4jRelation.reflexive;

    }catch (e) {

        return e;

    }

    return relationType;

}

    /*
     * Transform neo4j Relations in IRelations
     */


export async function neo4jRelationsToIRelation (neo4jRelation: any): Promise<IRelation|string> {

    let relation: IRelation = {} as IRelation; // row[0]
    let startNode: IRecord|string|undefined = ''; // row[1]
    let endNode: IRecord|string|undefined = ''; // row[2]
    let relationType: IRelationType|string = '';

    // row[x] must be null, because i use OPTIONAL MATCH, must check it. 
    if (neo4jRelation.row[0] !== null &&
        neo4jRelation.row[1] !== null && 
        neo4jRelation.row[2] !== null) {

            // Conver Relation Type
            relationType = neo4jRelationsTypesToIRelationTypes (neo4jRelation.row[0]);
            // Conver Start and End node
            endNode = await neo4jObjectToRecord (neo4jRelation.row[2]);
            startNode = await  neo4jObjectToRecord (neo4jRelation.row[1]);

    }

    let promiseRelation: Promise<IRelation|string> = 

    new Promise(

        (resolve: (types: IRelation) => void , reject: (str: string) => void ) => {

        if (typeof relationType !== 'string' && typeof endNode !== 'string' && typeof startNode !== 'string') {

            relation.type = relationType as IRelationType;
            relation.end = endNode as IRecord;
            relation.start = startNode as IRecord;
            resolve(relation);

        }else {

            reject('Does not exist relations.');

        }                 

    });

    return promiseRelation;

}


/*
 * Transfor NerScore nodes in Array<INerScoreRow>
 */

export function neo4jMetadataToINerScoreRow (metadata: any):  Array<INerScoreRow> {

    let array: Array<INerScoreRow> = [];
    let property: any;
    let nerScoreArray: any = JSON.parse(metadata.nerScore);

    for (property of nerScoreArray) {

            let nerScore: INerScoreRow = {key: '', value: {LOCATION: 0, PERSON: 0, ORGANIZATION: 0}};
            nerScore.key = property.key;
            nerScore.value = property.value;
            array.push(nerScore);

    }

    return array;

}