import java.util.Collection;

public class PartizanNimPosition extends cgsuite.AbstractShortGame
{
    private int[] leftSubtractionSet, rightSubtractionSet;
    private int heapSize;

    public PartizanNimPosition(int[] leftSubtractionSet, int[] rightSubtractionSet, int heapSize)
    {
        this.leftSubtractionSet = (int[]) leftSubtractionSet.clone();
        this.rightSubtractionSet = (int[]) rightSubtractionSet.clone();
        this.heapSize = heapSize;
        java.util.Arrays.sort(this.leftSubtractionSet);
        java.util.Arrays.sort(this.rightSubtractionSet);
        if (this.leftSubtractionSet.length == 0 || this.rightSubtractionSet.length == 0 ||
            this.leftSubtractionSet[0] <= 0 || this.rightSubtractionSet[0] <= 0)
        {
            throw new IllegalArgumentException("Invalid subtraction sets.");
        }
    }
    
    private PartizanNimPosition()
    {
    }
    
    public Collection getLeftOptions()
    {
        return getOptions(leftSubtractionSet);
    }
    
    public Collection getRightOptions()
    {
        return getOptions(rightSubtractionSet);
    }
    
    public Collection getOptions(int[] subtractionSet)
    {
        java.util.List options = new java.util.ArrayList();
    
        for (int i = 0; i < subtractionSet.length; i++)
        {
            if (subtractionSet[i] <= heapSize)
            {
                PartizanNimPosition p = new PartizanNimPosition();
                p.leftSubtractionSet = leftSubtractionSet;
                p.rightSubtractionSet = rightSubtractionSet;
                p.heapSize = heapSize - subtractionSet[i];
                options.add(p);
            }
        }
    
        return options;
    }
    
    public cgsuite.Game getInverse()
    {
        PartizanNimPosition inverse = new PartizanNimPosition();
        inverse.leftSubtractionSet = rightSubtractionSet;
        inverse.rightSubtractionSet = leftSubtractionSet;
        inverse.heapSize = heapSize;
        return inverse;
    }

    public boolean equals(Object obj)
    {
        return obj instanceof PartizanNimPosition &&
            ((PartizanNimPosition) obj).heapSize == heapSize &&
            java.util.Arrays.equals(leftSubtractionSet, ((PartizanNimPosition) obj).leftSubtractionSet) &&
            java.util.Arrays.equals(rightSubtractionSet, ((PartizanNimPosition) obj).rightSubtractionSet);
    }
    
    public int hashCode()
    {
        return heapSize;
    }
    
    public String toString()
    {
        return "PartizanNim(" + subtractionSetToString(leftSubtractionSet) + ","
            + subtractionSetToString(rightSubtractionSet) + "," + heapSize + ")";
    }
    
    public String subtractionSetToString(int[] subtractionSet)
    {
        String s = "[";
        for (int i = 0; i < subtractionSet.length; i++)
        {
            s += subtractionSet[i];
            if (i < subtractionSet.length - 1)
            {
                s += ",";
            }
        }
        s += "]";
        return s;
    }
    
    public static void main(String[] args)
    {
        PartizanNimPosition p = new PartizanNimPosition
            (new int[] {1,3,5}, new int[] {2,4}, 9);
        cgsuite.CanonicalGame g = p.canonicalize();
        System.out.println("Canonical form of a size 9 heap in [1,3,5] vs. [2,4] partizan nim:");
        System.out.println(g);
    }
}