########################################################################################################################################
#--------------------------------------------------------------------------------------------------------------------------------------#
#|                                                     Guild Manager Plugin                                                           |#
#|                                                        Author: Mwthorn                                                             |#
#|                                                        Author: mspro1                                                              |#
#|                                                         Version: 0.1                                                               |#
#--------------------------------------------------------------------------------------------------------------------------------------#
########################################################################################################################################

#-----------------------------------------------------------------------------------------------------------------#
# NOTE: Please run init before use others commands /ex run GMInit                                                     #
#-----------------------------------------------------------------------------------------------------------------#

GMInit:
    type: task
    debug: false
    script:
        - yaml create id:guilddatabase
        - yaml savefile:guilddatabase.yml id:guilddatabase
        - narrate "<gold>[Guild] <red>Guild files succefully created."

GMData:
    type: yaml data
    debug: false
    config:
        chat_system: "true"
        # TODO
        namemaxlength: 30
        nameminlength: 3
        maxmembers: 8
        commands:
            main: "guild"
            args:
                help: "help"
                create: "create"
                info: "info"
                list: "list"
                leave: "leave"
                accept: "accept"
                deny: "deny"
                invite: "invite"
                rename: "rename"
                promote: "promote"
                kick: "kick"
                chat: "guildmsg, /g"
            args_descriptions:
                help: "Afficher les commandes pour la guilde"
                create: "(nom) Créer une guilde."
                info: "(nom/joueur) Afficher les informations à propos de la guilde."
                list: "Afficher la liste des guildes."
                leave: "Quitter la guilde actuelle."
                accept: "Accepter une invitation à rejoindre une guilde."
                deny: "Refuser une invitation à rejoindre une guilde."
                invite: "(joueur) Inviter un joueur à rejoindre la guilde."
                rename: "(nouveau nom) Modifier le nom de la guilde."
                promote: "(joueur) Donne le rang admin au joueur."
                kick: "(joueur) Expulser un joueur de la guilde."
                chat: "Discuter avec votre guilde."

GMHelpList:
    type: task
    debug: false
    script:
    - foreach <s@GMData.list_keys[config.commands.args]> {
        - narrate "<gold>/<s@GMData.yaml_key[config.commands.main]> <s@GMData.yaml_key[config.commands.args.<def[value]>]> <dark_gray>- <white><s@GMData.yaml_key[config.commands.args_descriptions.<def[value]>]>"
    }

GMHelpMessage:
    type: procedure
    debug: false
    script:
    - determine "<white>/<s@GMData.yaml_key[config.commands.main]> <s@GMData.yaml_key[config.commands.args.help]>"

GMCommand:
    type: command
    debug: true
    name: guild
    description: Commands for guilds.
    usage: /<s@GMData.yaml_key[config.commands.main]>
    aliases:
    - <s@GMData.yaml_key[config.commands.main]>
    script:
    - if <context.args.size> > 0 {
        # Help
        - if <context.args.get[1]> == "<s@GMData.yaml_key[config.commands.args.help]>" {
            - inject GMHelpList
        }
        # Create
        else if <context.args.get[1]> == "<s@GMData.yaml_key[config.commands.args.create]>" {
            - if <player.is_player||false> && <player.has_permission[denizen.guild.create]> != "true" {
                - narrate "<red>Vous n'avez pas la permission d'utiliser cette commande"
                - queue clear
            }
            - if <player.has_flag[Guilds_Player_Spam]> {
                - narrate "Commande en cours, veuillez patientez <player.flag[Guilds_Player_Spam].expiration.formatted>"
                - queue clear
            }
            - if <context.args.size> >= 2 {
                - define guildName "<context.args.get[2]>"
                - ^yaml load:guilddatabase.yml id:guilddatabase
                - if <player.has_flag[GuildId]> {
                    - narrate "<red>Vous êtes déjà dans une guilde !"
                    - queue clear
                }
                - foreach <yaml[guilddatabase].list_keys[guilds]> {
                    - if <yaml[guilddatabase].read[guilds.<%value%>.name]> == %guildName% {
                        - narrate "<red><def[guildName]> existe déjà !"
                        - queue clear
                    }
                }
                - if <def[guildName].length> > <s@GMData.yaml_key[config.namemaxlength]> {
                    - narrate "<red>Le nom est trop long !"
                    - queue clear
                }
                - if <def[guildName].length> < <s@GMData.yaml_key[config.nameminlength]> {
                    - narrate "<red>Le nom est trop court !"
                    - queue clear
                }
                - if <def[guildName].contains[*]> || <def[guildName].contains[.]> || <def[guildName].contains[<&co>]> || <def[guildName].contains[|]> {
                    - narrate "<red>Nom de guilde invalide"
                    - queue clear
                }
                - if <player.is_op.not> flag player Guilds_Player_Spam:True duration:30s
                # Create Team
                - define guildId <util.random.uuid>
                - flag player GuildId:%guildId%
                - ^yaml set id:guilddatabase guilds.%guildId%.name:%guildName%
                - ^yaml set id:guilddatabase guilds.%guildId%.created:<util.date.time.day>-<util.date.time.month>-<util.date.time.year>
                - ^yaml set id:guilddatabase guilds.%guildId%.members:->:<player>
                - ^yaml set id:guilddatabase guilds.%guildId%.admins:->:<player>
                - ^yaml savefile:guilddatabase.yml id:guilddatabase
                - announce format:GMAnnonceFormat "<white><player.name.display> <green>a créé une nouvelle guilde nommée <white>%guildName%"<green>.
                - ^yaml unload id:guilddatabase
            }
            else {
                - narrate "<red>Pas assez d'arguments !"
            }
        }
        # Info
        else if <context.args.get[1]> == "<s@GMData.yaml_key[config.commands.args.info]>" {
            - if <player.is_player||false> && <player.has_permission[denizen.guild.info]> != "true" {
                - narrate "<red>Vous n'avez pas la permission d'utiliser cette commande"
                - queue clear
            }
            - if <context.args.size> >= 2 {
                # Check other guild (args either player or guild)
                - define guildName <context.args.get[2]>
                - ^yaml load:guilddatabase.yml id:guilddatabase
                - define guildExist false
                - foreach <yaml[guilddatabase].list_keys[guilds]||null> {
                    - if <yaml[guilddatabase].read[guilds.%value%.name]> == %guildName% {
                        - define guildExist true
                        - define guildCreated <yaml[guilddatabase].read[guilds.%value%.created]>
                        - define guildMembers <yaml[guilddatabase].read[guilds.%value%.members]>
                    }
                }
                - if <def[guildExist]> == false {
                    - define playerTarget <server.match_offline_player[<context.args.get[2]>]||null>
                    - if <def[playerTarget] == null {
                        - narrate "<red>Joueur non trouvé !"
                        - queue clear
                    }
                    else {
                        # Found player
                        - if <def[playerTarget].has_flag[GuildId]> {
                            - define guildName <yaml[guilddatabase].read[guilds.<def[playerTarget].flag[GuildId]>.name]>
                            - define guildCreated <yaml[guilddatabase].read[guilds.<def[playerTarget].flag[GuildId]>.created]>
                            - define guildMembers <yaml[guilddatabase].read[guilds.<def[playerTarget].flag[GuildId]>.members]>
                        }
                        else {
                            - narrate "<red><def[playerTarget].name> n'a pas de guilde."
                            - queue clear
                        }
                    }
                }
                # Found guild %guildName%
                - narrate "<blue>--- --- <white>%guildName%<blue>--- ---"
                - narrate "<green>Membres <dark_gray><&co> <gray><def[guildMembers].parse[name].separated_by[<&sp>]>"
                - narrate "<blue>--- --- <gray>Créé le %guildCreated% <blue>--- ---"
                - ^yaml unload id:guilddatabase
            }
            else if <player.has_flag[GuildId]> {
                # Check own team
                - ^yaml load:guilddatabase.yml id:guilddatabase
                - define name <yaml[guilddatabase].read[guilds.<player.flag[GuildId]>.name]>
                - define members <yaml[guilddatabase].read[guilds.<player.flag[GuildId]>.members]>
                - define admins <yaml[guilddatabase].read[guilds.<player.flag[GuildId]>.admins]>
                - define created <yaml[guilddatabase].read[guilds.<player.flag[GuildId]>.created]>
                - narrate "<blue>--- --- <white>Votre Guilde<blue>--- ---"
                - narrate "<green>Nom <dark_gray><&co> <gray>%name%"
                - narrate "<green>Membres <dark_gray><&co> <gray><def[members].parse[name].separated_by[<&sp>]>"
                - narrate "<green>Chefs <dark_gray><&co> <gray><def[admins].parse[name].separated_by[<&sp>]>"
                - narrate "<blue>--- --- <gray>Créé le %created% <blue>--- ---"
                - ^yaml unload id:guilddatabase
            }
            else {
                - narrate "<red>Vous n'êtes pas dans une guilde."
            }
        }
        # List
        else if <context.args.get[1]> == "<s@GMData.yaml_key[config.commands.args.list]>" {
            - if <player.is_player||false> && <player.has_permission[denizen.guild.list]> != "true" {
                - narrate "<red>Vous n'avez pas la permission d'utiliser cette commande"
                - queue clear
            }
            - ^yaml load:guilddatabase.yml id:guilddatabase
            - narrate "<blue>--- --- <white>Guildes <blue>--- ---"
            - foreach <yaml[guilddatabase].list_keys[guilds]||null> {
                - narrate "<gray><yaml[guilddatabase].read[guilds.%value%.name]||Aucune guilde>"
            }
            - ^yaml unload id:guilddatabase
        }
        # Leave
        else if <context.args.get[1]> == "<s@GMData.yaml_key[config.commands.args.leave]>" {
            - if <player.is_player||false> && <player.has_permission[denizen.guild.leave]> != "true" {
                - narrate "<red>Vous n'avez pas la permission d'utiliser cette commande"
                - queue clear
            }
            - inject GMInjectLeave
        }
        # Invite
        else if <context.args.get[1]> == "<s@GMData.yaml_key[config.commands.args.invite]>" {
            - if <player.is_player||false> && <player.has_permission[denizen.guild.invite]> != "true" {
                - narrate "<red>Vous n'avez pas la permission d'utiliser cette commande"
                - queue clear
            }
            - if <context.args.size> >= 2 {
                - if <player.has_flag[GuildId].not> {
                    - narrate "<red>Vous n'êtes pas dans une guilde !"
                    - queue clear
                }
                - ^yaml load:guilddatabase.yml id:guilddatabase
                - define admins <yaml[guilddatabase].read[guilds.<player.flag[GuildId]>.admins]>
                - if <def[admins].contains[<player>].not> {
                    - narrate "<red>Vous n'êtes pas admin !"
                    - queue clear
                }
                - define members <yaml[guilddatabase].read[guilds.<player.flag[GuildId]>.members]>
                - if <%members%.size> >= <s@GMData.yaml_key[config.maxmembers]> {
                    - narrate "<red>Cette guilde ne peut pas contenir plus de membre !"
                    - queue clear
                }
                - define playerTarget <server.match_player[<context.args.get[2]>]||null>
                - if <def[playerTarget]> == null {
                    - narrate "<red>Joueur non trouvé !"
                    - queue clear
                }
                else if <def[playerTarget].has_flag[GuildId]> {
                    - narrate "<red><def[playerTarget].name> est déjà dans une guilde !"
                    - queue clear
                }
                else if <def[playerTarget].has_flag[GuildPending]> {
                    - narrate "<red><def[playerTarget].name> est déjà invité à venir dans la guilde !"
                    - queue clear
                }
                - narrate "<white><player.name> <gray>vient d'inviter <white><def[playerTarget].name> <gray>à rejoindre la guilde." targets:<def[members].filter[is_online]>
                - flag <def[playerTarget]> GuildPending:<player.flag[GuildId]> duration:2m
                - narrate "<white>Vous avez été invité à rejoindre la guilde <gray><yaml[guilddatabase].read[guilds.<def[playerTarget].flag[GuildPending]>.name]><white>. Tapez <green>/guild (accept<dark_gray>/<green>deny)<white> pour accepter ou refuser." targets:<def[playerTarget]>
                - ^yaml unload id:guilddatabase
            }
            else {
                - narrate "<red>Pas assez d'arguments !"
            }
        }
        # Deny
        else if <context.args.get[1]> == "<s@GMData.yaml_key[config.commands.args.deny]>" {
            - if <player.is_player||false> && <player.has_permission[denizen.guild.deny]> != "true" {
                - narrate "<red>Vous n'avez pas la permission d'utiliser cette commande"
                - queue clear
            }
            - if <player.has_flag[GuildPending].not> {
                - narrate "<red>vous n'avez aucune invitation à rejoindre une guilde."
                - queue clear
            }
            - ^yaml load:guilddatabase.yml id:guilddatabase
            - narrate "Vous avez refusé l'invitation de <yaml[guilddatabase].read[guilds.<player.flag[GuildPending]>.name]>"
            - define members <yaml[guilddatabase].read[guilds.<player.flag[GuildPending]>.members]>
            - narrate "<white><player.name> <gray>a refusé de rejoindre la guilde." targets:<%members%.as_list.filter[is_online]>
            - flag player GuildPending:!
            - ^yaml unload id:guilddatabase
        }
        # Accept
        else if <context.args.get[1]> == "<s@GMData.yaml_key[config.commands.args.accept]>" {
            - if <player.is_player||false> && <player.has_permission[denizen.guild.accept]> != "true" {
                - narrate "<red>Vous n'avez pas la permission d'utiliser cette commande"
                - queue clear
            }
            - if <player.has_flag[GuildId]> {
                - inject GMInjectLeave
            }
            - if <player.has_flag[GuildPending].not> {
                - narrate "<red>Vous n'avez aucune invitation à rejoindre une guilde."
                - queue clear
            }
            - ^yaml load:guilddatabase.yml id:guilddatabase
            - define members <yaml[guilddatabase].read[guilds.<player.flag[GuildPending]>.members]>
            - if <%members%.size> >= <s@GMData.yaml_key[config.maxmembers]> {
                - narrate "<red><yaml[guilddatabase].read[guilds.<player.flag[GuildPending]>.name]> ne peut pas contenir plus de membre !"
                - queue clear
            }
            - flag player GuildId:<player.flag[GuildPending]>
            - ^yaml set id:guilddatabase guilds.<player.flag[GuildPending]>.members:->:<player>
            - define members <yaml[guilddatabase].read[guilds.<player.flag[GuildPending]>.members]>
            - narrate "<white><player.name> <gray>rejoint la guilde !" targets:<def[members].filter[is_online]>
            - flag player GuildPending:!
            - ^yaml savefile:guilddatabase.yml id:guilddatabase
            - ^yaml unload id:guilddatabase
        }
        # Rename
        else if <context.args.get[1]> == "<s@GMData.yaml_key[config.commands.args.rename]>" {
            - if <player.is_player||false> && <player.has_permission[denizen.guild.rename]> != "true" {
                - narrate "<red>Vous n'avez pas la permission d'utiliser cette commande"
                - queue clear
            }
            - if <player.has_flag[Guilds_Player_Spam]> {
                - narrate "Commande en cours, veuillez patienter <player.flag[Guilds_Player_Spam].expiration.formatted>"
                - queue clear
            }
            - if <context.args.size> >= 2 {
                - define newGuildName "<context.args.get[2]>"
                - if <player.has_flag[GuildId].not> {
                    - narrate "<red>Vous n'êtes pas dans une guilde !"
                    - queue clear
                }
                - ^yaml load:guilddatabase.yml id:guilddatabase
                - define admins <yaml[guilddatabase].read[guilds.<player.flag[GuildId]>.admins]>
                - if <def[admins].contains[<player>].not> {
                    - narrate "<red>Vous n'êtes pas admin !"
                    - queue clear
                }
                - foreach <yaml[guilddatabase].list_keys[guilds]> {
                    - if <%value%.name == %guildName%> {
                        - narrate "<red>%newGuildName% existe déjà !"
                        - queue clear
                    }
                }
                - if <def[newGuildName].length> > <s@GMData.yaml_key[config.namelength]> {
                    - narrate "<red>Le nom est trop long !"
                    - queue clear
                }
                - if <def[guildName].contains[*]> || <def[guildName].contains[.]> || <def[guildName].contains[<&co>]> || <def[guildName].contains[|]> {
                    - narrate "<red>Nom de guilde invalide."
                    - queue clear
                }
                - flag player Guilds_Player_Spam:True duration:30s
                - define oldGuildName <yaml[guilddatabase].read[guilds.<player.flag[GuildId]>.name]>
                - ^yaml set id:guilddatabase guilds.<player.flag[GuildId]>.name:%newGuildName%
                - announce "<white><player.name> <gray>vient de renommer la guilde <white>%oldGuildName%<gray> en <white>%newGuildName%"
                - ^yaml savefile:guilddatabase.yml id:guilddatabase
                - ^yaml unload id:guilddatabase

            }
            else {
                - narrate "<red>Pas assez d'arguments !"
            }
        }
        # Promote
        else if <context.args.get[1]> == "<s@GMData.yaml_key[config.commands.args.promote]>" {
            - if <player.is_player||false> && <player.has_permission[denizen.guild.promote]> != "true" {
                - narrate "<red>Vous n'avez pas la permission d'utiliser cette commande"
                - queue clear
            }
            - if <player.has_flag[GuildId].not> {
                - narrate "<red>Vous n'êtes pas dans une guilde ! "
                - queue clear
            }
            - if <context.args.size> >= 2 {
                - ^yaml load:guilddatabase.yml id:guilddatabase
                - define admins <yaml[guilddatabase].read[guilds.<player.flag[GuildId]>.admins]>
                - if <def[admins].contains[<player>].not> {
                    - narrate "<red>Vous n'êtes pas admin !"
                    - queue clear
                }
                - define playerTarget <server.match_player[<context.args.get[2]>]||null>
                - if %playerTarget% == null {
                    - narrate "<red>Joueur non trouvé ! "
                    - queue clear
                }
                - define members <yaml[guilddatabase].read[guilds.<player.flag[GuildId]>.members]>
                - if <def[members].contains[<def[playerTarget]>].not> {
                    - narrate "<red><def[playerTarget].name> n'est pas dans votre guilde !"
                    - queue clear
                }
                - if <def[admins].contains[<def[playerTarget]>]> {
                    - narrate "<red><def[playerTarget].name> est déjà admin !"
                    - queue clear
                }
                ## Give promotion
                - ^yaml set id:guilddatabase guilds.<player.flag[GuildId]>.admins:->:%playerTarget%
                - narrate "<white><player.name> <gray>a promu <white><def[playerTarget].name>" targets:<def[members].as_list.filter[is_online]>
                - ^yaml savefile:guilddatabase.yml id:guilddatabase
                - ^yaml unload id:guilddatabase
            }
            else {
                - narrate "<red>Pas assez d'arguments ! "
            }
        }
        # kick
        else if <context.args.get[1]> == "<s@GMData.yaml_key[config.commands.args.kick]>" {
            - if <player.is_player||false> && <player.has_permission[denizen.guild.kick]> != "true" {
                - narrate "<red>Vous n'avez pas la permission d'utiliser cette commande"
                - queue clear
            }
            - if <player.has_flag[GuildId].not> {
                - narrate "<red>Vous n'êtes pas dans une guilde ! "
                - queue clear
            }
            - if <context.args.size> >= 2 {
                - ^yaml load:guilddatabase.yml id:guilddatabase
                - define admins <yaml[guilddatabase].read[guilds.<player.flag[GuildId]>.admins]>
                - if <def[admins].contains[<player>].not> {
                    - narrate "<red>Vous n'êtes pas admin !"
                    - queue clear
                }
                - define playerTarget <server.match_offline_player[<context.args.get[2]>]||null>
                - if <def[playerTarget]> == null {
                    - narrate "<red>Joueur non trouvé ! "
                    - queue clear
                }
                - define members <yaml[guilddatabase].read[guilds.<player.flag[GuildId]>.members]>
                - if <def[members].contains[<def[playerTarget]>].not> {
                    - narrate "<red><def[playerTarget].name> n'est pas dans votre guilde !"
                    - queue clear
                }
                - if <def[admins].contains[<def[playerTarget]>]> {
                    - narrate "<red>Vous ne pouvez pas éjecter un admin !"
                    - queue clear
                }
                - ^yaml set id:guilddatabase guilds.<player.flag[GuildId]>.members:<-:<def[playerTarget]>
                - flag <def[playerTarget]> GuildId:!
                - narrate "<gray>Vous venez d'être exclue de la guilde <white><yaml[guilddatabase].read[guilds.<player.flag[GuildId]>.name]>" targets:<def[playerTarget]>
                - define members <yaml[guilddatabase].read[guilds.<player.flag[GuildId]>.members]>
                - narrate "<white><player.name> <gray>vient d'exclure <white><def[playerTarget].name> <gray>de la guilde." targets:<def[members].as_list.filter[is_online]>
                - ^yaml savefile:guilddatabase.yml id:guilddatabase
                - ^yaml unload id:guilddatabase
            }
            else {
                - narrate "<red>Pas assez d'arguments ! "
            }
        }
        else {
            - narrate "<red>Commande inconnue ! "
        }
    }
    else {
        - inject GMHelpList
    }

GMInjectLeave:
    type: task
    debug: false
    script:
    - if <player.has_flag[Guilds_Player_Spam]> {
        - narrate "Commande en cours, veuillez patienter <player.flag[Guilds_Player_Spam].expiration.formatted>"
        - queue clear
    }
    - if <player.has_flag[GuildId]> {
        - ^yaml load:guilddatabase.yml id:guilddatabase
        - narrate "<gray>Vous avez quitté la guilde <white><yaml[guilddatabase].read[guilds.<player.flag[GuildId]>.name]>"
        - define guildId <player.flag[GuildId]>
        - flag player GuildId:!
        - define members <yaml[guilddatabase].read[guilds.%guildId%.members]||null>
        - ^yaml set id:guilddatabase guilds.%guildId%.members:<-:<player>
        - if <def[members] != null {
            - if <def[members].is_empty.not||false> {
                - narrate "<white><player.name> <gray>a quitté la guilde." targets:<%members%.as_list.filter[is_online]>
            }
        }
        - define admins <yaml[guilddatabase].read[guilds.%guildId%.admins]||null>
        - if <def[admins].contains[<player>]> {
            - flag player Guilds_Player_Spam:True duration:30s
            - ^yaml set id:guilddatabase guilds.%guildId%.admins:<-:<player>
            - define admins <yaml[guilddatabase].read[guilds.%guildId%.admins]||null>
            - if <def[admins].is_empty||true> {
                # Remove team
                - define members <yaml[guilddatabase].read[guilds.%guildId%.members]||null>
                - if <def[members]> != null {
                    - foreach <def[members]> {
                        - flag <def[value]> GuildId:!
                    }
                }
                - define guildName <yaml[guilddatabase].read[guilds.%guildId%.name]||null>
                - ^yaml set id:guilddatabase guilds.%guildId%:!
                - announce format:GMAnnonceFormat "La guilde <white><def[guildName]> <green>a été dissoute par <white><player.name.display><green>."
            }
        }
        - ^yaml savefile:guilddatabase.yml id:guilddatabase
        - ^yaml unload id:guilddatabase
    }
    else {
        - narrate "<red>Vous n'êtes pas dans une guilde ! "
    }

GMChat:
    type: command
    debug: false
    name: guildmsg
    description: Envoyer un message dans le tchat de la guilde.
    usage: /guildmsg
    aliases:
    - g
    script:
    - if <player.is_player||false> && <player.has_permission[denizen.guild.chat]> != "true" {
        - narrate "<red>Vous n'avez pas la permission d'utiliser cette commande"
        - queue clear
    }
    - if <player.has_flag[GuildId].not> {
        - narrate "<red>Vous n'êtes pas dans une guilde ! "
        - queue clear
    }
    - ^yaml load:guilddatabase.yml id:guilddatabase
    - define members <yaml[guilddatabase].read[guilds.<player.flag[GuildId]>.members]||null>
    - narrate "<white>[<green>Guilde<white>] <player.name.display><white><&co> <context.raw_args>" targets:<def[members].as_list.filter[is_online]>
    - ^yaml unload id:guilddatabase

GMAnnonceFormat:
    type: format
    debug: false
    format: "<white>[<red>Guilde<white>]<green> <text>"