def get_syntax_template(entity):
    if not entity:
        log.bug("entity non è un parametro valido: %r" % entity)
        return ""

    # -------------------------------------------------------------------------

    syntax = ""

    syntax += "restring <nome o codice entità>\n"
    syntax += "restring <nome o codice entità> KeywordsName <nuove chiavi>\n"
    syntax += "restring <nome o codice entità> KeywordsShort <nuove chiavi>\n"
    syntax += "restring <nome o codice entità> KeywordsShortNight <nuove chiavi>\n"
    syntax += "restring <nome o codice entità> Name <nuovo nome>\n"
    syntax += "restring <nome o codice entità> Short <nuova short>\n"
    syntax += "restring <nome o codice entità> ShortNight <nuova short>\n"
    syntax += "restring <nome o codice entità> Long <nuova long>\n"
    syntax += "restring <nome o codice entità> LongNight <nuova long>\n"
    syntax += "restring <nome o codice entità> Descr <nuova descrizione>\n"
    syntax += "restring <nome o codice entità> DescrNight <nuova descrizione>\n"
    syntax += "restring <nome o codice entità> DescrHearing <nuova descrizione>\n"
    syntax += "restring <nome o codice entità> DescrHearingNight <nuova descrizione>\n"
    syntax += "restring <nome o codice entità> DescrSmell <nuova descrizione>\n"
    syntax += "restring <nome o codice entità> DescrSmellNight <nuova descrizione>\n"
    syntax += "restring <nome o codice entità> DescrTouch <nuova descrizione>\n"
    syntax += "restring <nome o codice entità> DescrTouchNight <nuova descrizione>\n"
    syntax += "restring <nome o codice entità> DescrTaste <nuova descrizione>\n"
    syntax += "restring <nome o codice entità> DescrTasteNight <nuova descrizione>\n"
    syntax += "restring <nome o codice entità> DescrSixth <nuova descrizione>\n"
    syntax += "restring <nome o codice entità> DescrSixthNight <nuova descrizione>\n"

    return syntax

def nifty_value_search(dictionary, argument):
    if not dictionary:
        log.bug("dictionary non è un parametro valido: %r" % dictionary)
        return

    if not argument:
        log.bug("argument non è un parametro valido: %r" % argument)
        return

    # -------------------------------------------------------------------------

    try:
        return dictionary[argument]
    except KeyError:
        # Se non ha trovato nulla allora prova a trovare in maniera
        # intelligente una chiave simile all'argomento passato
        pass

    argument = argument.lower()

    for key in dictionary:
        if is_same(argument, key):
            return dictionary[key]

    for key in dictionary:
        if is_prefix(argument, key):
            return dictionary[key]

    return None

def command_score(entity, argument="", behavioured=False):
    """
    Permette di visualizzare il proprio stato.
    """
    if not entity:
        log.bug("entity non è un parametro valido: %r" % entity)
        return False

    # -------------------------------------------------------------------------

    if argument and entity.trust >= TRUST.MASTER:
        target = entity.find_entity(argument, entity_tables=["players", "mobs"])
        if not target:
            entity.send_output("Non è stato trovato nessun giocatore o mob con argomento [white]%s[close]" % argument)
            return False
        target = target.split_entity(1)
    else:
        target = entity.split_entity(1)

    output = get_score_output(entity, target)
    if not output:
        log.bug("Inatteso output non valido con entity %s e target %s: %r" % (entity.code, target.code, output))
        return False
    entity.send_output(output)

    return True

def reverse_one_argument(argument, search_separator=True):
    """
    Come la one_argument, ma esegue la ricerca partendo dal fondo.
    """
    if not argument:
        if argument != "":
            log.bug("argument non è un parametro valido: %r" % argument)
        return "", ""

    # -------------------------------------------------------------------------

    separator = " "
    end = len(argument)
    if search_separator and argument[-1] == '"':
        separator = '"'
        end = len(argument) - 1
    elif search_separator and argument[-1] == "'":
        separator = "'"
        end = len(argument) - 1
    elif argument[-1] == " ":
        log.bug("argument finisce con uno spazio: %s" % argument)
        end = len(argument) - 1

    length = 0
    for c in reversed(argument[ : end]):
        if c == separator:
            break
        length += 1

    return argument[ : end-length].strip(), argument[end-length : end].strip()

def dice(argument, for_debug=None):
    if not argument:
        log.bug("argument non è un parametro valido: %r" % argument)
        return 0

    # -------------------------------------------------------------------------

    argument = argument.lower()
    if "d" in argument:
        dice_qty, dice_size = argument.split("d", 1)
    else:
        log.bug("Non è stata passata un'espressione dice valida: %s (for_debug=%s)" % (argument, for_debug))
        return 0

    addend = ""
    if "+" in dice_size:
        dice_size, addend = dice_size.rsplit("+", 1)
    elif "-" in dice_size:
        dice_size, addend = dice_size.rsplit("-", 1)
        addend = "-" + addend

    dice_qty  = int(dice_qty)
    dice_size = int(dice_size)
    addend    = int(addend)

    result = 0
    while dice_qty > 0:
        result += random.randint(1, dice_size)
        dice_qty -= 1
    return result + addend

def renew(fruttificato, room, age, fortuna):

    if fruttificato.code not in database["items"]:
        return

    pianta = Item("karpuram_item_mirtillo-rosso-03-pianta")
    if not pianta:
        log.bug("impossibile creare pianta: %r" % pianta)
        return

    age = age +1
    location=fruttificato.location

    fruttificato.act("quel che un tempo doveva esser $N, ora ...", TO.OTHERS, fruttificato)
    fruttificato.act("quel che un tempo doveva esser $N, ora ...", TO.ENTITY, fruttificato)
    fruttificato.extract(1)

    pianta.inject(location)

    pianta.act("... è $N che fruttificherà più avanti", TO.OTHERS, pianta)
    pianta.act("... è $N che fruttificherà più avanti", TO.ENTITY, pianta)
    
    fortuna = fortuna -1
    if random.randint(1, fortuna) == 1:
        reactor.callLater(random.randint(10,20), desiccation, pianta, room, age )
        return
    reactor.callLater(random.randint(10,20), blooming, pianta, room, age, fortuna)

def get_syntax_template_handler(entity, command_name):
    """
    Esiste per essere chiamata anche dal comando command_skills e command_socials
    """
    if not entity:
        log.bug("entity non è un parametro valido: %r" % entity)
        return ""

    if not command_name:
        log.bug("command_name non è un parametro valido: %r" % command_name)
        return ""

    # -------------------------------------------------------------------------

    syntax = ""

    syntax +=  "%s\n" % command_name
    syntax += "%s italiano\n" % command_name
    syntax += "%s inglese\n" % command_name
    syntax += "%s traduzione\n" % command_name
    if command_name == "commands":
        syntax += "%s tipi\n" % command_name
    if entity.trust >= TRUST.MASTER:
        syntax += "%s fiducia\n" % command_name
    syntax += "%s <comando cercato>\n" % command_name

    return syntax

def send_input(entity, argument, lang="", show_input=True, show_prompt=True):
    """
    Invia un input preoccupandosi di convertirlo prima nella lingua corretta
    per essere trovata dall'interprete.
    E' importante che l'argomento lang sia corrispondente alla lingua dell'input
    in argument.
    """
    if not entity:
        log.bug("entity non è un parametro valido: %r" % entity)
        return ""

    if not argument:
        log.bug("argument non è un parametro valido: %r" % argument)
        return ""

    if lang != "it" and lang != "en" and lang != "":
        log.bug("lang non è un parametro valido: %r" % lang)
        return ""

    if show_input != True and show_input != False:
        log.bug("show_input non è un parametro valido: %r" % show_input)
        return ""

    if show_prompt != True and show_prompt != False:
        log.bug("show_prompt non è un parametro valido: %r" % show_prompt)
        return ""

    # -------------------------------------------------------------------------

    args = argument.split()
    args[0] = translate_input(entity, args[0], lang)
    argument = " ".join(args)

    # Invia il comando ottenuto all'interprete
    interpret(entity, argument, show_input=show_input, show_prompt=show_prompt)

    def __init__(self, direction=DIR.NONE):
        if not direction:
            log.bug("direction non è un parametro valido: %r" % direction)
            return

        # ---------------------------------------------------------------------

        self.comment             = ""  # Eventuale commento al muro
        self.direction           = Element(direction)  # Tipologia della direzione
        self.maked_by            = None  # Oggetto di base utilizzato nella costruzione del muro (di solito un mattone o una pietra)
        self.depth               = 0   # Profondità della parete, assieme al tipo di materiale in quella direzione ne fanno la forza, che serve nel caso si voglia romperlo, picconarlo, sfondarlo o farlo saltare in aria!
        self.height              = 0   # Altezza del muro, se differente dall'altezza della stanza
        self.descr               = ""  # Descrizione dell'uscita che viene a formarsi quando il muro viene sfondato
        self.descr_night         = ""  # Descrizione notturna dell'uscita che viene a formarsi quando il muro viene sfondato
        self.descr_hearing       = ""  # Descrizione uditiva
        self.descr_hearing_night = ""  # Descrizione uditiva notturna
        self.descr_smell         = ""  # Descrizione odorosa
        self.descr_smell_night   = ""  # Descrizione odorosa notturna
        self.descr_touch         = ""  # Descrizione tattile
        self.descr_touch_night   = ""  # Descrizione tattile notturna
        self.descr_taste         = ""  # Descrizione del sapore
        self.descr_taste_night   = ""  # Descrizione del sapore notturna
        self.descr_sixth         = ""  # Descrizione del sesto senso
        self.descr_sixth_night   = ""  # Descrizione del sesto senso notturna
        self.extras              = Extras()  # Elenco delle extra che si possono guardare o leggere sul muro

def interpret_or_echo(entity, argument, looker=None, behavioured=False):
    if not entity:
        log.bug("entity non è un parametro valido: %r" % entity)
        return

    if not argument:
        log.bug("argument non è un parametro valido: %r" % argument)
        return

    # -------------------------------------------------------------------------

    if MIML_SEPARATOR in argument:
        argument = entity.parse_miml(argument)
    if not argument:
        return

    if "$" in argument:
        argument = looker.replace_act_tags(argument, target=entity)
    if "$" in argument:
        argument = looker.replace_act_tags_name(argument, looker=looker, target=entity)

    original_argument = argument
    arg, argument = one_argument(argument)

    input, huh_input, lang = multiple_search_on_inputs(entity, arg, exact=True)
    if input:
        interpret(entity, original_argument, use_check_alias=False, show_input=False, show_prompt=False, behavioured=behavioured)
    else:
        entity.location.echo(original_argument)

def check_position(entity, position, force_position=True):
    """
    Controlla che la posizione del comando passata sia adatta a quella che
    l'entità ha in questo momento.
    Viene passata force_position a False quando bisogna evitare ricorsioni.
    """
    if not entity:
        log.bug("entity non è un parametro valido: %r" % entity)
        return False

    if not position:
        log.bug("position non è un parametro valido: %r" % position)
        return False

    # -------------------------------------------------------------------------

    # Se un mob non può eseguire il comando allora cerca di mettersi
    # nella posizione adatta ad eseguirlo
    if force_position and not entity.IS_PLAYER and entity.position < position:
        if position == POSITION.SLEEP:
            command_sleep(entity, argument)
        elif position == POSITION.REST:
            command_rest(entity, argument)
        elif position == POSITION.KNEE:
            command_knee(entity, argument)
        elif position == POSITION.SIT:
            command_sit(entity, argument)
        elif position == POSITION.STAND:
            command_stand(entity, argument)

    # Se la posizione dell'entità è corretta allora può eseguire il comando
    if entity.position >= position:
        return True

    return False

def get_formatted_equipment_list(entity, target, show_header=True, show_footer=True):
    if not entity:
        log.bug("entity non è un parametro valido: %r" % entity)
        return ""

    if not target:
        log.bug("target non è un parametro valido: %r" % target)
        return ""

    # -------------------------------------------------------------------------

    output = get_equipment_list(entity, target)

    if show_header:
        if target == entity:
            if output:
                output = ["[red]Stai utilizzando[close]:\n"] + output
            else:
                output.append("Non stai utilizzando nulla, sei %s!\n" % entity.skin_colorize("nud$o"))
        else:
            if output:
                output = ["%s [red]sta utilizzando[close]:\n" % color_first_upper(target.get_name(entity))] + output
            else:
                output.append("%s non sta utilizzando nulla, è %s!\n" % (
                    color_first_upper(target.get_name(looker=entity)),
                    target.skin_colorize("nud%s" % grammar_gender(target))))

    if show_footer:
        carry_equip_descr = get_weight_descr(target.get_equipped_weight())
        output.append(create_demi_line(entity))
        output.append("Stai indossando un peso totale di %s." % carry_equip_descr)

    return "".join(output)

def defer_random_time(min_time, max_time, function, *args):
    """
    Funzione che viene utilizzata quando si vogliono eseguire dei comandi dopo
    un certo tot di tempo.
    """
    if min_time < 0:
        log.bug("min_time non è un parametro valido perchè minore di 0: %d" % min_time)
        return

    if max_time < min_time:
        log.bug("max_time non è un parametro valido perchè minore di min_time %d: %d" % (min_time, max_time))
        return

    # -------------------------------------------------------------------------

    if config.time_warp:
        time = 1
    else:
        if min_time == max_time:
            time = min_time
        else:
            time = random.randint(min_time, max_time)

    key = get_key()
    _before_defer(key, function, *args)
    return task.deferLater(reactor, time, _after_defer, key, function, *args)

def _get_already_deferred_arg(deferred_params, arg):
    if not deferred_params:
        log.bug("deferred_params non è un parametro valido: %r" % deferred_params)
        return False, None

    if not arg:
        log.bug("arg non è un parametro valido: %r" % arg)
        return False, None

    # -------------------------------------------------------------------------

    for deferred_entities in deferred_params:
        for deferred_entity in deferred_entities:
            if not deferred_entity():
                return False, None
            if deferred_entity() == arg:
                #if arg.prototype.code == "ikea_item_uovo-gallina":
                #    f = open("gallina.txt", "a")
                #    buf = "impostata la deferred_entity alla _after_defer: %r / %r, %r / %r, %d / %d, %r / %r, %r / %r\n" % (
                #        arg.code, deferred_entities[-1].code, arg.location, deferred_entities[-1].location, arg.quantity, deferred_entities[-1].quantity,
                #        FLAG.EXTRACTED in arg.flags, FLAG.EXTRACTED in deferred_entities[-1].flags, FLAG.WEAKLY_EXTRACTED in arg.flags, FLAG.WEAKLY_EXTRACTED in deferred_entities[-1].flags)
                #    f.write(buf)
                #    print buf
                #    import traceback
                #    traceback.print_stack(file=f)
                #    f.close()
                return True, arg

    return False, None

 def get_error_message(self):
     """
     Ritorna un messaggio di errore se qualcosa nel comando è sbagliata,
     altrimenti se tutto è a posto ritorna una stringa vuota.
     """
     if not self.fun_name:
         msg = "il nome della funzione non è valido"
     elif (not self.fun_name.startswith("command_")
     and   not self.fun_name.startswith("skill_")
     and   not self.fun_name.startswith("social_")):
         msg = "il nome della funzione non inizia per command_, skill_ o social_"
     elif self.type.get_error_message(CMDTYPE, "type") != "":
         msg = self.type.get_error_message(CMDTYPE, "type")
     elif self.trust.get_error_message(TRUST, "trust") != "":
         msg = self.trust.get_error_message(TRUST, "trust")
     elif self.position.get_error_message(POSITION, "position") != "":
         msg = self.position.get_error_message(POSITION, "position")
     elif self.flags.get_error_message(CMDFLAG, "flags") != "":
         msg = self.flags.get_error_message(CMDFLAG, "flags")
     elif self.no_races.get_error_message(RACE, "no_races") != "":
         msg = self.no_races.get_error_message(RACE, "no_races")
     # Ignora i minihelp vuoti relativi ai comandi-social
     elif not self.mini_help and not self.fun_name.startswith("social_"):
         msg = "la stringa di mini help è vuota"
     elif self.timer < 0.0:
         msg = "il timer non può essere negativo: %f" % self.timer
     elif not self.module:
         msg = "modulo non importato"
     elif not self.function:
         msg = "funzione non importata"
     else:
         return ""
     # Se arriva qui significa che ha un messaggio da inviare
     log.bug("(Command: fun_name %s) %s" % (self.fun_name, msg))
     return msg

def blooming(pianta, room, age, fortuna):

    if pianta.code not in database["items"]:
        return

    fiore = Item("karpuram_item_mirtillo-rosso-04-fiore")
    if not fiore:
        log.bug("impossibile creare fiore: %r" % fiore)
        return

    location=pianta.location

    pianta.act("Nelle scorse ore $N ha aperto i fiori", TO.OTHERS, pianta)
    pianta.act("Nelle scorse ore $N ha aperto i fiori", TO.ENTITY, pianta)
    pianta.extract(1)

    fiore.inject(location)

    fiore.act("$N rifulge di tutto il suo splendore.", TO.OTHERS, fiore)
    fiore.act("$N rifulge di tutto il suo splendore.", TO.ENTITY, fiore)
    fortuna = fortuna -1
    if random.randint(1, fortuna) == 1:
        reactor.callLater(random.randint( FLOWER_WAIT_MIN , FLOWER_WAIT_MAX ), desiccation, fiore, room, age )
        return
    reactor.callLater(random.randint( FLOWER_WAIT_MIN , FLOWER_WAIT_MAX ),fructification , fiore, room, age, fortuna)

def look_for_caterpillar(dust, show_act=True):
    if not dust:
        log.bug("dust non è un parametro valido: %r" % dust)
        return

    caterpillar = dust.find_entity("bruco", dust.location, ["mobs"])
    if not caterpillar:
        if show_act:
            dust.act("My name is $n: niente bruchi" % dust, TO.OTHERS)
            dust.act("My name is $n: niente bruchi" % dust, TO.ENTITY)

        defer(60, look_for_caterpillar, dust)
        return

    if show_act:
        dust.act("My name is $n, ho visto un bruco: %r" % caterpillar, TO.OTHERS)
        dust.act("My name is $n, ho visto un bruco: %r" % caterpillar, TO.ENTITY)
        command_say(caterpillar, "sa la vist cus'è?")

    #defer(60, look_for_caterpillar, dust)
    # il bruco potrebbe essere soggetto a script che lo potrebbero mutare senza
    # avvisaglie quindi tolgo di mezzo il bruco per sostituirlo con un altro
    # che so non essere afflitto da script
    location = caterpillar.location
    caterpillar.extract(1)
    new_caterpillar = Mob(PROTO_CATERPILLAR_CODE)
    new_caterpillar.inject(location)
    new_caterpillar.act("$n cambia aspetto in modo repentino.", TO.OTHERS)

    dust_eating(dust, new_caterpillar)

def marciume(seed, room):

    if seed.code not in database["items"]:
        return
    frutto_marcio = Item("karpuram_item_mirtillo-rosso-00-frutto-marcio")
    if not frutto_marcio:
        log.bug("impossibile creare frutto_marcio: %r" % frutto_marcio)
        return

    if room != seed.location:
        # log da rimuovere 
        log.bug("room di drop diversa da room attuale")
        return

    location=seed.location

    seed.act("$N appare tutto molliccio...", TO.OTHERS, seed)
    seed.act("$N appare tutto molliccio...", TO.ENTITY, seed)

    seed.extract()

    frutto_marcio.inject(location)

    frutto_marcio.act("... è $N buono solo come concime.", TO.OTHERS, frutto_marcio)
    frutto_marcio.act("... è $N buono solo come concime.", TO.ENTITY, frutto_marcio)

def check_if_part_is_already_weared(entity, part):
    if not entity:
        log.bug("entity non è un parametro valido: %r" % entity)
        return None, None

    if not part:
        log.bug("part non è un parametro valido: %r" % part)
        return None, None

    # -------------------------------------------------------------------------

    # Dà prima la precedenza alle entità layerate così da ritornare l'entità
    # più esterna nella stratificazione dei vestiti
    for possession in entity.iter_contains():
        if not possession.under_weared or not possession.under_weared():
            continue
        if FLAG.INGESTED in possession.flags:
            continue
        for location in possession.wear_mode:
            if location == part:
                return part, possession

    for possession in entity.iter_contains():
        if FLAG.INGESTED in possession.flags:
            continue
        for location in possession.wear_mode:
            if location == part:
                return part, possession

    return None, None

def pretty_list(list_to_convert):
    """
    Ritorna una frase descrivendo un elenco, separato da virgole o dalla
    congiunzione 'e', partendo da una lista di stringhe.
    """
    if not list_to_convert:
        log.bug("list_to_convert non è un parametro valido: %r" % list_to_convert)
        return

    # -------------------------------------------------------------------------

    if len(list_to_convert) == 1:
        return str(list_to_convert[0])

    arguments = []
    for argument in list_to_convert:
        argument = str(argument).strip()
        if len(list_to_convert) >= 2 and argument == str(list_to_convert[-1]):
            arguments.append(" e " + argument)
        else:
            if argument == str(list_to_convert[0]):
                arguments.append(argument)
            else:
                arguments.append(", " + argument)

    return "".join(arguments)