class Program
    {
        static readonly ConsoleTarget log_console = new ConsoleTarget("log_console");
        static readonly LoggingConfiguration configuration = new LoggingConfiguration();
        static readonly Logger logger = LogManager.GetCurrentClassLogger();

        static OpenProxyApi _proxy_api;
        static ProxyEntityMapper _proxy_mapper;
        static ProxyRepository _proxy_repository;

        static ProxyCreatorRequest _proxy_creator;
        static ProxyActivatorRequest _proxy_activator;

        static void Main(string[] args)
        {
            configuration.AddRule(LogLevel.Info, LogLevel.Fatal, log_console);
            LogManager.Configuration = configuration;

            _proxy_api = new OpenProxyApi("./proxy_information_api.json");
            _proxy_mapper = new ProxyEntityMapper();
            _proxy_repository = new ProxyRepository(_proxy_api, _proxy_mapper);

            _proxy_creator = new ProxyCreatorRequest(_proxy_repository);
            _proxy_activator = new ProxyActivatorRequest(_proxy_repository);

            ProxyEntity proxy = _proxy_creator.Handle(@"VOTRE FICHIER EXECUTABLE", 666);
            proxy = _proxy_activator.Handle(proxy, true);

            Console.ReadLine();
        }
    }

    // un exemple pour lancer 10 server
    DofusServer server = new DofusServer("EMPLACEMENT DU DOSSIER APP");
    int nombre_de_server_a_lancer = 10;
    for(int i = 1;i <= nombre_de_server_a_lancer;i++)
    {
        int port_du_server = 666;
        ServerEntity server_instance = server.Active(true, port_du_server + i); 
    }

    // un exemple pour lancer 10 proxy (pour DofusRetro c'est similaire , il suffit de remplacer DofusProxy par DofusRetroProxy et le constructeur de DofusRetroProxy 
    // prend en argument le dossier qui contient le fichier Dofus.exe)
    DofusProxy proxy = new DofusProxy("EMPLACEMENT DU DOSSIER APP");
    int nombre_de_proxy_a_lancer = 10;
    for(int i = 1;i <= nombre_de_proxy_a_lancer;i++)
    {
        int port_du_proxy = 666;
        ProxyEntity proxy_instance = proxy.Active(true, port_du_proxy + i); 
        Thread.Sleep(2000); // le client Dofus peut ne pas se lancer si vous en ouvre plein en même temps donc mettez une pause entre chaque ouverture de client
    }

    // L'attribut doit être spécifié pour pouvoir handle le message , mettez l'attribut en commentaire si vous voulez désactivez le handle d'un message
    // ProxyHandler pour les proxys et ServerHandler pour les servers
    [ProxyHandler(ProtocolName = "ServerSelectionMessage")]
    // Votre class Handler doit hérité de AbstractMessageHandler https://github.com/Mrpotatosse/AivyCore/blob/master/AivyDofus/Handler/AbstractMessageHandler.cs
    public class ServerSelectionMessageHandler : AbstractMessageHandler
    {
        // optionel pour le log
        static readonly Logger logger = LogManager.GetCurrentClassLogger();
        
        // obligatoire , cette variable ne sert que pour le proxy 
        // à TRUE elle redirige directement les données reçu sans aucune modification ( du type du handler ici : ServerSelectionMessage )   
        // à FALSE elle bloque tout les packets reçu ( du type du handler ici : ServerSelectionMessage ) et vous devrez envoyer un message manuellement
        public override bool IsForwardingData => false;

        // le constructeur doit avoir ses arguments la :
        //  - AbstractClientReceiveCallback => _callback : contient
        //             ._tag -> un énum qui définie si le message provient du Client ou du Server
        //             ._client -> qui représente le client ayant activé le callback
        //             ._remote -> le client en lien ( pour le server la valeur est null ) ( pour le proxy , si _tag = Client alors _remote = Server sinon l'inverse )
        //             ._client_repository -> le stockage de tout les clients (à noté que vous pouvez éxécutez des actions depuis cette variable , mais il est préférable de les
        // créer sous forme de class , comme ceux déjà créer , pour éviter tout conflit au niveau de la liste de client )
        //             ._client_creator, ._client_linker, ._client_connector, ._client_disconnector -> differente class qui représente les actions possible sur un client
        //  - NetworkElement => _element : la base du message ( ce qui contient toutes les informations de lecture/écriture )
        //  - NetworkContentElement => _content : le contenu du message reçu
        // Le constructeur ne peux pas être modifié ( sinon il y a aura une erreur lors du runtime )
        public ServerSelectionMessageHandler(AbstractClientReceiveCallback callback,
                                             NetworkElement element,
                                             NetworkContentElement content)
            : base(callback, element, content)
        {

        }
        
        // OBLIGATOIRE , la fonction qui permet de Handle un message
        public override void Handle()
        {
            // Pour créer un message/type il faut passer par un NetworkContentElement
            NetworkContentElement custom_message = new NetworkContentElement()
            {
                field = 
                { "nomDeLaPropriété", null }, // valeur de la propriété
                { "protocol_id" , 0 } // sur certain type , il peut être obligatoire ( dans le protocol c'est si prefixed_by_type_id = true ) 
                // { ... }   
            };
        }
        
        // optionel
        public override void EndHandle()
        {
        
        }
        // optionel
        public override void Error(Exception e)
        {
            logger.Error(e);
        }
    }