using System.Globalization;
using System.Net;
using System.Windows;
using System;

namespace Calculateur_de_Masque_Reseau;

public partial class MainWindow : Window
{
    // Constructeur de la fenêtre
    public MainWindow()
    {
        InitializeComponent();
    }

    // Exécuté lorsque l'utilisateur clique sur le bouton Calculer
    private void BtnCalculer_Click(object sender, RoutedEventArgs e)
    {
        // Réinitialisation des zones de texte
        TxtErreur.Text = "";
        TxtResultats.Text = "";

        // Vérification de l'adresse IP et du CIDR avec comme conditions : 
        // - L'adresse IP doit être au format IPv4 (4 octets séparés par des points, chaque octet entre 0 et 255)
        // - Le CIDR doit être un entier entre 0 et 32
        // Si l'une des conditions n'est pas respectée, un message d'erreur est affiché et la fonction s'arrête
        if (!VerifierIPv4(TxtIP.Text, out uint ip) || !int.TryParse(TxtCIDR.Text.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out int cidr) || cidr < 0 || cidr > 32)
        {
            TxtErreur.Text = "Adresse IPv4 invalide ou CIDR invalide (0 à 32).";
            return;
        }

        // Création du masque à partir du CIDR
        uint masque = cidr == 0 ? 0u : uint.MaxValue << (32 - cidr);

        // Calcul de l'adresse réseau
        uint reseau = ip & masque;

        // Calcul de l'adresse de diffusion (broadcast)
        uint diffusion = reseau | ~masque;

        // Calcul de la première adresse utilisable
        string premiereIp = cidr >= 31 ? "N/A" : UIntToIp(reseau + 1);

        // Calcul de la dernière adresse utilisable
        string derniereIp = cidr >= 31 ? "N/A" : UIntToIp(diffusion - 1);

        // Calcul du nombre d'hôtes possibles
        long nombreHotes = cidr >= 31 ? 0 : (1L << (32 - cidr)) - 2;

        // Affichage des résultats
        TxtResultats.Text =
            "Adresse IP        : " + UIntToIp(ip) + "\n" +
            "IP binaire        : " + ConversionBinaire(ip) + "\n\n" +
            "CIDR              : /" + cidr + "\n" +
            "Masque décimal    : " + UIntToIp(masque) + "\n" +
            "Masque binaire    : " + ConversionBinaire(masque) + "\n\n" +
            "Adresse réseau    : " + UIntToIp(reseau) + "\n" +
            "Adresse broadcast : " + UIntToIp(diffusion) + "\n" +
            "Première IP       : " + premiereIp + "\n" +
            "Dernière IP       : " + derniereIp + "\n" +
            "Nombre d'hôtes    : " + nombreHotes;
    }

    // Vérifie qu'une chaîne correspond à une IPv4
    // et la convertit en entier sur 32 bits
    private static bool VerifierIPv4(string text, out uint value)
    {
        value = 0;

        string[] parties = text.Trim().Split('.');

        // Une IPv4 doit avoir exactement 4 parties
        if (parties.Length != 4)
            return false;

        byte[] octets = new byte[4];

        for (int i = 0; i < 4; i++)
        {
            // Chaque partie doit être un nombre entre 0 et 255
            if (!int.TryParse(parties[i], out int nombre) || nombre < 0 || nombre > 255)
                return false;

            octets[i] = (byte)nombre;
        }

        value = ((uint)octets[0] << 24) | ((uint)octets[1] << 16) | ((uint)octets[2] << 8) | octets[3];

        return true;
    }

    
    


    // Convertit un entier 32 bits en adresse IPv4
    private static string UIntToIp(uint value)
    {
        return $"{(value >> 24) & 255}." + $"{(value >> 16) & 255}." + $"{(value >> 8) & 255}." + $"{value & 255}";
    }

    // Convertit une adresse IPv4 en binaire
    private static string ConversionBinaire(uint value)
    {
        string resultat = "";

        // Parcours des 4 octets
        for (int i = 0; i < 4; i++)
        {
            uint octet = (value >> (24 - i * 8)) & 255;

            // Conversion de l'octet en binaire sur 8 bits
            resultat += Convert.ToString((int)octet, 2).PadLeft(8, '0');

            // Ajout du séparateur entre les octets
            if (i < 3)
                resultat += ".";
        }

        return resultat;
    }

    // Convertit un masque réseau (255.255.255.0)
    // en notation CIDR (/24)
    private static int ConvertirMasqueEnCIDR(uint masque)
    {
        int cidr = 0;

        // Parcours des 32 bits du masque
        // en partant du bit de gauche
        for (int i = 31; i >= 0; i--)
        {
            // Récupère le bit actuel
            uint bitActuel = (masque >> i) & 1;

            // Tant qu'on trouve des 1,
            // on augmente le CIDR
            if (bitActuel == 1)
            {
                cidr++;
            }
            else
            {
                // Dès qu'on trouve le premier 0,
                // tous les bits suivants doivent être des 0

                for (int j = i - 1; j >= 0; j--)
                {
                    if (((masque >> j) & 1) == 1)
                    {
                        // Exemple :
                        // 11111111.00000000.11111111.00000000
                        // n'est pas un masque valide
                        return -1;
                    }
                }

                return cidr;
            }
        }

        return cidr;
    }

}