import Srl from "./Srl";
import TupleMap from "ts-json-key-map";

type TokensType = string[];
export type NodesType  = [
    number, // begin
    number, // end (exclusive)
    string  // role label
    ][];
export type EdgesType = [
    number[], // tails
    [number]  // a single head
    ][];

function findNode(nodes:NodesType, begin:number, end:number, label:string):number {
    for(let i=0; i<nodes.length; i++) {
        const node = nodes[i];
        if(node[0] === begin && node[1] === end && node[2] === label) return i;
    }
    return -1;
}

interface Meta {
    frame_label_set_name: string | undefined
}

export default class SrlJsonFormat {
    meta?: Meta;
    tokens: TokensType;
    nodes: NodesType;
    edges: EdgesType;

    constructor(tokens: TokensType, nodes: NodesType, edges: EdgesType, meta?: Meta) {
        this.tokens = tokens;
        this.nodes = nodes;
        this.edges = edges;
        this.meta = meta;
    }


    static parseSrl(srl:Srl):SrlJsonFormat {
        return SrlJsonFormat.parseSrlWithMap(srl).json;
    }


    /**
     * construct an SrlJson from Srl with extra information
     * in Srl format, a role is identified by <frameIndex>,<roleIndex>
     * in Hypergraph format, a role is identified by <nodeIndex>
     * so this function returns the relationship between the two identifiers
     */
    static parseSrlWithMap(srl:Srl):{
        json:SrlJsonFormat,
        srlFrameRoleIndex_jsonNodeIndex:TupleMap<[number,number],number>
    } {
        const nodes:NodesType = [[0,srl.tokens.length,'&GOAL;']];
        const edges:EdgesType = [[[],[0]]];
        const predIndexes = edges[0][0]; // insert predicate indexes here later on
        const tupleMap = new TupleMap<[number,number],number>();
        for(let frameIndex=0; frameIndex<srl.frames.length; frameIndex++) {
            const frame = srl.frames[frameIndex];
            let heads:[number] = [0];
            const tails = [];
            for(let roleIndex=0; roleIndex<frame.roles.length; roleIndex++) {
                const role = frame.roles[roleIndex];

                // check if the labeled span exists
                let index = findNode(nodes, role.beginTokenIndex, role.beginTokenIndex+role.length, role.name);
                if(index < 0) {

                    // if this labeled span doesn't exist, create a new one
                    index = nodes.length;
                    nodes.push([role.beginTokenIndex, role.beginTokenIndex+role.length,role.name]);
                }
                tupleMap.set([frameIndex, roleIndex], index);

                if(role.isPredicate) {
                    heads = [index];
                    predIndexes.push(index);
                }
                else {

                    tails.push(index);
                }
            }
            edges.push([tails, heads]);
        }
        return {
            json: new SrlJsonFormat(srl.tokens, nodes, edges, {frame_label_set_name: srl.frameLabelSetName}),
            srlFrameRoleIndex_jsonNodeIndex: tupleMap
        }
    }

}