import sys
import random

# odd-numbered rows are right-shifted by half a tile width
class Map(object):
    def __init__(self):
        self._arr = []
        self._list = []
        self._finalized = False

    def add(self, row, col, tile):
        self._extend(row, col)
        self._arr[row][col] = tile
        self._list.append(tile)
        self._finalized = False

    def get(self, row, col):
        if row < 0 or len(self._arr) <= row:
            return None
        if col < 0 or len(self._arr[row]) <= col:
            return None
        return self._arr[row][col]

    def _extend(self, row, col):
        while len(self._arr) <= row:
            self._arr.append([])
        while len(self._arr[row]) <= col:
            self._arr[row].append(None)

    def _finalize(self):
        if self._finalized:
            return
        self._neighbors = {}
        def check(_r, _c, tile):
            n = self.get(_r, _c)
            if n:
                self._neighbors[_c].append(n)
        for row, r in enumerate(self._arr):
            for col, tile in enumerate(r):
                if tile:
                    self._neighbors[tile] = []
                    offset = row & 1
                for i in range(2):
                    c = col - 1 + i + offset
                    check(row - 1, c)
                    check(row + 1, c)
                check(row, col - 1)
                check(row, col + 1)
        self._finalized = True

    def number(self):
        self._finalize()
        red_possibilities = dict(zip(self._list, self._list))
        to_number = dict(zip(self._list, self._list))
        if len(red_possibilities) != 19:
            sys.stderr('Map.number() only supports maps of 19 tiles!')
            return
        for red in [6, 6, 8, 8]:
            rp = red_possibilities.keys()
            random.shuffle(rp)
            tile = rp[0]
            tile.roll_val = red
            del to_number[tile]
            del red_possibilities[tile]
            for t in self._neighbors[tile]:
                del red_possibilities[tile]
        tiles = to_number.keys()
        random.shuffle(tiles)
        zipped = zip(tiles, [2, 3, 3, 4, 4, 5, 5, 9, 9, 10, 10, 11, 11, 12])
        def assign_roll_val(tr):
            tile, rv = tr
            tile.roll_val = rv
        map(assign_roll_val, zipped)