'use strict';

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

export default class DB2SchemaGraph {

    buildEdges = async (foreignKeyReferences) => {
        
        let serializedLink = {}
        let serializedLinks
        let edgesJson = { edges: {} }
        let edgeName: string; //foreign key column name
        let sourceNode: string; //foreign key table name
        let targetNode: string;  //primary key table name

        //console.log(JSON.stringify(foreignKeyReferences, null, 3))

        let graph = new Graph();
        let tables = foreignKeyReferences
        for (let i = 0; i < tables.length; i++) {
            let references = tables[i]

            sourceNode = tables[i].FOREIGN_TABLE;
            sourceNode = sourceNode.split('.')[1]
            targetNode = tables[i].PRIMARY_TABLE;
            targetNode = targetNode.split('.')[1] 
            edgeName = tables[i].FK_COLUMN_NAME;

            //console.log(sourceNode)
            graph.addNode(sourceNode) //original table
            graph.addNode(targetNode) //foreign table
            graph.addEdge(sourceNode, targetNode)
            
            serializedLink = graph.serializeLinks(edgeName)
            //console.log(serializedLink)
            //console.log(serializedLink[edgeName])

            if(edgesJson.edges.hasOwnProperty(sourceNode)) {
                edgesJson.edges[sourceNode] = edgesJson.edges[sourceNode].concat(serializedLink[edgeName]);
            } else {
                edgesJson.edges[sourceNode] = serializedLink[edgeName];
            }            
            graph = new Graph()
            serializedLink = {}
        }

        //console.log(JSON.stringify(edgesJson,null,3))

        //TODO update the edges name
        //update the edgeName to be the right one because if multiple elements in a table, then all the edgeName are the same
        //the edgename in an array should be different
        
        return edgesJson
    }

    //to achieve the bidirectional relationship so we need to create edges that comes from target to source
    generateBidirectionalEdges = (edges) => {

        //get the table name
        let tables = Object.keys(edges['edges'])
        //console.log(tables)

        let _tables = {}
        let _references = []

        for (let i = 0; i < tables.length; i++) {

            let table = tables[i]
            let references = edges['edges'][table]

            //console.log(references)
            let source
            let target

            for (let j = 0; j < references.length; j++) {
                let reference = references[j]
                let _reference = { ...reference }

                //generate the reverse edges
                source = reference['source']
                let tmp = source
                target = reference['target']
                _reference.source = target
                _reference.target = tmp

                _references.push(_reference)
            }
        }

        //create a json with arrays group by the tablename
        const property = "source"
        const reversedEdges = _.groupBy(_references, property);

        //combine multiple arrays with the same key into one array
        const bidirectionalEdges = jsonMerger.mergeObjects([edges['edges'], reversedEdges], {defaultArrayMergeOperation: "concat"})
        //console.log(JSON.stringify(bidirectionalEdges,null,3))

        return bidirectionalEdges
    }
}

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

const DB2Configuration = {
    HOSTNAME: 'localhost',
    PORT: '50000',
    USER: 'db2inst1',
    PASSWORD: 'pentatech',
    DATABASE: 'SAMPLE',
    SCHEMA: 'DB2INST1'
};


async function run() {

    const db2SchemaGraph = new DB2SchemaGraph();

    const db2DatabaseDiscovery = new DB2DatabaseDiscovery(DB2Configuration);
    let extractedSchema = await db2DatabaseDiscovery.extractDB2Schema();
    //console.log(JSON.stringify(extractedSchema, null , 3));

    let foreignKeys = await db2DatabaseDiscovery.getForeignKeyReferences(extractedSchema)
    //console.log(foreignKeys);

    //build the edges
    let edges = await db2SchemaGraph.buildEdges(foreignKeys)
    //console.log(JSON.stringify(edges,null,3))

    //get the reverse edges
    let bidirectionalEdges = await db2SchemaGraph.generateBidirectionalEdges(edges)
    //console.log(JSON.stringify(bidirectionalEdges, null,3))

    extractedSchema = schema.buildDB2Schema(extractedSchema, DB2Configuration.DATABASE);
    //console.log(JSON.stringify(extractedSchema, null , 3));

    let nodesGraph = {
        // nodes: [],
        // edges: {}
    };

    nodesGraph['nodes'] = extractedSchema;
    nodesGraph['edges'] = bidirectionalEdges;

    console.log(JSON.stringify(nodesGraph, null , 3));
}

//run()