--[[
###################################
##         Chess System          ##
##      Developed by Dalvo       ##
##       Date: 22/04/2012        ##
##   Tested on TFS 0.4_rev3884   ##
## Obs.: Need modified sources   ##
###################################


* criação das peças (.xml) [completo]
* criação tabuleiro [completo]
* função verifica posições que peça pode mover [parcialmente completa] ** faltam exceções
* verificação de xeque [completo]
* verificação de xeque-mate [não]
* função que pega todas as peças do tabuleiro e separa por cor [completo]
* movimentação de peças e captura [completo]
* verificação de xeque ao mover rei [parcialmente completo]
* envio de efeitos para facilitar a visualização das posições que se pode mover [completo]
* talkaction para desafiar outro player [incompleto]
* criação de peças o tabuleiro [completo]
* modificação source em callback onPush [completo]
* verificar xeque a cada movimentação de peça [não]


]]
--## config ##
INITIAL_POS = {x=90, y = 139, z = 7}
XADREZ_STORAGE = 759593 -- for look
tile_white, tile_black = 965, 966
stor_challenger = 752345
--## end config ##




Chess = {}


function Chess:new(cid)
    --[[
    Chess:new(cid)
        * inicialmente usada apenas para usar as funções como metodo
        * necessita-se usar esta função antes de qualquer outra da lib
    ]]
    local attr = {cid = cid}
    return setmetatable(attr, {__index = self})
end


function Chess:hasTileSend(pos, namefind)
    --[[
    Chess:hasTileSend(pos, namefind)
        * verifica se tile pertence ao tabuleiro
        * se houver monstro no tile verifica se o monstro em questão tem 'namefind' no nome
    ]]
    local uid = getTopCreature(pos).uid
    if((isInArray({tile_black, tile_white}, getTileInfo(pos).itemid) and not (isMonster(uid) and getCreatureName(uid):find(namefind)))then
        return true
    end
    return false
end


function Chess:getDirsToPos(fromPos, toPos)
    --[[
    Chess:getDirsToPos(fromPos, toPos)
        * lista todas as direções para se mover da posição 'fromPos' até 'toPos'
        * função a ser optimizada ainda
    ]]
    local dirs, fakeFromPos, fakeToPos = {}, {}, {}
    fakeFromPos, fakeToPos = {x = fromPos.x, y=fromPos.y, z=fromPos.z}, {x = toPos.x, y = toPos.y, z= toPos.z}
    while (not self:tableCompare(fakeFromPos, fakeToPos)) do
        local dir = getDirectionTo(fakeFromPos, fakeToPos)
        table.insert(dirs, dir)
        local newPos = getPositionByDirection(fakeFromPos, dir, 1)
        fakeFromPos.x, fakeFromPos.y, fakeFromPos.z = newPos.x, newPos.y, newPos.z
    end
    return dirs
end


function Chess:moveDirs(uid, listDir, delayStep)
    --[[
    Chess:moveDirs(uid, listDir[, delayStep])
        * move creature fornecida por 'uid' por todas as direções listadas em 'listDir' num intervalo de 'delayStep' em miliseconds
        * se 'delayStep' não for fornecida, seu valor é '1000'
    ]]
    if not delayStep then
        delayStep = 1000
    end


    for i, dir in pairs(listDir) do
        addEvent(function()
                if(isCreature(uid))then
                    doMoveCreature(uid, dir)
                end
            end, i*delayStep)
    end
end


function Chess:tableCompare(tab, tab2)
    --[[
    Chess:tableCompare(tab, tab2)
        * compara se duas tabelas tem index iguais fornecendo valores iguais
        * pouco usada, possivelmente será removida
    ]]


    bool = true
    for index,value in pairs(tab) do
        if not(value == tab2[index])then
            bool = false
        end
    end
    return bool
end


function Chess:isFirstPosPawn(pos, color)
    --[[
    Chess:isFirstPosPawn(pos, color)
        * verifica se 'pos' é posição inicial de pawn para 'color' fornecida
    ]]
    local fakePos = {}
    fakePos.x, fakePos.y, fakePos.z = pos.x,pos.y, pos.z
    fakePos.y = (color == "black") and (fakePos.y + 2) or (fakePos.y - 2)
    return ((getTileInfo(fakePos).itemid == tile_black or getTileInfo(fakePos).itemid == tile_white) == false)
end


function Chess:isPiece(name)
    --[[
    Chess:isPiece(name)
        * verifica se 'name' é nome de uma peça e se 'name' não é nome de um player
    ]]
    local pieceType = name:sub(7)
    if(isPlayer(getCreatureByName(name)))then return false end
    return isInArray({"king", "pawn", "horse", "tower", "queen", "bishop"}, pieceType)
end


function Chess:getPathPos(uid_piece, xeque)
    --[[
    Chess:getPathPos(uid_piece[, xeque)
        * função base do sistema
        * a partir do uid fornecido pega pelo nome da peça todas as posições a que se pode mover a peças
        * o parametro 'xeque' é um booleano e só deve ser usado para verificar posição de xeque para o rei
    ]]
    local piece_moves =
    {
        ["king"] = {distMove=1, dirs = {0,1,2,3,4,5,6,7}},
        ["queen"] = {distMove=8, dirs = {0,1,2,3,4,5,6,7}},
        ["bishop"] = {distMove=8, dirs = {4,5,6,7}},
        ["horse"] = {posits = {{x = -1, y = -2}, {x = 1, y = -2}, {x = 2, y = 1}, {x = 2, y = -1},{x = -2, y = 1}, {x = -2, y = -1}, {x = -1, y = 2}, {x = 1, y = 2}}},
        ["tower"] = {distMove=8, dirs = {0,1,2,3}},
        ["pawn"] = 0 -- ignore this
    }
    if not(isCreature(uid_piece))then return error("[Chess System] Creature Not Found.") end
    local positions, piecename = {}, getCreatureName(uid_piece)
    local pieceType, pieceColor = piecename:sub(7):lower(), piecename:sub(1,5):lower()


    if(piece_moves[pieceType])then
        if(isInArray({"king", "queen", "tower", "bishop"}, pieceType))then
            for _, dir in pairs(piece_moves[pieceType].dirs)do
                for dist = 1, piece_moves[pieceType].distMove do
                    local pos = getPositionByDirection(getThingPos(uid_piece), dir, dist)
                    if(self:hasTileSend(pos, pieceColor))then
                        table.insert(positions, pos)
                    end
                    local uid_pos = getTopCreature(pos).uid
                    if(isCreature(uid_pos) or (not self:hasTileSend(pos, pieceColor)))then break end
                end
            end
        elseif(pieceType == "horse")then
            for _, mod_ in pairs(piece_moves[pieceType].posits) do
                local pos = getThingPos(uid_piece)
                pos.x, pos.y = pos.x + mod_.x, pos.y + mod_.y
                if(self:hasTileSend(pos, pieceColor))then
                    table.insert(positions, pos)
                end
            end
        elseif(pieceType == "pawn")then
            local dir = (pieceColor == "black") and 0 or 2
            local pos1 = getPositionByDirection(getThingPos(uid_piece), dir, 1)
            if not(isCreature(getTopCreature(pos1).uid))then
                if not xeque then
                    table.insert(positions, pos1)
                    local pos_r, pos_l = {x= pos1.x -1,y=pos1.y,z=pos1.z}, {x= pos1.x +1 ,y=pos1.y,z=pos1.z}
                    if(isMonster(getTopCreature(pos_l).uid))then
                        table.insert(positions, pos_r)
                    end
                    if(isMonster(getTopCreature(pos_l).uid))then
                        table.insert(positions, pos_l)
                    end
                    local pos2 = getPositionByDirection(getThingPos(uid_piece), dir, 2)
                    if(self:isFirstPosPawn(getThingPos(uid_piece), pieceColor) and #positions > 0)then
                        table.insert(positions, pos2)
                    end
                else
                    table.insert(positions, pos_r)
                    table.insert(positions, pos_l)
                end
            end
        end
        return positions
    else
        error("[Chess System] Invalid piece name")
    end
end


function Chess:isValidPos(uid, pos, xeque)
    --[[
    Chess:isValidPos(uid, pos[, xeque])
        * verifica se a posição 'pos' está contida no pathpos da criatura
        * o parametro 'xeque' é um booleano e só deve ser usado para verificar posição de xeque para o rei
    ]]
    local listPos = self:getPathPos(uid, xeque)
    for _, posi in pairs(listPos) do
        if(posi.x == pos.x and posi.y == pos.y and posi.z == pos.z)then
            return true
        end
    end
    return false
end


function Chess:verifyXeque(uid, toPos)
    --[[
    Chess:verifyXeque(uid[, toPos])
        * listar peças adversarias
        * iterar sobre elas gerando o pathpos de cada uma e verificando se coincide com a pos do rei
        * caso uma seja verdadeira retornar true finalizando o loop
        * caso nenhuma seja verdadeira retornar false
    ]]
    if(isCreature(uid))then
        local piecename = getCreatureName(uid)
        local pieceType, pieceColor = piecename:sub(7):lower(), piecename:sub(1,5):lower()
        if(self:isPiece(piecename) and pieceType == "king")then
            local black, white = self:getPiecesOnTab()
            for _, piece in pairs(pieceColor == "black" and white or black) do
                if(self:isValidPos(piece, type(toPos) == "table" and toPos or getThingPos(uid), true))then
                    return true
                end
            end
        end
    end
    return false
end


function Chess:sendEffects(uid)
    --[[
    Chess:sendEffects(uid)
        * pega o path do uid para todas as posiçoes possiveis de se andar
        * manda efeito em todas
    ]]
    local positions = self:getPathPos(uid)
    doSendMagicEffect(getThingPos(uid), 55)
    for _, pos in pairs(positions) do
        doSendMagicEffect(pos, 56)
    end
end


function Chess:getPiecesOnTab()
    --[[
    Chess:getPiecesOnTab()
        * pega o uid de todas as peças no tabuleiro partindo da posição configurada
        por 'INITIAL_POS' e separar por time retornando duas tabelas
    ]]
    local black, white = {}, {}
    for x = 0, 7 do
        for y = 0, 7 do
            local pos = {x = INITIAL_POS.x, y = INITIAL_POS.y, z = INITIAL_POS.z}
            pos.x, pos.y = pos.x + x, pos.y + y
            local creature = getTopCreature(pos)
            if(isMonster(creature.uid))then
                local name = getCreatureName(creature.uid)
                if(self:isPiece(name))then
                    table.insert(name:find("black") and black or white, creature.uid)
                end
            end
        end
    end
    return black, white
end


function Chess:createPieces()
    --[[
    Chess:createPieces()
        * remove todas peças do tabuleiro
        * ao remover também cria as peças em sua posição inicial
        * brancas em cima, pretas em baixo
    ]]
    local piecepos = {}
    pieces = {"tower", "horse", "bishop", "queen", "king","bishop","horse","tower"}
    for _, index in pairs({0,1,6,7}) do piecepos[index] = {} end
    for index, piece in pairs(pieces) do
        piecepos[0][index-1] = "white "..piece
        piecepos[7][index-1] = "black "..piece
    end
    for i = 0, 7 do
        piecepos[1][i] = "white pawn"
        piecepos[6][i] = "black pawn"
    end


    for x = 0, 7 do
        for y = 0, 7 do
            local pos = {x = INITIAL_POS.x, y = INITIAL_POS.y, z = INITIAL_POS.z}
            pos.x, pos.y = (pos.x + x), (pos.y + y)
            local creature = getTopCreature(pos)
            if(isMonster(creature.uid))then
                doRemoveCreature(creature.uid)
            end
            if(piecepos[y] and piecepos[y][x]) then
                doCreateMonster(piecepos[y][x], pos)
            end
        end
    end
end