from enum import Enum
from typing import Tuple, Dict

from data import GameConstants, Direction

def getHotSpot(game:GameConstants) -> (int, int):
    pass

def isOrderReady(game:GameConstants) -> bool:
    pass

def getReadyOrderId(game:GameConstants) -> int:
    pass

class Action():


    def __init__(self, game: GameConstants):
        self.game = GameConstants

    def rotate(self, direction: Direction) -> GameConstants:
        self.game.agentDirection = direction
        pass

    def move(self) -> GameConstants:
        # w zaleznosci od kierunku napierdala do przodu
        pass

    def special(self) -> GameConstants:
        # w zaleznosci od miejsca gdzie jest i czy ma cos na lapie odklada albo bierze przedmiot
        pass

    def orderOut(self, orderId: int) -> GameConstants:
        # nalicza punkty wypierdalaorder i czysci orderStock
        pass

def heuristic(a: Tuple[int, int], b: Tuple[int, int]) -> float:
    (x1, y1) = a

    (x2, y2) = b
    return abs(x1 - x2) + abs(y1 - y2)

class PossibleMoves(Enum):
    move = 1
    rotateLeft = 2
    rotateDown = 3
    rotateRight = 4
    rotateTop = 5


def getRotationEvaluation(direction: Direction):
    # get evaluationForMoveAfterRotation
    return 1.0

def evaluateMoves(game: GameConstants) -> Dict:
    posibleMoves = Dict
    currPos = game.agentPos
    gameCopy = game.getCopy()
    getRotationEvaluation()
    posibleMoves[PossibleMoves.move] = heuristic(currPos, Action(gameCopy).move().agentPos)
    posibleMoves[PossibleMoves.rotateTop] = getRotationEvaluation(Direction.Direction.top)
    posibleMoves[PossibleMoves.rotateLeft] = getRotationEvaluation(Direction.Direction.left)
    posibleMoves[PossibleMoves.rotateDown] = getRotationEvaluation(Direction.Direction.down)
    posibleMoves[PossibleMoves.rotateRight] = getRotationEvaluation(Direction.Direction.right)
    return posibleMoves

def getIndex(value: float, dict: Dict) -> PossibleMoves:
    for key, val in dict:
        if val == value:
            return key

def getMaxFromList(list: [float]) -> float:
    maxi = -10000000
    for i in range(len(list)):
        if list[i] > maxi:
            maxi = list[i]

    return maxi

def getBestPossibleMove(game: GameConstants) -> PossibleMoves:
    movesDict = evaluateMoves()
    bestChoice = getMaxFromList(movesDict.values())
    return getIndex(bestChoice, movesDict)

def getBestMove(game: GameConstants) -> GameConstants:
    gameCopy = game.getCopy()
    bestPossibleMove = getBestPossibleMove(gameCopy)

    if bestPossibleMove == PossibleMoves.move:
        return Action(gameCopy).move()
    elif bestPossibleMove == PossibleMoves.rotateTop:
        return Action(gameCopy).rotate(Direction.Direction.top)
    elif bestPossibleMove == PossibleMoves.rotateLeft:
        return Action(gameCopy).rotate(Direction.Direction.left)
    elif bestPossibleMove == PossibleMoves.rotateDown:
        return Action(gameCopy).rotate(Direction.Direction.down)
    else:
        return Action(gameCopy).rotate(Direction.Direction.right)



def nastepnik(game: GameConstants) -> GameConstants:
    if isOrderReady(game) > -1:
        return Action(game.getCopy()).orderOut(getReadyOrderId(game))
    elif game.agentPos == getHotSpot(game):
        return Action(game.getCopy()).special()
    else:
        return getBestMove(game)