'use strict';

const jsonMerger = require("json-merger");  //https://github.com/boschni/json-merger
// @ts-ignore
import Converter from './utils/Converter';
const Graph = require("./utils/graph-data-structure");

const _ = require('underscore');

export default class MongoDBSchemaGraph {

    //Get the array of same table names (edges) from two nodes
    getEdges = (node1, node2) => {
        let edgeNames = node1.filter(function (val) {
            return node2.indexOf(val) != -1;
        });

        return edgeNames;
    }

    //Get unique edges names from the multiple arrays of edges
    //Purpose: so one edge as the key can have nested target and source
    getUniqueEdgeNames = (edgesAndNodesCombined: Array<any>) => {
        let edgeNames = [];
        for(let i=0; i<edgesAndNodesCombined.length; i++) {
            edgeNames = _.union(edgeNames, edgesAndNodesCombined[i][0]);
        }
        return edgeNames;
    }

    //Get the array of the same edges found from two nodes
    //return the array of edges as well as the two nodes
    getEdgesAndNodes = (dbTableWithColObject) => {
        let edgesAndNodes = [];
        let edgesAndNodesCombined = [];
        let edgeNames = [];
        let colNamesTableX = [];
        let colNamesTableY = [];
        let tableNames = [];

        let dbNames = Object.keys(dbTableWithColObject);
        //console.log(dbNames);
        for (let dbName of dbNames) {
            tableNames = Object.keys(dbTableWithColObject[dbName]);
            
            for (let i = 0; i < tableNames.length; i++) {
                for (let j = 0; j < (tableNames.length); j++) {
                    if (i == j) continue;
                    else {
                        colNamesTableX = Object.keys(dbTableWithColObject[dbName][tableNames[i]]);
                        colNamesTableX = _.without(colNamesTableX, '_id', '__v');

                        colNamesTableY = Object.keys(dbTableWithColObject[dbName][tableNames[j]]);
                        colNamesTableY = _.without(colNamesTableY, '_id', '__v');

                        edgeNames = this.getEdges(colNamesTableX, colNamesTableY);
                        if (Array.isArray(edgeNames) && edgeNames.length) {
                            edgesAndNodes.push(edgeNames);
                            edgesAndNodes.push(tableNames[i]);
                            edgesAndNodes.push(tableNames[j]);
                            edgesAndNodesCombined.push(edgesAndNodes);
                            edgesAndNodes = [];
                            //console.log(edgeNames + "\t" + tableNames[i] + "\t"  + tableNames[j] );
                        }
                    }
                }
            }
        }
        return edgesAndNodesCombined;
    }

    //Get edges with source node and target node in Json
    getEdgesGraph = (uniqueEdgeNames:Array<any>, edgesAndNodesCombined: Array<any>) => {

        let serializedLinks;
        let edgesJson = {edges: {}};
        let sourceNode;
        let targetNode;
        let edgeName;

        let graph = new Graph();

        for (let i=0; i<uniqueEdgeNames.length; i++) {
            for(let j=0; j<edgesAndNodesCombined.length; j++) {
                if(edgesAndNodesCombined[j][0].includes(uniqueEdgeNames[i])) {
                    edgeName = uniqueEdgeNames[i];
                    sourceNode = edgesAndNodesCombined[j][1];
                    targetNode = edgesAndNodesCombined[j][2];

                    graph.addNode(sourceNode);
                    graph.addNode(targetNode);
                    graph.addEdge(sourceNode, targetNode);
                    //console.log(uniqueEdgeNames[i] + "\t" + edgesAndNodesCombined[j] )
                }
            }
            serializedLinks = graph.serializeLinks(edgeName);
            edgesJson.edges[edgeName] = serializedLinks[edgeName];
            graph = new Graph();

        }
        return edgesJson;
    }
}

/*********************************** Main Entry Point ************************************************/

/*
const object6=
    {
        questionnaires: {
            _id: {primaryKey: true, type: 'Object', required: true},
            Question_1: {type: 'string', required: true},
            Question_2: {type: 'string', required: true},
            Question_3: {type: 'string', required: true},
            Question_4: {type: 'string', required: true},
            Question_5: {type: 'string', required: true},
            Question_6: {type: 'string', required: true},
            Question_7: {type: 'string', required: true},
            Question_8: {type: 'string', required: true},
            __v: {type: 'number', required: true}
        },
        performanceratings: {
            _id: {primaryKey: true, type: 'Object', required: true},
            ProfileID: {type: 'string', required: true},
            Ratings: {type: 'string', required: true},
            RatingsDate: {type: 'Date', required: true},
            Endorser: {key: true, type: 'string', required: true},
            OverallScore: {type: 'number', required: true},
            Confidence: {type: 'number', required: true},
            Context: {type: 'string', required: true},
            Relationship: {type: 'string', required: true},
            __v: {type: 'number', required: true}
        },
        profiles: {
            _id: {primaryKey: true, type: 'Object', required: true},
            Meta_Profile: {type: 'Array', required: true},
            ProfileID: {type: 'string', required: true},
            FirstName: {type: 'string', required: true},
            FamilyName: {type: 'string', required: true},
            Email: {type: 'string', required: true},
            Gender: {type: 'string', required: true},
            Phone: {key: true, type: 'string', required: true},
            Age: {type: 'number', required: true},
            Locations: {type: 'string', required: true},
            Education: {type: 'string', required: true},
            __v: {type: 'number', required: true}
        },
        workhistories: {
            _id: {primaryKey: true, type: 'Object', required: true},
            ProfileID: {type: 'string', required: true},
            JobTitle: {type: 'string', required: true},
            JobDescription: {type: 'string', required: true},
            CompanyName: {type: 'string', required: true},
            CompanyContact: {key: true, type: 'string', required: true},
            Position: {key: true, type: 'string', required: true},
            StartDate: {type: 'Date', required: true},
            EndDate: {type: 'Date', required: true},
            Location: {type: 'string', required: true},
            Country: {type: 'string', required: true},
            __v: {type: 'number', required: true},
            Education: {type: 'string', required: true}
        },
        students: {
            _id: {type: 'number', required: true},
            name: {key: true, type: 'string', required: true},
            scores: {type: 'Array', required: true}
        },
        measurement: {
            _id: {primaryKey: true, type: 'Object', required: true},
            size: {type: 'Object', structure: [Object], required: true},
            body_type: {type: 'string', required: true}
        },
        grades: {
            _id: {primaryKey: true, type: 'Object', required: true},
            student_id: {type: 'number', required: true},
            class_id: {type: 'number', required: true},
            scores: {type: 'Array', required: true}
        }
    }


const mongoDBSchemaGraph = new MongoDBSchemaGraph();

let edgesAndNodesCombined = mongoDBSchemaGraph.getEdgesAndNodes(object6);
//console.log(edgesAndNodesCombined);

let uniqueEdgeNames = mongoDBSchemaGraph.getUniqueEdgeNames(edgesAndNodesCombined);
//console.log(uniqueEdgeNames);

let nodesGraph = { nodes: { } };
nodesGraph.nodes = object6;
//console.log(nodesGraph);

let edgesJson = mongoDBSchemaGraph.getEdgesGraph(uniqueEdgeNames,edgesAndNodesCombined);
//console.log(JSON.stringify(edgesJson,null,4));

let schemaGraph = jsonMerger.mergeObjects([nodesGraph, edgesJson]);
//console.log(JSON.stringify(schemaGraph,null,4));


//get the Ed version of the edge graph
const converter = new Converter();
let edEdgesGraph = converter.convertToEdEdgesGraph(uniqueEdgeNames, edgesJson);
//console.log(JSON.stringify(edEdgesGraph,null,4));

//to comply with Ed Schema Graph
let schemaEdGraph = jsonMerger.mergeObjects([nodesGraph, edEdgesGraph]);
console.log(JSON.stringify(schemaEdGraph,null,4));
*/