require "map"

viewport={}

function viewport.new(_width, _height)
    return { x=0, y=0,
	         width=_width,
			 height=_height,
             get=viewport.get,
			 position=viewport.position,
			 print=viewport.print,
			 room=viewport.coord2room,
             --roomXY= viewport.room2coord,
             tile= viewport.tile,
             last_tile= viewport.last_tile,
             screen_coords = viewport.screen_coords,
             inside = viewport.inside } 
end

function viewport:get()
    return self.x, self.y, self.x+self.width, self.y+self.height
end

function viewport:screen_coords ( x, y )
    local scr_x = x-self.x
    local scr_y = y-self.y
    return scr_x, scr_y
end

function viewport:inside( x, y, w, h )
    local result = false
    if self.x<=x+w and self.x+self.width>=x and self.y<=y+h and self.y+self.height>=y then result = true end
    return result
end

-- function viewport:coord2tile (x, y)
-- 	local tw = arcade_config.tiles_width
-- 	local th = arcade_config.tiles_height
-- 	local cols = mapa_room_cols
-- 	local rows = mapa_room_rows
-- 	local rooms_per_floor = mapa_rooms_per_piso
-- 	local xx = x or self.x
--     local yy = y or self.y
--     
-- 	local calc_col = math.floor(xx / tw) % cols
-- 	local calc_row = math.floor(yy / th) % rows
-- 	local calc_room = math.floor(yy / (th * rows))*rooms_per_floor+math.floor(xx / (tw * cols))
-- -- print("X= "..self.x.." / W="..tw.." / C= "..cols.." > "..calc_col)	
-- -- print("Y= "..self.y.." / H="..th.." / R= "..rows.." > "..calc_row)
-- -- print("CR= "..calc_row.." / RF= "..rooms_per_floor.." / CC= "..calc_col)	
-- 	-- local tile_offset_x = self.x - (calc_col * tw * cols)
-- 	-- local tile_offset_y = self.y - (calc_row * th * rows)	
-- 	local tile_offset_x = xx - (calc_col * tw) - ((calc_room%rooms_per_floor)*cols*tw)
-- 	local tile_offset_y = yy - (calc_row * th) - ( math.floor(calc_room/10)*rows*th)
-- -- print(self.x.." C"..calc_col.." W"..tw.." R"..calc_room.." c"..cols.." > "..tile_offset_x)	
-- 	-- room, x, y, offset x, offset y
-- 	return calc_room, calc_col, calc_row, tile_offset_x, tile_offset_y
-- end

function viewport:tile ()
    return coords.world_to_tile(self.x, self.y)
end

function viewport:last_tile ()
    return coords.world_to_tile(self.x+self.width, self.y+self.height)
end

function viewport:coord2room ()
    return coords.world_to_room(self.x, self.y)
	-- local tw = arcade_config.tiles_width
	-- local th = arcade_config.tiles_height
	-- local cols = mapa_room_cols
	-- local rows = mapa_room_rows
	-- local rooms_per_floor = mapa_rooms_per_piso
	-- 
	-- local calc_col = math.floor(self.x / (tw * cols))
	-- local calc_row = math.floor(self.y / (th * rows))
	-- 
	-- local calc_room = calc_row*rooms_per_floor+calc_col
	-- return calc_room
end

--  function viewport:room2coord ( room )
--  	local tw = arcade_config.tiles_width
--  	local th = arcade_config.tiles_height
--  	local cols = mapa_room_cols
--  	local rows = mapa_room_rows
--  	local rooms_per_floor = mapa_rooms_per_piso
--  	
--  	local x = (room % rooms_per_floor) * cols * tw
--  	local y = math.floor(room/rooms_per_floor) * rows * th
--  	
--  	local room_center_x_offset = (cols * tw) >> 1
--  	local room_center_y_offset = (rows * th) >> 1
--  	
--  	-- return x+room_center_x_offset, y+room_center_y_offset
--  	return x, y
--  end

function viewport:position(x, y)
  local nx = (x ~= nil) and x or self.x
  local ny = (y ~= nil) and y or self.y

  self.x = nx
  self.y = ny

  return self.x, self.y
end

function viewport:print()
	local room = self:room()
	draw.rectf(0,7,45,14,16)
    draw.text("X="..self.x.." , Y= "..self.y..", R"..room,1,8,2)
end

return viewport