class ZulrahConstants {
    public static final byte RANGE = 0x1;
    public static final byte MAGE  = 0x2;
    public static final byte MELEE = 0x3;

    public static final byte CENTER = 0x0;
    public static final byte LEFT = 0x4;
    public static final byte RIGHT = 0x8;
    public static final byte BOTTOM = 0xc;

    public static final byte MELEE_CENTER = MELEE | CENTER;
    public static final byte MAGE_CENTER = MAGE | CENTER;
    public static final byte MAGE_RIGHT = MAGE | CENTER;
    public static final byte RANGE_CENTER = RANGE | CENTER;
    public static final byte RANGE_BOTTOM = RANGE | BOTTOM;
    public static final byte RANGE_LEFT = RANGE | LEFT;
    public static final byte RANGE_RIGHT = RANGE | RIGHT;

    public static final short RANGE_MELEE_MAGE_CENTER = (short) (RANGE_CENTER | (MELEE_CENTER << 4) | (MAGE_CENTER << 8));
    public static final short FIRST_PATTERN = (short) (RANGE_MELEE_MAGE_CENTER | (RANGE_BOTTOM << 12));
    public static final short SECOND_PATTERN = (short) (RANGE_MELEE_MAGE_CENTER | (RANGE_LEFT << 12));
    public static final short THIRD_PATTERN = (short) (RANGE_CENTER | (RANGE_RIGHT << 4));
    public static final short FOURTH_PATTERN = (short) (RANGE_CENTER | (MAGE_RIGHT << 4));

    public static final int MAGE_ID = 1;
    public static final int RANGE_ID = 1;
    public static final int MELEE_ID = 1;

    public static final Area LEFT_AREA = new Area();
    public static final Area RIGHT_AREA = new Area();
    public static final Area BOTTOM_AREA = new Area();
    public static final Area CENTER_AREA = new Area();
}

class PatternHashBuilder {
    public short buildHash(MethodProvider api, short currentHash, int currentRound) {
        NPC zulrah = api.getNpcs().closest("Zulrah");
        if(zulrah == null)
            return currentHash;

        switch(zulrah.getId()) {
            case 1:
                currentHash |= RANGE << (currentRound * 4);
                break;
            case 2:
                currentHash |= MAGE << (currentRound * 4);
                break;
            case 3:
                currentHash |= MELEE << (currentRound * 4);
                break;
        }

        Area area = zulrah.getArea();
        if(area.equals(CENTER_AREA)) {
            currentHash |= CENTER << (currentRound * 4);
        } else if(area.equals(LEFT_AREA)) {
            currentHash |= LEFT << (currentRound * 4);
        }

        return currentHash;
    }
}

class ZulrahHelperScript extends Script {
    private Map<Short, ZulrahPattern> patterns = new HashMap<>();
    private ZulrahPattern pattern;

    private PatternHashBuilder hashBuilder;
    private short currentHash;
    private int currentRound;

    public void onStart() {
        //create Zulrah and Player details
        //create ZulrahStages

        patterns.put(FIRST_PATTERN, new ZulrahPattern());
        patterns.put(SECOND_PATTERN, new ZulrahPattern());
        patterns.put(THIRD_PATTERN, new ZulrahPattern());
        patterns.put(FOURTH_PATTERN, new ZulrahPattern());

        System.out.println();
        System.out.println(SECOND_PATTERN);
        System.out.println(THIRD_PATTERN);
        System.out.println(FOURTH_PATTERN);
    }

    public int onLoop() {
        if(patternIsAvailable()) {
            processPattern();
        } else {
            pattern = patterns.get(hashBuilder.buildHash(this, currentHash, currentRound));
        }

        return 33;
    }

    private void processPattern() {
        if(pattern.isFinished()) {
            //end script / restart
        } else {
            if(pattern.process(this)) {
                currentRound++;
            }
        }
    }

    private boolean patternIsAvailable() {
        return pattern != null;
    }
}

class ZulrahPattern {
    private final LinkedList<ZulrahRound> stagesToProcess;
    private boolean finished;

    public ZulrahPattern(final ZulrahRound...stages) {
        stagesToProcess = new LinkedList<>(Arrays.asList(stages));
    }

    /**
     * @return true if current round is finished. False if otherwise.
     */
    public boolean process(MethodProvider api) {
        ZulrahRound currentStage = stagesToProcess.peekFirst();
        if(currentStage.isFinished(api)) {
            stagesToProcess.pop();

            if(stagesToProcess.size() < 1) {
                finished = true;
            }

            return true;
        } else {
            currentStage.process(api);
            return false;
        }
    }

    public boolean isFinished() {
        return finished;
    }
}

class ZulrahRound {
    private ZulrahDetails zulrah;
    private PlayerDetails player;

    public ZulrahRound(ZulrahDetails zulrah, PlayerDetails player) {
        this.zulrah = zulrah;
        this.player = player;
    }

    public void process(MethodProvider api) {

    }

    public boolean isFinished(MethodProvider api) {
        return false;
    }
}


class ZulrahDetails {

}

class PlayerDetails {

}