steelbreeze/state

import { Function } from '@steelbreeze/types';
import { State, Region, Instance, Visitor } from '.';

class JSONNode {
    readonly name: String;

    public constructor(element: Region | State) {
        this.name = element.name;
    }
}

class JSONState extends JSONNode {
    deferredEventPool: Array<any> | undefined;
    readonly children: Array<JSONRegion> = [];

    constructor(state: State) {
        super(state);
    }
}

class JSONRegion extends JSONNode {
    public readonly children: Array<JSONState> = [];

    constructor(region: Region, public readonly activeState: string | undefined) {
        super(region);
    }
}

export class JSONSerializer implements Visitor {
    public root: JSONState | undefined;

    private stateMap: Map<State, JSONState> = new Map<State, JSONState>();
    private regionMap: Map<Region, JSONRegion> = new Map<Region, JSONRegion>();

    public constructor(private readonly instance: Instance, private readonly deferedEventSerializer: Function<any, any> | undefined = undefined) {
    }

    visitPseudoState() {
    }

    visitPseudoStateTail() {
    }

    visitState(state: State) {
        const jsonState = new JSONState(state);

        this.stateMap.set(state, jsonState);

        if (state.parent) {
            const parent = this.regionMap.get(state.parent);

            if (parent) {
                parent.children.push(jsonState);
            }
        } else {
            this.root = jsonState;
        }
    }

    visitStateTail() {
    }

    visitRegion(region: Region) {
        const lastKnownState = this.instance.get(region);
        const jsonRegion = new JSONRegion(region, lastKnownState ? lastKnownState.name : undefined);

        this.regionMap.set(region, jsonRegion);

        const parent = this.stateMap.get(region.parent);

        if (parent) {
            parent.children.push(jsonRegion);
        }
    }

    visitRegionTail() {
    }

    public toString(): string {
        if (this.instance.deferredEventPool.length && this.deferedEventSerializer && this.root) {
            this.root.deferredEventPool = this.instance.deferredEventPool.map(this.deferedEventSerializer);
        }

        return JSON.stringify(this.root);
    }
}