local t = {}
local bmp = require 'map.bmp'
local lg = assert( love.graphics )

local colours = { 
  africa = {1,0,0,0.5},
  europe = {0,1,0,0.5},
  northamerica = {0,0,1,0.5},
  russia = {0,1,1,0.5},
  southamerica = {1,0,1,0.5},
  southasia = {1,1,0,0.5},
  sailable = {1, 1, 1, 0.2},
}

function t.load( filename, name )
  local img, imgd = assert( bmp.load( filename ) )
  img:setWrap( "repeat" )
  local territory = { 
    visible = true, 
    name = name,
    filename = filename,
    colour = colours[name],
    border = {},
    img = img,
    imgd = imgd
  }

  if name == "sailable" then
    t.sailable = territory
    t.computeBorder( territory, 20 / 255, "sailable" )
    t.computeBorder( territory, 60 / 255, "placeable" )
  else
    t.computeBorder( territory, 60 / 255, "sea" )
    t.computeBorder( territory, 130 / 255, "land" )
  end
  return setmetatable( territory, {__index = t } )
end

--World space coordinate.
local function ToWorld( x, y )
  return x * 360 / 512 - 180, y * 200 / 285 - 100
end

local function ToPixel( x, y )
  return (x + 180) * 512 / 360, 285 - ( y + 100 ) * 285 / 200 
end


function t.isValid( x, y )

end

function t.getPixel( territory, x, y )
  --ZERO INDEXED
  local imgx, imgy = math.floor( 512 * ( x + 180 ) / 360 ),  math.floor( 285 * ( y + 100 ) / 200 )
  --print( territory.name, imgx, imgy )
  return territory.imgd:getPixel( imgx, imgy )
end

--[[
    0
    20  -- once sailable.bmp is brighter than this, the area is traversable by ships
    60  -- once sailable.bmp and territory.bmp are brighter than this, ships can be placed here
    130 -- if territory.bmp is brighter than this and sailable is darker than 60, structures are placeable.

    SO:
      SAILABLE: 0 (not), 21 (traverse not place), 61 ( traverse and place )
      TERRITORY:  131 ( place land if sailable <= 60 ), 61 ( place sea ), 0
]]
function t.isSailable( x, y )
  local water = assert( t.sailable )
  if water:getPixel( x, y ) > 20 / 255 then return true end
  return false
end

function t.canPlaceShip( territory, x, y )
  local water = assert( t.sailable )
  if water:getPixel( x, y ) > 60 / 255
  and territory:getPixel( x, y ) > 60 / 255 then return true end
  return false
end

function t.canPlaceLand( territory, x, y )
  local water = assert( t.sailable )
  if water:getPixel( x, y ) < 60 / 255
  and territory:getPixel( x, y ) > 130 / 255 then return true end
  return false
end

function t.draw( territory )
  lg.setColor( territory.colour )
  lg.draw( territory.img )
end

function t.drawBorder( territory, key )
  key = key or "border"
  for _, poly in ipairs( territory[key] ) do
    lg.line( poly )
  end
end


function t.computeBorder( territory, threshold, key )
  key = key or "border"
  territory[key] = {}
  local border = territory[key]
  local n = 1

  local w, h = territory.imgd:getWidth() - 1, territory.imgd:getHeight() - 1
  w, h = math.min( 512, w ), math.min( 285, h )
  for x = 0, w do
    for y = 0, h do
      --Bottom left, bottom right, and top right of pixel in image coordinates:
      local blx, bly = x, y + 1
      local brx, bry = x + 1, y + 1
      local trx, try = x + 1, y

      --Sample image and detect edge:
      local curValue = territory.imgd:getPixel( x, y )
      local rightValue = territory.imgd:getPixel( math.min( x + 1, 511 ), y )
      local downValue = territory.imgd:getPixel( x, math.min( 284, y + 1 ) )

      local isRightEdge =
      ((curValue >= threshold) and (rightValue < threshold)) or
      ((curValue < threshold) and (rightValue >= threshold))
      local isDownEdge = 
      ((curValue >= threshold) and (downValue < threshold)) or
      ((curValue < threshold) and (downValue >= threshold))

      if isRightEdge then
        --print( "Left edge:", brx, bry, trx, try )
        border[n] = { x + 1, y, x + 1, y + 1 }
        n = n + 1
      end

      if isDownEdge then
        --print( "Down edge:", blx, bly, brx, bry )
        border[n] = { x, y + 1, x + 1, y + 1 }
        n = n + 1
      end
    end
  end
end

function t.save( territory )
  local fmt = (territory.name == "sailable") and "sailable" or "territory"
  return bmp[fmt]( territory.imgd )
end

return t