# needed for graphics in notebooks:
%matplotlib notebook
# import main code for the game, and all the tests:
import lost_puffling
from lost_puffling_tests import *


def get_damage(technique):
    """Returnerer skaden av angrepsteknikkene"""
    # FEEDBACK: Svært bra
    value = 0
    if technique == 'slash':
        value = 2
    if technique == 'jump slash':
        value = 3
    if technique == 'bow':
        value = 1
    if technique == 'spin attack':
        value = 1.5
    return value


def choose_technique(enemy):
    """Returnerer angrepsmåte basert på avstanden til motstandaren"""
    # FEEDBACK: Svært bra
    if enemy[1] < 2 and enemy[1] >= 0:
        return 'slash'
    elif enemy[1] < 4 and enemy[1] >= 2:
        return 'jump slash'
    elif enemy[1] >= 4:
        return 'bow'

def get_spin_damage(enemies):
    """Returnerer skaden for spin_damage for kvar motstandar i nærleiken"""
    # FEEDBACK: Svært bra
    spin_damage = 0
    for enemy in enemies:
        if 0 <= enemy[1] <= 2:
            spin_damage += min(enemy[0], get_damage("spin attack"))
    return spin_damage



def query_attack(enemies):
    """Tar ei lista av posisjon og avstand til motstandar og returnerer den teknikken som gjer høgast skade"""
    # FEEDBACK: Svært bra
    highest_dmg = 0
    target = None
    for index, enemy in enumerate(enemies):
        damage = min(enemy[0], get_damage(choose_technique(enemy)))
        if damage > highest_dmg:
            highest_dmg = damage
            target = index
    spin_damage = get_spin_damage(enemies)
    if spin_damage > highest_dmg:
        return ["spin attack", None]
    return [choose_technique(enemies[target]), target]

def min_adjoining(adjoining):
    """Returnerer det minst besøkte rommet/romma"""
    # FEEDBACK: Svært bra

    coordinates = []
    # FEEDBACK: Du kan bruke float('inf') i stedet for eit stort tal,
    # men det er kanskje betre å bruke følgende:
    # least_visited = lost_puffling.nvisited(adjoining[0][0], adjoining[0][1])
    least_visited = 100000 #ikkje særlig pent, finns kanskje ein finare måte?
    for (x, y) in (adjoining):
        num_visited = lost_puffling.nvisited(x, y)
        if num_visited < least_visited:
            least_visited = num_visited
            coordinates = [[x, y]]
        elif num_visited == least_visited:
            coordinates.append([x, y])
    return coordinates


def query_direction(adjoining, inventory):
    """returnerer koordinatene til den raskaste vegen gjennom spelet basert på innhalde i inventaren"""

    # FEEDBACK: Svært bra

    if len(min_adjoining(adjoining)) > 1:
        # FEEDBACK: Det er betre å bruke denne først, og deretter bruke if len(candidates) > 1
        candidates = min_adjoining(adjoining)
        best_room = candidates[0]

        for room in candidates:

            if has_big_key(inventory):
                # FEEDBACK: Du bør ha kommentarer her: størst x, y nær null
                if room[0] > best_room[0]:
                    best_room = room
                elif room[0] == best_room[0]:
                    if abs(room[1]) < abs(best_room[1]):
                        best_room = room

            elif has_boomerang(inventory):
                # Minst y, x nær 0
                if room[1] < best_room[1]:
                    best_room = room
                elif room[1] == best_room[1]:
                    if abs(room[0]) < abs(best_room[0]):
                        best_room = room

            elif has_small_key(inventory):
                # Størst y, x nær 0
                if room[1] > best_room[1]:
                    best_room = room
                elif room[1] == best_room[1]:
                    if abs(room[0]) < abs(best_room[0]):
                        best_room = room

            else:
                # Minst x, y nær 0
                if room[0] < best_room[0]:
                    best_room = room
                elif room[0] == best_room[0]:
                    if abs(room[1]) < abs(best_room[1]):
                        best_room = room
        return best_room


    # Du kan eventuelt flytte dette alternativet øverst, slik at du ser når den blir utført. Altså
    # adjoining = min_adjoining(adjoining)
    # if len(adjoining) == 1:
    #     return adjoining[0]
    # else:
    return min_adjoining(adjoining)[0]  #kanskje ikkje lett å sjå, men dette blir returnert viss ingen av dei øvrige krava blir oppfyllt



def boss_fight():
    """Returnerer optimale avgjerelse basert på avstanden og aggresseviteten til 'bossen'"""
    # FEEDBACK: Svært bra

    while lost_puffling.boss_is_alive():
        if lost_puffling.boss_is_attacking():
            lost_puffling.hero_action('dodge')
        else:
            distance = lost_puffling.boss_distance()
            if distance >= 0 and distance < 2:
                lost_puffling.hero_action('slash')
            if distance < 4 and distance >= 2:
                lost_puffling.hero_action('jump slash')
            if distance >=4:
                lost_puffling.hero_action('bow')



def has_item(inventory, item_name):
    '''return True if item_name is in inventory and False otherwise.'''
    inventory = inventory.replace(' ', '').lower()
    item_name = item_name.replace(' ', '').lower()
    return (',' + item_name) in (',' + inventory)

def has_big_key(inventory):
    '''return True if the big key is in inventory and False otherwise.'''
    return has_item(inventory, 'big key')

def has_small_key(inventory):
    '''return True if the small key is in inventory and False otherwise.'''
    return has_item(inventory, 'small key')

def has_boomerang(inventory):
    '''return True if the boomerang is in inventory and False otherwise.'''
    return has_item(inventory, 'boomerang')

test_all(quiet=True)