from asci_lib import Asci, print_text
from random import randint
from math import floor, ceil

from asgard import *
from vanaheim import *
from alfheim import *
from midgard import *
from niflheim import *
from jotunheim import *
from nidavellir import *
from muspellheim import *
from svartalfheim import *


maps = (
    asgard,
    vanaheim,
    alfheim,
    midgard,
    niflheim,
    jotunheim,
    nidavellir,
    muspellheim,
    svartalfheim,
    h_9, h_10, h_11, h_12, h_13, h_14, h_15, h_16, h_17, h_18, h_19, h_20,
    h_21, h_22,
    h_23, h_24,
    h_25, h_26, h_27, h_28,
    h_29, h_30,
    h_31, h_32, h_33, h_34, h_35, h_36,
    h_37, h_38, h_39, h_40, h_41,
    h_42, h_43, h_44,
    h_45, h_46, h_47, h_48)

# Asci functions
def npc(data, stat):
    npc_data = (
    asgard_npc,
    vanaheim_npc,
    alfheim_npc,
    midgard_npc,
    niflheim_npc,
    jotunheim_npc,
    nidavellir_npc,
    muspellheim_npc,
    svartalfheim_npc,
    h_9_npc, h_10_npc, h_11_npc, h_12_npc, h_13_npc, h_14_npc, h_15_npc, h_16_npc, h_17_npc, h_18_npc, h_19_npc, h_20_npc,
    h_21_npc, h_22_npc,
    h_23_npc, h_24_npc,
    h_25_npc, h_26_npc, h_27_npc, h_28_npc,
    h_29_npc, h_30_npc,
    h_31_npc, h_32_npc, h_33_npc, h_34_npc, h_35_npc, h_36_npc,
    h_37_npc, h_38_npc, h_39_npc, h_40_npc, h_41_npc,
    h_42_npc, h_43_npc, h_44_npc,
    h_45_npc, h_46_npc, h_47_npc, h_48_npc)


    event = npc_data[data[1]](data, stat)

    if not event:
        return [0, "Hmm ?"]

    elif type(event) == tuple:
        issue = fight(stat, event[0], event[1])

        if issue == 0:
            stat[1] += event[2]
            if sum(stat[2][:-1]) >= 200: return [1, "Vous avez gagne le combat. [+{}PO]".format(event[2])]
            
            print_text("Vous avez gagne le combat. [+{}PO]".format(event[2]))
            data[0] += 1
            choice = 0
            while not choice:
                print("<o> Amelioration  <o>")
                print(" |1. Vitesse       |")
                print(" |2. Agilite       |")
                print(" |3. Attaque       |")
                print(" |4. Defense       |")
                print("<o> ============= <o>")
                choice = get_input()
                if (choice < 0 or choice > 4) and stat[2][choice - 1] >= 50: choice = 0

            print_text("Vous gagnez 2 points {}".format(("de vitesse", "d'agilite", "d'attaque", "de defense")[choice - 1]))
            stat[2][choice - 1] += 2
            if stat[2][choice -1] > 50: stat[2][choice - 1] = 50
            
            return None

        elif issue == 1: return [0, "Vous etes mort."]
        elif issue == 2: return [0, "Vous avez fuit."]
    
    else:
        return event


def point_of_interest(data, stat):
    po_data = (
        asgard_po,
        vanaheim_po,
        alfheim_po,
        midgard_po,
        niflheim_po,
        jotunheim_po,
        nidavellir_po,
        muspellheim_po,
        svartalfheim_po
    )

    coords = data[2], data[3]

    event = po_data[data[1]](coords)

    if not event: return [0, "Il n'y a rien à voir ici."]
    else: return event


def routine(data, stat):
    stat[4] = (stat[4] + 1) % 1440

    # Mana regeneration
    if stat[2][4] < stat[0] // 2 and not (stat[4] % 60):
        stat[2][4] += 1


# Game mecanics
def fight(stat, opponent_stat, opponent_name):

    def player_turn():
        end = False
        msg = "Tour de {}".format(stat[5])
        
        if choice == 1:
            damage = stat_test(player_stat, 2)[1] - opponent_stat[3]
            if damage < 0: damage = 0
            
            if damage == 0:
                msg += "\n{} bloque l'attaque.".format(opponent_name)
            elif stat_test(opponent_stat[:-1], 1)[0]:
                msg += "\n{} esquive le coup.".format(opponent_name)
            else:
                opponent_stat[4] -= damage
                msg += "\n{0} perd {1} PV.".format(opponent_name, damage)

        elif choice == 2:
            if len(stat[7]) == 0:
                msg += "\nVous ne connaissez pas de sort."
            else:
                spell_data = ("Soin", "Flammes", "Givre", "Etincelles", "Fatigue")
                spell_level = ("I", "II", "III", "IV", "V")

                spell_choice = 0
                while not spell_choice:
                    print("\n" * 6 + "Sort(s) connu(s) :")
                    count = 0
                    for spell_id, level in stat[7]:
                        print("{0}. {1} {2}".format(count + 1, spell_data[spell_id], spell_level[level - 1]))
                        count += 1
                    spell_choice = get_input()
                    if spell_choice < 0 or spell_choice > 3: spell_choice = 0

                spell_choice -= 1
                name, level = spell_data[stat[7][spell_choice][0]], stat[7][spell_choice][1]

                if stat[2][4] >= level * 10:
                    msg += "\nVous lancez {0} de niveau {1} [-{2} PM].".format(name, spell_level[level - 1], level * 10)
                    stat[2][4] -= level * 10
                    pts = 12 * level + randint(-5, 5)

                    if stat[7][spell_choice][0] == 0:
                        stat[0] += pts
                        msg += "\nVous gagnez {} PV".format(pts)
                    
                    elif stat[7][spell_choice][0] == 1:
                        opponent_stat[4] -= pts
                        msg += "\n{0} perd {1} PV".format(opponent_name, pts)
                    
                    elif stat[7][spell_choice][0] == 2:
                        opponent_stat[4] -= pts
                        msg += "\n{0} perd {1} PV".format(opponent_name, pts)
                    
                    elif stat[7][spell_choice][0] == 3:
                        opponent_stat[4] -= pts
                        msg += "\n{0} perd {1} PV".format(opponent_name, pts)
                    
                    elif stat[7][spell_choice][0] == 4:
                        opponent_stat[0] -= pts
                        msg += "\n{0} perd {1} points de vitesse".format(opponent_name, 12 * level)

                else:
                    msg += "\nVous ne parvenez pas a lancer le sort."

        elif choice == 3:
            if stat_test(player_stat, 1)[0]:
                end = True
            else:
                msg += "\nVotre tentative de fuite echoue."

        print_text(msg)
        return end

    def opponent_turn():
        msg = "Tour de {}".format(opponent_name)
        damage = stat_test(opponent_stat, 2)[1] - player_stat[3]
        if damage < 0: damage = 0

        if damage == 0:
            msg += "\n{} bloque l'attaque.".format(stat[5])
        elif stat_test(player_stat, 1)[0]:
            msg += "\n{} esquive le coup.".format(stat[5])
        else:
            stat[0] -= damage
            msg += "\n{0} perd {1} PV.".format(stat[5], damage)

        print_text(msg)

    # opponent_stat = [vitesse, agilité, attaque, défense, vie]
    # player_stat = [vitesse, agilité, attaque, défense]
    player_stat = [stat[2][0], stat[2][1], stat[2][2] + stat[3][0] * 5, stat[2][3] + stat[3][1] * 5]

    player = opponent = 0

    end = False
    while not end:
        choice = 0
        while not choice:
            print("<o>    Combat     <o>")
            print(" | 1. Attaquer     |")
            print(" | 2. Ensorceler   |")
            print(" | 3. Fuir         |")
            print(" | 4. Statistiques |")
            print("<o> ============= <o>")
            choice = get_input()
            if choice < 0 or choice > 4: choice = 0

            if choice == 4:
                p_capacities = ["{} ".format(i) if i < 10 else str(i) for i in player_stat]
                o_capacities = ["{} ".format(i) if i < 10 else str(i) for i in opponent_stat[:-1]]

                p_health = str(stat[0]) + " " * (3 - len(str(stat[0])))
                o_health = str(opponent_stat[4]) + " " * (3 - len(str(opponent_stat[4])))

                print("  Joueur | Ennemi")
                print("Vit: {0}  | {1}".format(p_capacities[0], o_capacities[0]))
                print("Agi: {0}  | {1}".format(p_capacities[1], o_capacities[1]))
                print("Att: {0}  | {1}".format(p_capacities[2], o_capacities[2]))
                print("Def: {0}  | {1}".format(p_capacities[3], o_capacities[3]))
                print("Vie: {0} | {1}".format(p_health, o_health))
                input()
                choice = 0

        # Who start
        while player == opponent:
            player = stat_test(player_stat, 0)[1]
            opponent = stat_test(opponent_stat[:-1], 0)[1]

        # Fight
        if player > opponent:
            end = player_turn()
            if end: return 2
            if opponent_stat[4] <= 0: return 0
            opponent_turn()
        
        else:
            opponent_turn()
            if stat[0] <= 0: return 1 
            end = player_turn()

        if opponent_stat[4] <= 0: return 0
        if stat[0] <= 0: return 1

    return 2


def misc_stat(data, stat):
    if data[1] < 9: place = ("Asgard", "Vanaheim", "Alfheim", "Midgard", "Niflheim", "Jotunheim", "Nidavellir", "Muspellheim", "Svartalfheim")[data[1]]
    else: place =  "interieur"
    money, ticks, player_class = stat[1], stat[4], stat[6]
    
    hours = ticks // 60
    if 4 <= hours <= 5:
        hours = " |aube - {}h".format(hours)
    elif 6 <= hours <= 12:
        hours = " |matin - {}h".format(hours)
    elif 13 <= hours <= 18:
        hours = " |apres-midi - {}h".format(hours)
    elif 19 <= hours <= 20:
        hours = " |crepuscule - {}h".format(hours)
    else:
        hours = " |nuit - {}h".format(hours)

    player_class = (" |Guerrier", " |Voleur", " |Moine", " |Mage", " |Assassin")[player_class]

    money = " |Argent: {} PO".format(money)

    print("<o> Informations  <o>")
    print(" |" + center(place, 17, " ") + "|")
    print(player_class + " " * (19 - len(player_class)) + "|")
    print(hours + " " * (19 - len(hours)) + "|")
    print(money + " " * (19 - len(money)) + "|")
    print("<o> ============= <o>")
    input()


def display_stat(data, stat):
        capacities = ["{} ".format(i) if i < 10 else str(i) for i in stat[2]]

        first_line = " |Vit : {0} Agi : {1}|".format(capacities[0], capacities[1])
        second_line = " |Att : {0} Def : {1}|".format(capacities[2], capacities[3])
        health = " |Vie : {} PV".format(stat[0])
        mana = " |Magie : {} PM".format(stat[2][4])

        print("<o> {} <o>".format(center(stat[5], 13, " ")))
        print(first_line)
        print(second_line)
        print(mana + " " * (19 - len(mana)) + "|")
        print(health + " " * (19 - len(health)) + "|")
        print("<o> ============= <o>")
        input()


def inventory(data, stat):
    weapon = ("<aucune>", "Dague", "Marteau", "Masse", "Fleau", "Hache", "Epee", "Espadon", "Hache double")[stat[3][0]]
    shield = ("<aucune>", "Rondache", "Pavois", "Cote de maille", "Broigne", "Harnois")[stat[3][1]]

    weapon = " |" + weapon + " " * (17 - len(weapon)) + "|"
    shield = " |" + shield + " " * (17 - len(shield)) + "|"

    print("<o>  Inventaire   <o>")
    print(" |- Arme :         |\n{}".format(weapon))
    print(" |- Armure :       |\n{}".format(shield))
    print("<o> ============= <o>")
    input()


def sleep(data, stat):
    if 360 < stat[4] < 1140:
        print_text("Vous ne pouvez pas dormir de jour.")
        return

    stat[4] = 360

    # If the player is at home
    if data[1] == 27:
        if stat[0] < 100: stat[0] += 10
        stat[2][4] += 2

    print_text("Vous vous reposez.")


def spell(data, stat):
    spell_data = ("Soin", "Flammes", "Givre", "Etincelles", "Fatigue")
    spell_level = ("I", "II", "III", "IV", "V")

    to_disp = "Magie : {} PM".format(stat[2][4])
    print("<o>    Sorts     <o>")
    print(" |" + to_disp + " " * (16 - len(to_disp)) + "|")

    for i in range(3):
        if i < len(stat[7]):
            spell_id, level = stat[7][i]
            if spell_id >= 0:
                to_disp = "{0} {1}".format(spell_data[spell_id], spell_level[level - 1])
                print(" |" + to_disp + " " * (16 - len(to_disp)) + "|")
        else:
            print(" |<aucun>         |")

    print("<o> ============ <o>")
    input()


events = {"*": npc, "?": point_of_interest}
keys = {4: display_stat, 7: spell, 8:misc_stat, 6: inventory, 9: sleep}

# Main function
def idk(stat=None, data=None):
    # stat = [0 - PV, 1 - pièces d'or, 2 - [vitesse, agilité, attaque, defense, magie], 3 - [arme, armure], 4 - ticks, 5 - nom, 6 - classe, 7 - sorts connus : (id, level), 8 - sous-quête en cours]
    if not stat:
        name = ""
        while len(name) == 0 or len(name) > 13:
            name = input("Entrez votre nom :\n>")

        player_class = 0
        while(not player_class):
            print("Choisissez une classe\n1. Guerrier\n2. Voleur\n3. Moine\n4. Mage\n5. Assassin")
            player_class = get_input()
            if player_class < 0 or player_class > 5: player_class = 0

        if player_class == 1:
            stat = [5, 5, 10, 5, 5]
        elif player_class == 2:
            stat = [5, 10, 5, 5, 5] 
        elif player_class == 3:
            stat = [5, 5, 5, 10, 5]
        elif player_class == 4:
            stat = [5, 5, 5, 5, 20]
        elif player_class == 5:
            stat = [10, 5, 5, 5, 5]

        stat = [100, 1000, stat, [0, 0], 360, name, player_class - 1, [], 0, -1]
        if player_class == 4:
            stat[7].append((1, 1))
        data = [0, 3, 44, 66]

    else:
        stat.append(-1)

        # Money check
        if stat[1] < 0: stat[1] = 0
        if stat[1] > 100000: stat[1] = 100000

        # Stat check
        for i in range(len(stat[2])):
            if stat[2][i] > 50: stat[2][i] = 50
            if stat[2][i] < 0: stat[2][i] = 0

        # Player's class check
        if not (0 <= stat[6] <= 5):
            raise ValueError("unknown player's class")

    idk_game = Asci(maps, events, keys)
    stat, data = idk_game.mainloop(100, stat, data, routine=routine, door="^_", walkable=".,`' ", exit_key="q")

    print("idk({0}, {1})".format(stat[:-1], data))


# Misc function
def get_input():
    string = input(">")
    try:
        return int(string)
    except:
        return 0


def center(string, total_length, symbol):
    left = floor((total_length - len(string)) / 2)
    right = ceil((total_length - len(string)) / 2)

    return left * symbol + string + right * symbol


def stat_test(stat, test_id):
    score = (80 + randint(-20, 20)) * stat[test_id] / 50
    return randint(1, 100) <= score, floor(score)