class TileDrawingHelper
  attr_accessor :tileset
  attr_accessor :autotiles

  AUTOTILE_PATTERNS = [
    [[27, 28, 33, 34], [5, 28, 33, 34], [27,  6, 33, 34], [5,  6, 33, 34],
     [27, 28, 33, 12], [5, 28, 33, 12], [27,  6, 33, 12], [5,  6, 33, 12]],
    [[27, 28, 11, 34], [5, 28, 11, 34], [27,  6, 11, 34], [5,  6, 11, 34],
     [27, 28, 11, 12], [5, 28, 11, 12], [27,  6, 11, 12], [5,  6, 11, 12]],
    [[25, 26, 31, 32], [25,  6, 31, 32], [25, 26, 31, 12], [25,  6, 31, 12],
     [15, 16, 21, 22], [15, 16, 21, 12], [15, 16, 11, 22], [15, 16, 11, 12]],
    [[29, 30, 35, 36], [29, 30, 11, 36], [5, 30, 35, 36], [5, 30, 11, 36],
     [39, 40, 45, 46], [5, 40, 45, 46], [39,  6, 45, 46], [5,  6, 45, 46]],
    [[25, 30, 31, 36], [15, 16, 45, 46], [13, 14, 19, 20], [13, 14, 19, 12],
     [17, 18, 23, 24], [17, 18, 11, 24], [41, 42, 47, 48], [5, 42, 47, 48]],
    [[37, 38, 43, 44], [37,  6, 43, 44], [13, 18, 19, 24], [13, 14, 43, 44],
     [37, 42, 43, 48], [17, 18, 47, 48], [13, 18, 43, 48], [1,  2,  7,  8]]
  ]

  # converts neighbors returned from tableNeighbors to tile indexes
  NEIGHBORS_TO_AUTOTILE_INDEX = [
    46, 44, 46, 44, 43, 41, 43, 40, 46, 44, 46, 44, 43, 41, 43, 40,
    42, 32, 42, 32, 35, 19, 35, 18, 42, 32, 42, 32, 34, 17, 34, 16,
    46, 44, 46, 44, 43, 41, 43, 40, 46, 44, 46, 44, 43, 41, 43, 40,
    42, 32, 42, 32, 35, 19, 35, 18, 42, 32, 42, 32, 34, 17, 34, 16,
    45, 39, 45, 39, 33, 31, 33, 29, 45, 39, 45, 39, 33, 31, 33, 29,
    37, 27, 37, 27, 23, 15, 23, 13, 37, 27, 37, 27, 22, 11, 22,  9,
    45, 39, 45, 39, 33, 31, 33, 29, 45, 39, 45, 39, 33, 31, 33, 29,
    36, 26, 36, 26, 21,  7, 21,  5, 36, 26, 36, 26, 20,  3, 20,  1,
    46, 44, 46, 44, 43, 41, 43, 40, 46, 44, 46, 44, 43, 41, 43, 40,
    42, 32, 42, 32, 35, 19, 35, 18, 42, 32, 42, 32, 34, 17, 34, 16,
    46, 44, 46, 44, 43, 41, 43, 40, 46, 44, 46, 44, 43, 41, 43, 40,
    42, 32, 42, 32, 35, 19, 35, 18, 42, 32, 42, 32, 34, 17, 34, 16,
    45, 38, 45, 38, 33, 30, 33, 28, 45, 38, 45, 38, 33, 30, 33, 28,
    37, 25, 37, 25, 23, 14, 23, 12, 37, 25, 37, 25, 22, 10, 22,  8,
    45, 38, 45, 38, 33, 30, 33, 28, 45, 38, 45, 38, 33, 30, 33, 28,
    36, 24, 36, 24, 21,  6, 21,  4, 36, 24, 36, 24, 20,  2, 20,  0
  ]

  def self.tableNeighbors(data, x, y)
    return 0 if x < 0 || x >= data.xsize
    return 0 if y < 0 || y >= data.ysize
    t = data[x, y]
    xp1 = [x + 1, data.xsize - 1].min
    yp1 = [y + 1, data.ysize - 1].min
    xm1 = [x - 1, 0].max
    ym1 = [y - 1, 0].max
    i = 0
    i |= 0x01 if data[x, ym1] == t   # N
    i |= 0x02 if data[xp1, ym1] == t   # NE
    i |= 0x04 if data[xp1,   y] == t   # E
    i |= 0x08 if data[xp1, yp1] == t   # SE
    i |= 0x10 if data[x, yp1] == t   # S
    i |= 0x20 if data[xm1, yp1] == t   # SW
    i |= 0x40 if data[xm1,   y] == t   # W
    i |= 0x80 if data[xm1, ym1] == t   # NW
    return i
  end

  def self.fromTileset(tileset)
    bmtileset = pbGetTileset(tileset.tileset_name)
    bmautotiles = []
    for i in 0...7
      bmautotiles.push(pbGetAutotile(tileset.autotile_names[i]))
    end
    return self.new(bmtileset, bmautotiles)
  end

  def initialize(tileset, autotiles)
    if tileset.mega?
      @tileset = TilemapRenderer::TilesetWrapper.wrapTileset(tileset)
      tileset.dispose
      @shouldWrap = true
    else
      @tileset = tileset
      @shouldWrap = false
    end
    @autotiles = autotiles
  end

  def dispose
    @tileset.dispose if @tileset
    @tileset = nil
    for i in 0...@autotiles.length
      @autotiles[i].dispose
      @autotiles[i] = nil
    end
  end

  def bltSmallAutotile(bitmap, x, y, cxTile, cyTile, id, frame)
    return if id >= 384 || frame < 0 || !@autotiles
    autotile = @autotiles[(id / 48) - 1]
    return if !autotile || autotile.disposed?
    cxTile = [cxTile / 2, 1].max
    cyTile = [cyTile / 2, 1].max
    if autotile.height == 32
      anim = frame * 32
      src_rect = Rect.new(anim, 0, 32, 32)
      bitmap.stretch_blt(Rect.new(x, y, cxTile * 2, cyTile * 2), autotile, src_rect)
    else
      anim = frame * 96
      id %= 48
      tiles = AUTOTILE_PATTERNS[id >> 3][id & 7]
      src = Rect.new(0, 0, 0, 0)
      for i in 0...4
        tile_position = tiles[i] - 1
        src.set((tile_position % 6 * 16) + anim, tile_position / 6 * 16, 16, 16)
        bitmap.stretch_blt(Rect.new((i % 2 * cxTile) + x, (i / 2 * cyTile) + y, cxTile, cyTile),
                           autotile, src)
      end
    end
  end

  def bltSmallRegularTile(bitmap, x, y, cxTile, cyTile, id)
    return if id < 384 || !@tileset || @tileset.disposed?
    rect = Rect.new((id - 384) % 8 * 32, (id - 384) / 8 * 32, 32, 32)
    rect = TilemapRenderer::TilesetWrapper.getWrappedRect(rect) if @shouldWrap
    bitmap.stretch_blt(Rect.new(x, y, cxTile, cyTile), @tileset, rect)
  end

  def bltSmallTile(bitmap, x, y, cxTile, cyTile, id, frame = 0)
    if id >= 384
      bltSmallRegularTile(bitmap, x, y, cxTile, cyTile, id)
    elsif id > 0
      bltSmallAutotile(bitmap, x, y, cxTile, cyTile, id, frame)
    end
  end

  def bltAutotile(bitmap, x, y, id, frame)
    bltSmallAutotile(bitmap, x, y, 32, 32, id, frame)
  end

  def bltRegularTile(bitmap, x, y, id)
    bltSmallRegularTile(bitmap, x, y, 32, 32, id)
  end

  def bltTile(bitmap, x, y, id, frame = 0)
    if id >= 384
      bltRegularTile(bitmap, x, y, id)
    elsif id > 0
      bltAutotile(bitmap, x, y, id, frame)
    end
  end
end

#===============================================================================
#
#===============================================================================
def createMinimap(mapid)
  map = load_data(sprintf("Data/Map%03d.rxdata", mapid)) rescue nil
  return BitmapWrapper.new(32, 32) if !map
  bitmap = BitmapWrapper.new(map.width * 4, map.height * 4)
  black = Color.new(0, 0, 0)
  tilesets = $data_tilesets
  tileset = tilesets[map.tileset_id]
  return bitmap if !tileset
  helper = TileDrawingHelper.fromTileset(tileset)
  for y in 0...map.height
    for x in 0...map.width
      for z in 0..2
        id = map.data[x, y, z]
        id = 0 if !id
        helper.bltSmallTile(bitmap, x * 4, y * 4, 4, 4, id)
      end
    end
  end
  bitmap.fill_rect(0, 0, bitmap.width, 1, black)
  bitmap.fill_rect(0, bitmap.height - 1, bitmap.width, 1, black)
  bitmap.fill_rect(0, 0, 1, bitmap.height, black)
  bitmap.fill_rect(bitmap.width - 1, 0, 1, bitmap.height, black)
  return bitmap
end

def bltMinimapAutotile(dstBitmap, x, y, srcBitmap, id)
  return if id >= 48 || !srcBitmap || srcBitmap.disposed?
  anim = 0
  cxTile = 3
  cyTile = 3
  tiles = TileDrawingHelper::AUTOTILE_PATTERNS[id >> 3][id & 7]
  src = Rect.new(0, 0, 0, 0)
  for i in 0...4
    tile_position = tiles[i] - 1
    src.set((tile_position % 6 * cxTile) + anim,
            tile_position / 6 * cyTile, cxTile, cyTile)
    dstBitmap.blt((i % 2 * cxTile) + x, (i / 2 * cyTile) + y, srcBitmap, src)
  end
end

def passable?(passages, tile_id)
  return false if tile_id == nil
  passage = passages[tile_id]
  return (passage && passage < 15)
end

# Unused
def getPassabilityMinimap(mapid)
  map = load_data(sprintf("Data/Map%03d.rxdata", mapid))
  tileset = $data_tilesets[map.tileset_id]
  minimap = AnimatedBitmap.new("Graphics/Pictures/minimap_tiles")
  ret = Bitmap.new(map.width * 6, map.height * 6)
  passtable = Table.new(map.width, map.height)
  passages = tileset.passages
  for i in 0...map.width
    for j in 0...map.height
      pass = true
      for z in [2, 1, 0]
        if !passable?(passages, map.data[i, j, z])
          pass = false
          break
        end
      end
      passtable[i, j] = pass ? 1 : 0
    end
  end
  neighbors = TileDrawingHelper::NEIGHBORS_TO_AUTOTILE_INDEX
  for i in 0...map.width
    for j in 0...map.height
      if passtable[i, j] == 0
        nb = TileDrawingHelper.tableNeighbors(passtable, i, j)
        tile = neighbors[nb]
        bltMinimapAutotile(ret, i * 6, j * 6, minimap.bitmap, tile)
      end
    end
  end
  minimap.disposes
  return ret
end