# -*- coding: utf-8 -*-
# This file has been generated, if you wish to
# modify it in a permanent way, please refer
# to the script file : gen/generator_python.rb

from api import *
import time
import random

M = 0.

# Heuristiques

def objectif():
    (x, y) = ma_pos()
    quart = int(0.25 * TAILLE_TERRAIN)
    anti = TAILLE_TERRAIN - quart
    if x <= quart:
        if y <= quart:
            return (anti, quart)
        else:
            return (quart, quart)
    elif x >= anti:
        if y >= anti:
            return (quart, anti)
        else:
            return (anti, anti)

def rapporte_portail(portail):
    r = 0
    for champ in champs_incidents_portail(portail):
        r += score_triangle(champ.som1, champ.som2, champ.som3)
    return r

def rapporterait_portail(portail):
    r = 0
    l = [p for p in liste_portails() if portail_joueur(p) == portail_joueur(portail)]
    for p in l:
        if len(liens_bloquants(p, portail)) == 0:
            for champ in champs_incidents_segment(p, portail):
                r += score_triangle(champ.som1, champ.som2, champ.som3)
    return r
    
def rapporterait_lien(a, b):
    r = 0
    for champ in champs_incidents_segment(a, b):
        r += score_triangle(champ.som1, champ.som2, champ.som3)
    return r

def cout_capture(portail, joueur):
    d = distance(position_agent(joueur), portail)
    (pa, pm) = (0, 0)
    if d <= 6:
        pm = d
    else:
        pm = 6
        pa = (d - 6) * COUT_TURBO
    adv = adversaire() if joueur == moi() else moi()
    if portail_joueur(portail) == adv:
        pa += COUT_CAPTURE + COUT_NEUTRALISATION_BOUCLIER * portail_boucliers(portail) + COUT_NEUTRALISATION
    elif portail_joueur(portail) == joueur:
        pa += COUT_NEUTRALISATION
    return (pa, pm)

def nb_boucliers(portail):
    d = (distance_min(portail, adversaire()) // NB_POINTS_DEPLACEMENT) + 1
    return rapporte_portail(portail) // (4 * d)

# Utilitaires

def meilleur_portail(choix, pos):
    
    #A modifier 000000000000000000000000000000000000000000000000000000000
    
    l = [p for p in liste_portails() if portail_joueur(p) in choix and not case_dans_champ(p)]
    return max(l, key = lambda portail : note(portail, pos))
    
    if l != []:
        return max(l, key = lambda portail : rapporterait_portail(portail))
    else:
        l = [p for p in liste_portails() if portail_joueur(p) in choix]
        return min(l, key = lambda pos2 : distance(pos, pos2))

def chemin(depart, arrivee, pm):
    c = [depart[0], depart[1]]
    while pm >= 1 and c[0] != arrivee[0]:
        if c[0] > arrivee[0]:
            c[0] -= 1
        else:
            c[0] += 1
        pm -= 1
    while pm >= 1 and c[1] != arrivee[1]:
        if c[1] > arrivee[1]:
            c[1] -= 1
        else:
            c[1] += 1
        pm -= 1
    return (c[0], c[1])    

def ma_pos():
    return position_agent(moi())

def distance_min(pos, joueur):
    d = distance(pos, position_agent(joueur))
    l = [p for p in liste_portails() if portail_joueur(p) == joueur]
    for p in l:
        d = min(d, distance(p, pos))
    return d

# Action

def go_vers_meilleur_portail():
    p = meilleur_portail([-1, adversaire()], ma_pos())
    print("Meilleur", p)
    c = chemin(ma_pos(), p, NB_POINTS_DEPLACEMENT)
    print(deplacer(c))
    i = 0
    while points_action() >= COUT_TURBO and ma_pos() != p and i < 10:
        print("OK")
        c = chemin(ma_pos(), p, 1)
        print(utiliser_turbo())
        print(deplacer(c))
        i += 1

def note(portail, pos):
    n =  rapporterait_portail(portail)
    if portail_joueur(portail) == adversaire():
        n += rapporte_portail(portail) * 0.5
    
    (pa, pm) = cout_capture(portail, moi())
    cout = 6*pm + pa
    if cout <= NB_POINTS_ACTION:
        n *= 2
    n -= cout
    return n

# Fonction appelée au début de la partie.
def partie_init():
    pass # Place ton code ici

# Fonction appelée à chaque tour.
def jouer_tour():
    global M
    print("TOOOOOOOOOOOOOOUUUUUUUUUUUR ACTUEL", tour_actuel)
    t0 = time.time()
    i = 0
    total = min(NB_POINTS_ACTION / COUT_CAPTURE, 5)
    while i < total and (points_action() > COUT_CAPTURE or points_deplacement() > 0):
        i += 1
        print("Tour", i)
        # Phase 2 : on neutralise si besoin
        print("2", points_action())
        if points_action() >= COUT_CAPTURE and portail_joueur(ma_pos()) == adversaire():
            print("Neutralise", points_action())
            print(neutraliser())
        
        # Phase 3 : on capture
        print("3", points_action())
        if points_action() >= COUT_CAPTURE and portail_joueur(ma_pos()) == -1:
            print("CAPTURE", points_action(), moi())
            print(capturer())
            
        # Phase 4 : on créé tous les liens
        print("5", points_action())
        l = [p for p in liste_portails() if portail_joueur(p) == moi()]
        l.sort(key = lambda p : rapporterait_lien(ma_pos(), p) )
        l.reverse()
        for p in l:
            print(lier(p))
            
        # Phase 5 : boucliers
        nb = nb_boucliers(ma_pos())
        for k in range(nb - portail_boucliers(ma_pos())):
            if points_action() >= COUT_BOUCLIER:
                print(ajouter_bouclier())
        
        # Phase 1 : déplacement vers le portail le plus proche
        print("1", points_action())
        go_vers_meilleur_portail()
            
    M = max(time.time() - t0, M)
    print("Fin tour", tour_actuel(), time.time() - t0)
    pass # Place ton code ici

# Fonction appelée à la fin de la partie.
def partie_fin():
    global M
    print(M)
    pass # Place ton code ici
