/*
 * Copyright (c) 2012-2019 The ANTLR Project. All rights reserved.
 * Use of this file is governed by the BSD 3-clause license that
 * can be found in the LICENSE.txt file in the project root.
 */

module antlr.v4.runtime.atn.ArrayPredictionContext;

import antlr.v4.runtime.atn.PredictionContext;
import antlr.v4.runtime.atn.SingletonPredictionContext;
import std.array;
import std.container.array;
import std.conv;
import std.stdio;

/**
 * Array of prediction contexts
 */
class ArrayPredictionContext : PredictionContext
{

    /**
     * Parent can be null only if full ctx mode and we make an array
     * from {@link #EMPTY} and non-empty. We merge {@link #EMPTY} by using null parent and
     * returnState == {@link #EMPTY_RETURN_STATE}.
     */
    public PredictionContext[] parents;

    /**
     * Sorted for merge, no duplicates; if present,
     * {@link #EMPTY_RETURN_STATE} is always last.
     * @uml
     * @final
     */
    public int[] returnStates;

    public this(SingletonPredictionContext a)
    {
        PredictionContext[] parents;
        parents ~= a.parent;
        int[] returnStates;
        returnStates ~= a.returnState;
        this(parents, returnStates);
    }

    public this(PredictionContext[] parents, int[] returnStates)
    {
        super(calculateHashCode(parents, returnStates)); // caching the hash code
        assert(parents && parents.length > 0);
        assert(returnStates && returnStates.length > 0);
        debug {
            import std.stdio;
            writefln("CREATE ARRAY: %s, %s", parents, returnStates);
        }
        this.parents = parents;
        this.returnStates = returnStates;
    }

    /**
     * @uml
     * @override
     */
    public override bool isEmpty()
    {
        // since EMPTY_RETURN_STATE can only appear in the last position, we
        // don't need to verify that size==1
        return returnStates[0] == EMPTY_RETURN_STATE;
    }

    /**
     * @uml
     * @override
     */
    public override size_t size()
    {
        return returnStates.length;
    }

    /**
     * @uml
     * @override
     */
    public override PredictionContext getParent(int index)
    {
        return parents[index];
    }

    /**
     * @uml
     * @override
     */
    public override int getReturnState(int index)
    {
        return returnStates[index];
    }

    /**
     * @uml
     * @override
     */
    public override bool opEquals(Object o)
    {
        if (!cast(ArrayPredictionContext)o) {
            return false;
        }

        if (this.toHash != o.toHash) {
            return false; // can't be same if hash is different
        }
        auto aObject = cast(ArrayPredictionContext)o;
        import std.algorithm.comparison : equal;
        return equal(parents, aObject.parents) &&
            equal(returnStates, aObject.returnStates);
    }

    /**
     * @uml
     * @override
     */
    public override string toString()
    {
        if (isEmpty)
            return "[]";
        string[] buf;
        foreach (i, el; returnStates) {
            if (el == EMPTY_RETURN_STATE) {
                buf ~= "$";
                continue;
            }
            buf ~= to!string(el);
            if (parents[i]) {
                buf ~= " " ~ parents[i].toString;
            }
            else {
                buf ~= "null";
            }
        }
        return "[" ~ join(buf, ", ") ~ "]";
    }

}

version (AntlrUnittest)
{
    import dshould;

    @("Empty")
    unittest
    {
        import antlr.v4.runtime.atn.EmptyPredictionContext;

        auto spc = new EmptyPredictionContext;
        auto apc = new ArrayPredictionContext(spc);
        ArrayPredictionContext apcp;
        apc.toString.should.equal("[]");
        apc.size.should.equal(1);
        apc.isEmpty.should.equal(true);
        static if (size_t.sizeof == 4)
            apc.toHash.should.equal(786443632U);
        else
            apc.toHash.should.equal(6723470047294944096UL);
        apc.getParent(0).should.be(null);
        apc.getReturnState(0).should.equal(PredictionContext.EMPTY_RETURN_STATE);
        auto apc1 = new ArrayPredictionContext(spc);
        apcp = apc;
        apc.should.equal(apcp);
        class A {}
        auto apc2 = new A;
        apc.should.not.equal(apc2);
        apc.should.equal(apc1);
    }

    @("Flat")
    unittest
    {
        import antlr.v4.runtime.atn.EmptyPredictionContext;

        auto spc = new EmptyPredictionContext;
        auto apc = new ArrayPredictionContext(spc);
        apc.returnStates = 12 ~ apc.returnStates;
        apc.toString.should.equal("[12, null, $]");
        apc.size.should.equal(2);
        apc.isEmpty.should.equal(false);
        apc.getParent(0).should.be(null);
        static if (size_t.sizeof == 4)
            apc.toHash.should.equal(786443632U);
        else
            apc.toHash.should.equal(6723470047294944096UL);
        static if (size_t.sizeof == 4)
            apc.calculateHashCode(apc.getParent(0), apc.getReturnState(0))
                .should.equal(182986417U);
        else
            apc.calculateHashCode(apc.getParent(0), apc.getReturnState(0))
                .should.equal(4292457832056041856UL);
        apc.getReturnState(0).should.equal(12);
        auto apc1 = new ArrayPredictionContext(spc);
        apc.should.not.equal(apc1);
    }

    @("Deep")
    unittest
    {
        import antlr.v4.runtime.atn.EmptyPredictionContext;

        auto spc = new EmptyPredictionContext;
        auto apc = new ArrayPredictionContext(spc);
        auto apc1 = new ArrayPredictionContext(spc);
        apc.returnStates = 12 ~ apc.returnStates;
        apc.toString.should.equal("[12, null, $]");
        apc.size.should.equal(2);
        apc.isEmpty.should.equal(false);
        apc.getParent(0).should.be(null);
        apc.getReturnState(0).should.equal(12);
        apc.parents[0] = apc1;
        auto apc2 = new ArrayPredictionContext(apc.parents, apc.returnStates);
        apc2.toString.should.equal("[12,  [], $]");
        apc.toString.should.equal("[12,  [], $]");
        apc.should.not.equal(apc2);
        apc2.parents = apc1 ~ apc2.parents;
        apc2.returnStates = 13 ~ apc2.returnStates;
        apc2.toString.should.equal("[13,  [], 12,  [], $]");
    }
}