/* dijkstra.c: el algoritmo de estado de enlace, paso a paso.
 *
 * Lee un grafo (líneas "nodo nodo costo") y corre Dijkstra desde un nodo. Imprime
 * la tabla de cada iteración y la forwarding table que resulta. Cuando dos caminos
 * empatan guarda los dos: un destino puede tener varios next hop (ECMP).
 *
 *   ./dijkstra graphs/six.txt a
 */
#include <inttypes.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_NODES 32
#define NAME_SIZE 8
#define INFINITE_COST INT32_MAX

static char names[MAX_NODES][NAME_SIZE];
static int node_count;
static int32_t cost[MAX_NODES][MAX_NODES]; /* 0 = sin enlace */

static int find_or_add(const char *name) {
    for (int i = 0; i < node_count; i++) {
        if (strcmp(names[i], name) == 0) {
            return i;
        }
    }
    if (node_count == MAX_NODES) {
        fprintf(stderr, "demasiados nodos (máximo %d)\n", MAX_NODES);
        exit(EXIT_FAILURE);
    }
    snprintf(names[node_count], NAME_SIZE, "%s", name);
    return node_count++;
}

static int compare_names(const void *left, const void *right) {
    return strcmp(left, right);
}

/* Primera pasada: nombres, en orden alfabético. Segunda pasada: costos. */
static int load_graph(const char *path) {
    int links = 0;
    for (int pass = 0; pass < 2; pass++) {
        FILE *file = fopen(path, "r");
        if (file == NULL) {
            perror(path);
            exit(EXIT_FAILURE);
        }
        char line[128];
        while (fgets(line, sizeof line, file) != NULL) {
            char left[NAME_SIZE];
            char right[NAME_SIZE];
            int value;
            if (line[0] == '#' || sscanf(line, "%7s %7s %d", left, right, &value) != 3) {
                continue;
            }
            if (value <= 0) {
                fprintf(stderr, "costo inválido: %s", line);
                exit(EXIT_FAILURE);
            }
            int u = find_or_add(left);
            int v = find_or_add(right);
            if (pass == 1) {
                cost[u][v] = value;
                cost[v][u] = value;
                links++;
            }
        }
        if (fclose(file) != 0) {
            perror("fclose");
            exit(EXIT_FAILURE);
        }
        if (pass == 0) {
            qsort(names, (size_t)node_count, NAME_SIZE, compare_names);
        }
    }
    return links;
}

static void print_header(int source) {
    printf("%-4s %-*s", "paso", node_count + 1, "N'");
    for (int v = 0; v < node_count; v++) {
        if (v != source) {
            printf(" %-8s", names[v]);
        }
    }
    printf("\n");
}

/* Una celda como "6,cd": costo y predecesores en el camino más corto. */
static void print_row(int step, int source, const int *order, int done_count,
                      const int32_t *dist, const uint32_t *previous, const bool *done) {
    printf("%-4d ", step);
    int written = 0;
    for (int i = 0; i < done_count; i++) {
        written += printf("%s", names[order[i]]);
    }
    printf("%*s", node_count + 1 > written ? node_count + 1 - written : 0, "");
    for (int v = 0; v < node_count; v++) {
        if (v == source) {
            continue;
        }
        char cell[64] = "-";
        if (done[v]) {
            snprintf(cell, sizeof cell, "*");
        } else if (dist[v] != INFINITE_COST) {
            size_t used = (size_t)snprintf(cell, sizeof cell, "%" PRId32 ",", dist[v]);
            for (int u = 0; u < node_count; u++) {
                if (previous[v] & (UINT32_C(1) << u)) {
                    used += (size_t)snprintf(cell + used, sizeof cell - used, "%s", names[u]);
                }
            }
        }
        printf(" %-8s", cell);
    }
    printf("\n");
}

static void dijkstra(int source) {
    int32_t dist[MAX_NODES];
    uint32_t previous[MAX_NODES] = {0}; /* predecesores, como conjunto de bits */
    uint32_t first_hops[MAX_NODES] = {0}; /* next hop desde el origen, también */
    bool done[MAX_NODES] = {false};
    int order[MAX_NODES];
    int done_count = 0;

    for (int v = 0; v < node_count; v++) {
        dist[v] = INFINITE_COST;
    }
    dist[source] = 0;
    done[source] = true;
    order[done_count++] = source;
    for (int v = 0; v < node_count; v++) {
        if (cost[source][v] > 0) {
            dist[v] = cost[source][v];
            previous[v] = UINT32_C(1) << source;
            first_hops[v] = UINT32_C(1) << v;
        }
    }

    print_header(source);
    print_row(0, source, order, done_count, dist, previous, done);
    for (int step = 1; step < node_count; step++) {
        /* El más cercano que falta. Con empate, el primero en orden alfabético. */
        int nearest = -1;
        for (int v = 0; v < node_count; v++) {
            if (!done[v] && dist[v] != INFINITE_COST && (nearest < 0 || dist[v] < dist[nearest])) {
                nearest = v;
            }
        }
        if (nearest < 0) {
            break; /* lo que queda no se alcanza */
        }
        done[nearest] = true;
        order[done_count++] = nearest;
        for (int v = 0; v < node_count; v++) {
            if (done[v] || cost[nearest][v] == 0) {
                continue;
            }
            int32_t through = dist[nearest] + cost[nearest][v];
            if (through < dist[v]) {
                dist[v] = through;
                previous[v] = UINT32_C(1) << nearest;
                first_hops[v] = first_hops[nearest];
            } else if (through == dist[v]) {
                /* Empate: este camino se suma a los que ya había. */
                previous[v] |= UINT32_C(1) << nearest;
                first_hops[v] |= first_hops[nearest];
            }
        }
        print_row(step, source, order, done_count, dist, previous, done);
    }

    printf("\nforwarding table de %s\n", names[source]);
    printf("%-8s %-6s %s\n", "destino", "costo", "next hop");
    for (int v = 0; v < node_count; v++) {
        if (v == source) {
            continue;
        }
        if (dist[v] == INFINITE_COST) {
            printf("%-8s %-6s -\n", names[v], "inf");
            continue;
        }
        printf("%-8s %-6" PRId32, names[v], dist[v]);
        for (int u = 0; u < node_count; u++) {
            if (first_hops[v] & (UINT32_C(1) << u)) {
                printf(" %s", names[u]);
            }
        }
        printf("\n");
    }
}

int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "uso: %s GRAFO ORIGEN\n", argv[0]);
        return EXIT_FAILURE;
    }
    int links = load_graph(argv[1]);
    int source = -1;
    for (int v = 0; v < node_count; v++) {
        if (strcmp(names[v], argv[2]) == 0) {
            source = v;
        }
    }
    if (source < 0) {
        fprintf(stderr, "no existe el nodo %s\n", argv[2]);
        return EXIT_FAILURE;
    }
    printf("%d nodos, %d enlaces, origen %s\n\n", node_count, links, argv[2]);
    dijkstra(source);
    return EXIT_SUCCESS;
}

/* dv_sim.c: vector de distancias, ronda por ronda.
 *
 * Simula routers que solo conocen sus enlaces y lo que les cuentan sus vecinos.
 * Cada router guarda, por destino, un costo y un next hop, y aplica dos reglas:
 *   1. Lo que diga su next hop actual se acepta siempre, aunque sea peor.
 *   2. Lo que diga otro vecino se acepta solo si mejora el costo.
 *
 *   ./dv_sim GRAFO [--mode plain|split|poison] [--dest NODO] [--inf N] [--max N]
 *            [--fail U V | --set U V COSTO | --lie NODO DESTINO COSTO]
 *            [--order U:V,U:V,...]
 *
 * Primero converge y después aplica el evento. Sin --order, en cada ronda todos
 * anuncian a la vez. Con --order, cada paso es un solo anuncio U -> V, en ese orden,
 * que se repite: sirve para fijar cuál mensaje llega antes.
 */
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_NODES 16
#define NAME_SIZE 8
#define NO_HOP (-1)
#define MAX_ORDER 64
#define EXPIRY_ROUNDS 6 /* sin noticias del next hop por tantas rondas, la ruta vence */

enum mode { MODE_PLAIN, MODE_SPLIT, MODE_POISON };

struct message {
    int from;
    int to;
};

static char names[MAX_NODES][NAME_SIZE];
static int node_count;
static int link_cost[MAX_NODES][MAX_NODES]; /* 0 = sin enlace */
static int dist[MAX_NODES][MAX_NODES];
static int hop[MAX_NODES][MAX_NODES];
static int age[MAX_NODES][MAX_NODES];
static int infinity = 16;
static enum mode mode = MODE_PLAIN;
static long announcements;
static bool stopped_by_limit; /* run terminó por --max, no porque nada cambiara */
/* Un router que miente: anuncia este costo sin importar lo que sepa. */
static int liar = NO_HOP;
static int lie_dest = NO_HOP;
static int lie_cost;

static int find_or_add(const char *name) {
    for (int i = 0; i < node_count; i++) {
        if (strcmp(names[i], name) == 0) {
            return i;
        }
    }
    if (node_count == MAX_NODES) {
        fprintf(stderr, "demasiados nodos (máximo %d)\n", MAX_NODES);
        exit(EXIT_FAILURE);
    }
    snprintf(names[node_count], NAME_SIZE, "%s", name);
    return node_count++;
}

static int require_node(const char *name) {
    for (int i = 0; i < node_count; i++) {
        if (strcmp(names[i], name) == 0) {
            return i;
        }
    }
    fprintf(stderr, "no existe el nodo %s\n", name);
    exit(EXIT_FAILURE);
}

static int compare_names(const void *left, const void *right) {
    return strcmp(left, right);
}

static void load_graph(const char *path) {
    for (int pass = 0; pass < 2; pass++) {
        FILE *file = fopen(path, "r");
        if (file == NULL) {
            perror(path);
            exit(EXIT_FAILURE);
        }
        char line[128];
        while (fgets(line, sizeof line, file) != NULL) {
            char left[NAME_SIZE];
            char right[NAME_SIZE];
            int value;
            if (line[0] == '#' || sscanf(line, "%7s %7s %d", left, right, &value) != 3) {
                continue;
            }
            if (value <= 0) {
                fprintf(stderr, "costo inválido: %s", line);
                exit(EXIT_FAILURE);
            }
            int u = find_or_add(left);
            int v = find_or_add(right);
            if (pass == 1) {
                link_cost[u][v] = value;
                link_cost[v][u] = value;
            }
        }
        if (fclose(file) != 0) {
            perror("fclose");
            exit(EXIT_FAILURE);
        }
        if (pass == 0) {
            qsort(names, (size_t)node_count, NAME_SIZE, compare_names);
        }
    }
}

/* Al inicio, cada router conoce solo sus enlaces directos. */
static void init_tables(void) {
    for (int u = 0; u < node_count; u++) {
        for (int d = 0; d < node_count; d++) {
            bool direct = link_cost[u][d] > 0 && link_cost[u][d] < infinity;
            dist[u][d] = u == d ? 0 : (direct ? link_cost[u][d] : infinity);
            hop[u][d] = u == d ? u : (direct ? d : NO_HOP);
        }
    }
}

/* Qué le anuncia from a to sobre un destino. Devuelve false si no anuncia nada. */
static bool advertised(int from, int to, int d, int *value) {
    if (from == liar && d == lie_dest) {
        *value = lie_cost;
        return true;
    }
    if (hop[from][d] == to && d != from) {
        if (mode == MODE_SPLIT) {
            return false; /* split horizon: no se lo cuento a quien me lo enseñó */
        }
        if (mode == MODE_POISON) {
            *value = infinity; /* poison reverse: se lo cuento como infinito */
            return true;
        }
    }
    *value = dist[from][d];
    return true;
}

/* Aplica el anuncio de un vecino sobre un destino. Devuelve si cambió la tabla. */
static bool apply(int router, int neighbor, int d, int value) {
    if (d == router || (router == liar && d == lie_dest)) {
        return false;
    }
    int through = value + link_cost[router][neighbor];
    if (through > infinity) {
        through = infinity;
    }
    if (hop[router][d] == neighbor) {
        age[router][d] = 0;
        if (through != dist[router][d]) {
            dist[router][d] = through;
            if (through == infinity) {
                hop[router][d] = NO_HOP;
            }
            return true;
        }
    } else if (through < dist[router][d]) {
        dist[router][d] = through;
        hop[router][d] = neighbor;
        age[router][d] = 0;
        return true;
    }
    return false;
}

/* Las rutas de quien calla envejecen. Solo pasa con split horizon. */
static bool expire_routes(void) {
    bool changed = false;
    for (int u = 0; u < node_count; u++) {
        for (int d = 0; d < node_count; d++) {
            if (u == d || hop[u][d] == NO_HOP || (u == liar && d == lie_dest)) {
                continue;
            }
            if (++age[u][d] > EXPIRY_ROUNDS) {
                dist[u][d] = infinity;
                hop[u][d] = NO_HOP;
                age[u][d] = 0;
                changed = true;
            }
        }
    }
    return changed;
}

static bool any_aging(void) {
    for (int u = 0; u < node_count; u++) {
        for (int d = 0; d < node_count; d++) {
            if (age[u][d] > 0) {
                return true;
            }
        }
    }
    return false;
}

/* Una ronda: todos arman sus anuncios con la tabla de antes y luego todos los
 * aplican. El next hop actual se atiende primero, para que el resultado no dependa
 * del orden de los vecinos. */
static bool round_all_at_once(void) {
    static int inbox[MAX_NODES][MAX_NODES][MAX_NODES];
    static bool present[MAX_NODES][MAX_NODES][MAX_NODES];
    for (int from = 0; from < node_count; from++) {
        for (int to = 0; to < node_count; to++) {
            if (link_cost[from][to] == 0) {
                continue;
            }
            announcements++;
            for (int d = 0; d < node_count; d++) {
                present[from][to][d] = advertised(from, to, d, &inbox[from][to][d]);
            }
        }
    }
    bool changed = expire_routes();
    for (int to = 0; to < node_count; to++) {
        for (int d = 0; d < node_count; d++) {
            int current = hop[to][d];
            if (current != NO_HOP && current != to && link_cost[current][to] > 0
                && present[current][to][d]) {
                changed |= apply(to, current, d, inbox[current][to][d]);
            }
        }
        for (int from = 0; from < node_count; from++) {
            if (link_cost[from][to] == 0) {
                continue;
            }
            for (int d = 0; d < node_count; d++) {
                if (present[from][to][d] && hop[to][d] != from) {
                    changed |= apply(to, from, d, inbox[from][to][d]);
                }
            }
        }
    }
    return changed;
}

/* Un solo anuncio, que el receptor aplica de inmediato. */
static bool single_message(struct message message) {
    announcements++;
    bool changed = false;
    for (int d = 0; d < node_count; d++) {
        int value;
        if (advertised(message.from, message.to, d, &value)) {
            changed |= apply(message.to, message.from, d, value);
        }
    }
    return changed;
}

static void format_entry(char *cell, size_t size, int router, int d) {
    if (dist[router][d] >= infinity) {
        snprintf(cell, size, "inf");
    } else if (router == d) {
        snprintf(cell, size, "0");
    } else if (hop[router][d] == NO_HOP) {
        snprintf(cell, size, "%d", dist[router][d]);
    } else {
        snprintf(cell, size, "%d/%s", dist[router][d], names[hop[router][d]]);
    }
}

static void print_matrix(void) {
    printf("    ");
    for (int d = 0; d < node_count; d++) {
        printf(" %-6s", names[d]);
    }
    printf("\n");
    for (int u = 0; u < node_count; u++) {
        printf("%-4s", names[u]);
        for (int d = 0; d < node_count; d++) {
            char cell[32];
            format_entry(cell, sizeof cell, u, d);
            printf(" %-6s", cell);
        }
        printf("\n");
    }
}

/* Busca un ciclo de forwarding hacia d. Lo imprime si lo hay. */
static void print_loop(int d) {
    for (int start = 0; start < node_count; start++) {
        if (start == d) {
            continue;
        }
        int visits[MAX_NODES] = {0};
        int current = start;
        while (current != d && current != NO_HOP && visits[current] == 0) {
            visits[current] = 1;
            current = hop[current][d];
        }
        if (current == d || current == NO_HOP) {
            continue;
        }
        /* current está en el ciclo; se imprime una vez, desde su nodo menor */
        int lowest = current;
        for (int walk = hop[current][d]; walk != current; walk = hop[walk][d]) {
            if (walk < lowest) {
                lowest = walk;
            }
        }
        printf("  ciclo: %s", names[lowest]);
        for (int walk = hop[lowest][d]; walk != lowest; walk = hop[walk][d]) {
            printf(" > %s", names[walk]);
        }
        printf(" > %s", names[lowest]);
        return;
    }
}

static void print_line(const char *label, int d) {
    printf("%-14s", label);
    for (int u = 0; u < node_count; u++) {
        if (u == d) {
            continue;
        }
        char cell[32];
        format_entry(cell, sizeof cell, u, d);
        printf(" %s=%-6s", names[u], cell);
    }
    print_loop(d);
    printf("\n");
}

/* Corre hasta que nada cambie. Devuelve cuántas rondas o pasos hicieron cambios. */
static int run(int dest, bool show, const struct message *order, int order_size, int max_rounds) {
    int last_change = 0;
    char label[64];
    if (order_size > 0) {
        int unchanged_steps = 0;
        for (int step = 1; step <= max_rounds; step++) {
            struct message message = order[(step - 1) % order_size];
            bool changed = single_message(message);
            if (changed) {
                last_change = step;
                unchanged_steps = 0;
            } else {
                unchanged_steps++;
            }
            if (show && dest != NO_HOP) {
                snprintf(label, sizeof label, "paso %d %s>%s", step, names[message.from],
                         names[message.to]);
                print_line(label, dest);
            }
            if (unchanged_steps >= order_size) {
                return last_change;
            }
        }
        stopped_by_limit = true;
        return last_change;
    }
    for (int round = 1; round <= max_rounds; round++) {
        bool changed = round_all_at_once();
        if (changed) {
            last_change = round;
        }
        if (show && changed) {
            if (dest != NO_HOP) {
                snprintf(label, sizeof label, "ronda %d", round);
                print_line(label, dest);
            } else {
                printf("ronda %d\n", round);
                print_matrix();
                printf("\n");
            }
        }
        if (!changed && !any_aging()) {
            return last_change;
        }
    }
    stopped_by_limit = true;
    return last_change;
}

static void fail_link(int u, int v) {
    link_cost[u][v] = 0;
    link_cost[v][u] = 0;
    for (int d = 0; d < node_count; d++) {
        if (hop[u][d] == v) {
            dist[u][d] = infinity;
            hop[u][d] = NO_HOP;
        }
        if (hop[v][d] == u) {
            dist[v][d] = infinity;
            hop[v][d] = NO_HOP;
        }
    }
}

/* El costo cambia en los dos extremos. Las rutas por ese enlace suben o bajan igual. */
static void set_link(int u, int v, int value) {
    int delta = value - link_cost[u][v];
    link_cost[u][v] = value;
    link_cost[v][u] = value;
    for (int d = 0; d < node_count; d++) {
        if (hop[u][d] == v) {
            dist[u][d] += delta;
        }
        if (hop[v][d] == u) {
            dist[v][d] += delta;
        }
    }
}

static int parse_order(char *text, struct message *order) {
    int size = 0;
    for (char *pair = strtok(text, ","); pair != NULL; pair = strtok(NULL, ",")) {
        char *colon = strchr(pair, ':');
        if (colon == NULL || size == MAX_ORDER) {
            fprintf(stderr, "--order mal formado: %s\n", pair);
            exit(EXIT_FAILURE);
        }
        *colon = '\0';
        order[size].from = require_node(pair);
        order[size].to = require_node(colon + 1);
        size++;
    }
    return size;
}

static void usage(const char *program) {
    fprintf(stderr,
            "uso: %s GRAFO [--mode plain|split|poison] [--dest NODO] [--inf N] [--max N]\n"
            "       [--fail U V | --set U V COSTO | --lie NODO DESTINO COSTO]\n"
            "       [--order U:V,U:V,...]\n",
            program);
    exit(EXIT_FAILURE);
}

int main(int argc, char *argv[]) {
    if (argc < 2) {
        usage(argv[0]);
    }
    load_graph(argv[1]);

    int dest = NO_HOP;
    int max_rounds = 200;
    const char *fail_args[2] = {NULL, NULL};
    const char *set_args[3] = {NULL, NULL, NULL};
    const char *lie_args[3] = {NULL, NULL, NULL};
    char *order_text = NULL;
    for (int i = 2; i < argc; i++) {
        const char *flag = argv[i];
        int remaining = argc - i - 1;
        if (strcmp(flag, "--mode") == 0 && remaining >= 1) {
            const char *value = argv[++i];
            if (strcmp(value, "plain") == 0) {
                mode = MODE_PLAIN;
            } else if (strcmp(value, "split") == 0) {
                mode = MODE_SPLIT;
            } else if (strcmp(value, "poison") == 0) {
                mode = MODE_POISON;
            } else {
                usage(argv[0]);
            }
        } else if (strcmp(flag, "--dest") == 0 && remaining >= 1) {
            dest = require_node(argv[++i]);
        } else if (strcmp(flag, "--inf") == 0 && remaining >= 1) {
            infinity = atoi(argv[++i]);
        } else if (strcmp(flag, "--max") == 0 && remaining >= 1) {
            max_rounds = atoi(argv[++i]);
        } else if (strcmp(flag, "--fail") == 0 && remaining >= 2) {
            fail_args[0] = argv[++i];
            fail_args[1] = argv[++i];
        } else if (strcmp(flag, "--set") == 0 && remaining >= 3) {
            set_args[0] = argv[++i];
            set_args[1] = argv[++i];
            set_args[2] = argv[++i];
        } else if (strcmp(flag, "--lie") == 0 && remaining >= 3) {
            lie_args[0] = argv[++i];
            lie_args[1] = argv[++i];
            lie_args[2] = argv[++i];
        } else if (strcmp(flag, "--order") == 0 && remaining >= 1) {
            order_text = argv[++i];
        } else {
            usage(argv[0]);
        }
    }
    if (infinity <= 0 || max_rounds <= 0) {
        usage(argv[0]);
    }

    struct message order[MAX_ORDER];
    int order_size = order_text != NULL ? parse_order(order_text, order) : 0;
    bool has_event = fail_args[0] != NULL || set_args[0] != NULL || lie_args[0] != NULL;

    init_tables();
    if (!has_event) {
        if (dest != NO_HOP) {
            print_line("ronda 0", dest);
        } else {
            printf("ronda 0\n");
            print_matrix();
            printf("\n");
        }
    }
    int rounds = run(dest, !has_event, NULL, 0, max_rounds);
    printf("convergió: %d %s, %ld anuncios\n", rounds, rounds == 1 ? "ronda" : "rondas",
           announcements);
    if (!has_event) {
        return EXIT_SUCCESS;
    }

    if (dest != NO_HOP) {
        print_line("antes", dest);
    } else {
        print_matrix();
    }
    announcements = 0;
    if (fail_args[0] != NULL) {
        fail_link(require_node(fail_args[0]), require_node(fail_args[1]));
        printf("--- cae el enlace %s-%s\n", fail_args[0], fail_args[1]);
    } else if (set_args[0] != NULL) {
        set_link(require_node(set_args[0]), require_node(set_args[1]), atoi(set_args[2]));
        printf("--- el enlace %s-%s pasa a costar %s\n", set_args[0], set_args[1], set_args[2]);
    } else {
        liar = require_node(lie_args[0]);
        lie_dest = require_node(lie_args[1]);
        lie_cost = atoi(lie_args[2]);
        dist[liar][lie_dest] = lie_cost;
        hop[liar][lie_dest] = NO_HOP;
        printf("--- %s anuncia %s con costo %s\n", lie_args[0], lie_args[1], lie_args[2]);
    }
    if (dest != NO_HOP) {
        print_line("evento", dest);
    }
    rounds = run(dest, true, order, order_size, max_rounds);
    const char *unit = order_size > 0 ? (rounds == 1 ? "paso" : "pasos")
                                      : (rounds == 1 ? "ronda" : "rondas");
    printf("%s: %d %s, %ld anuncios\n", stopped_by_limit ? "detenido por --max" : "volvió a converger",
           rounds, unit, announcements);
    return EXIT_SUCCESS;
}

"""Ayudas de las pruebas de la semana 5: levantar topologías y correr comandos."""
import json
import os
import subprocess
import time
import unittest

HERE = os.path.dirname(os.path.abspath(__file__))
# La solución no se publica. Sin ella, las pruebas usan lo que ustedes escriben en lab/.
ANSWERS = os.path.join(HERE, "solution")
if not os.path.isdir(ANSWERS):
    ANSWERS = os.path.join(HERE, "lab")


def answer_path(name):
    """Devuelve la ruta de un archivo del laboratorio, o salta si sigue con el TODO."""
    path = os.path.join(ANSWERS, name)
    with open(path, encoding="utf-8") as file:
        if "TODO" in file.read():
            raise unittest.SkipTest(f"falta completar lab/{name}")
    return path


def run(args, timeout=240, stdin=None):
    return subprocess.run(args, capture_output=True, text=True, timeout=timeout, stdin=stdin)


class Lab:
    """Una topología de Containerlab que se levanta y se destruye desde las pruebas."""

    def __init__(self, folder, name, network):
        self.folder = os.path.join(HERE, folder)
        self.topology = f"{folder}.clab.yml"
        self.prefix = f"clab-{name}-"
        self.network = network

    def deploy(self, **variables):
        done = subprocess.run(
            ["containerlab", "deploy", "-t", self.topology, "--reconfigure"],
            cwd=self.folder, capture_output=True, text=True, timeout=300,
            env={**os.environ, **variables})
        if done.returncode != 0:
            raise RuntimeError(done.stdout + done.stderr)

    def destroy(self):
        subprocess.run(["containerlab", "destroy", "-t", self.topology, "--cleanup"],
                       cwd=self.folder, capture_output=True, text=True, timeout=300)
        subprocess.run(["docker", "network", "rm", self.network], capture_output=True, text=True)

    def sh(self, node, *command, timeout=60):
        """Corre un comando en un nodo y devuelve el resultado completo."""
        return run(["docker", "exec", self.prefix + node, *command], timeout=timeout)

    def out(self, node, *command, timeout=60):
        """Corre un comando en un nodo y devuelve stdout y stderr juntos."""
        done = self.sh(node, *command, timeout=timeout)
        return done.stdout + done.stderr

    def daemon(self, node, command):
        """Deja un comando corriendo en segundo plano dentro de un nodo."""
        run(["docker", "exec", "-d", self.prefix + node, "sh", "-c", command])

    def vtysh(self, node, *commands):
        """Corre comandos de vtysh en un nodo y devuelve su salida."""
        arguments = [part for command in commands for part in ("-c", command)]
        return self.out(node, "vtysh", *arguments)

    def configure(self, node, *commands):
        """Aplica líneas de configuración, como en conf t."""
        return self.vtysh(node, "conf t", *commands)

    def route(self, node, prefix):
        """Devuelve la entrada de la tabla de routing de un prefijo, en JSON de FRRouting."""
        output = self.vtysh(node, f"show ip route {prefix} json")
        return json.loads(output or "{}").get(prefix, [])

    def neighbor_states(self, node):
        """Devuelve el estado de cada vecino OSPF: {router id: estado}."""
        data = json.loads(self.vtysh(node, "show ip ospf neighbor json") or "{}")
        states = {}
        for router_id, entries in data.get("neighbors", {}).items():
            for entry in entries:
                states[router_id] = entry.get("nbrState", "")
        return states

    def full_with(self, node, router_id):
        return self.neighbor_states(node).get(router_id, "").startswith("Full")


def wait_until(predicate, seconds=30, step=0.5):
    """Espera a que una condición se cumpla; devuelve si se cumplió."""
    deadline = time.monotonic() + seconds
    while time.monotonic() < deadline:
        if predicate():
            return True
        time.sleep(step)
    return predicate()

# Tres áreas en línea para ver qué cruza de una a otra:
#
#    área 1            área 0            área 2
#  x1 ---- abr1 ---- core ---- abr2 ---- y1
#
# abr1 y abr2 son area border routers. x1 e y1 tienen LAN simuladas con interfaces
# dummy, para poder apagarlas sin tocar los enlaces.
#
# Con ABR1_CONF=frr-range.conf, abr1 arranca resumiendo el área 1 en un solo prefijo.
name: w05-areas
mgmt:
  network: redes-w05-areas
  ipv4-subnet: 172.90.5.128/26
  ipv6-subnet: 3fff:172:90:5:2::/80
topology:
  defaults:
    kind: linux
    image: redes-router
    exec:
      - ip route del default
      - ip -6 route del default
      - sysctl -w net.ipv6.conf.all.disable_ipv6=1
  nodes:
    x1:
      binds: [x1/frr.conf:/etc/frr/frr.conf:ro]
      exec:
        - ip route del default
        - ip -6 route del default
        - sysctl -w net.ipv6.conf.all.disable_ipv6=1
        - ip link add lan1 type dummy
        - ip link add lan2 type dummy
        - ip link set lan1 up
        - ip link set lan2 up
    abr1:
      binds: [abr1/${ABR1_CONF:=frr.conf}:/etc/frr/frr.conf]
    core:
      binds: [core/frr.conf:/etc/frr/frr.conf:ro]
    abr2:
      binds: [abr2/frr.conf:/etc/frr/frr.conf:ro]
    y1:
      binds: [y1/frr.conf:/etc/frr/frr.conf:ro]
      exec:
        - ip route del default
        - ip -6 route del default
        - sysctl -w net.ipv6.conf.all.disable_ipv6=1
        - ip link add lan1 type dummy
        - ip link set lan1 up
  links:
    - endpoints: ["x1:eth1", "abr1:eth1"]
      mtu: 1500
    - endpoints: ["abr1:eth2", "core:eth1"]
      mtu: 1500
    - endpoints: ["core:eth2", "abr2:eth1"]
      mtu: 1500
    - endpoints: ["abr2:eth2", "y1:eth1"]
      mtu: 1500

# Para el ejemplo de vector de distancias, iteración por iteración.
w x 2
w y 9
x y 3
x z 8
y z 1

# Tres nodos en línea, para el conteo al infinito.
x y 1
y z 1

# El grafo de seis nodos del capítulo: nodo nodo costo. Es el mismo de six/.
a b 3
a c 1
b c 4
b d 2
c d 5
c e 5
d e 1
d f 7
e f 2

# Un triángulo y una cola: aquí split horizon y poison reverse no alcanzan.
a b 1
a c 1
b c 1
c d 1

# Triángulo con costos desiguales, para buenas y malas noticias.
p q 2
q r 1
p r 30

# Topología del laboratorio: cinco routers con caminos alternativos y un host en
# cada extremo. Los routers traen sus direcciones, pero no OSPF: configurarlo es el
# trabajo del laboratorio.
#
#              h1
#              |
#              r1
#             /  \
#           r2 -- r3
#           |      |
#           r4 -- r5
#           |
#           h4
name: w05-ospf
mgmt:
  network: redes-w05-ospf
  ipv4-subnet: 172.90.5.64/26
  ipv6-subnet: 3fff:172:90:5:1::/80
topology:
  defaults:
    kind: linux
    image: redes-router
    exec:
      - ip route del default
      - ip -6 route del default
      - sysctl -w net.ipv6.conf.all.disable_ipv6=1
  nodes:
    r1:
      binds: [r1/frr.conf:/etc/frr/frr.conf:ro]
    r2:
      binds: [r2/frr.conf:/etc/frr/frr.conf:ro]
    r3:
      binds: [r3/frr.conf:/etc/frr/frr.conf:ro]
    r4:
      binds: [r4/frr.conf:/etc/frr/frr.conf:ro]
    r5:
      binds: [r5/frr.conf:/etc/frr/frr.conf:ro]
    h1:
      exec:
        - ip route del default
        - ip -6 route del default
        - sysctl -w net.ipv6.conf.all.disable_ipv6=1
        - ip addr add 10.205.101.10/24 dev eth1
        - ip route add default via 10.205.101.1
    h4:
      exec:
        - ip route del default
        - ip -6 route del default
        - sysctl -w net.ipv6.conf.all.disable_ipv6=1
        - ip addr add 10.205.104.10/24 dev eth1
        - ip route add default via 10.205.104.1
  links:
    - endpoints: ["r1:eth1", "r2:eth1"]
      mtu: 1500
    - endpoints: ["r1:eth2", "r3:eth1"]
      mtu: 1500
    - endpoints: ["r2:eth2", "r3:eth2"]
      mtu: 1500
    - endpoints: ["r2:eth3", "r4:eth1"]
      mtu: 1500
    - endpoints: ["r3:eth3", "r5:eth1"]
      mtu: 1500
    - endpoints: ["r4:eth2", "r5:eth2"]
      mtu: 1500
    - endpoints: ["h1:eth1", "r1:eth3"]
      mtu: 1500
    - endpoints: ["h4:eth1", "r4:eth3"]
      mtu: 1500

# El grafo de seis nodos del capítulo, hecho red: cada nodo es un router y cada
# arista es un enlace cuyo costo de OSPF es el peso del grafo.
#
#        3       2        7
#     a ---- b ----- d ------ f
#      \     |     / |       /
#       \1   |4  5/  |1    /2
#        \   |  /    |   /
#         \  | /     |  /
#           c ------ e
#               5
name: w05-six
mgmt:
  network: redes-w05-six
  ipv4-subnet: 172.90.5.0/26
  ipv6-subnet: 3fff:172:90:5::/80
topology:
  defaults:
    kind: linux
    image: redes-router
    # Sin ruta por defecto de gestión: lo que un router no sabe a dónde mandar debe
    # fallar, no irse por Docker. Sin IPv6 para que no aparezca ruido en las capturas.
    exec:
      - ip route del default
      - ip -6 route del default
      - sysctl -w net.ipv6.conf.all.disable_ipv6=1
  nodes:
    a:
      binds: [a/frr.conf:/etc/frr/frr.conf:ro]
    b:
      binds: [b/frr.conf:/etc/frr/frr.conf:ro]
    c:
      binds: [c/frr.conf:/etc/frr/frr.conf:ro]
    d:
      binds: [d/frr.conf:/etc/frr/frr.conf:ro]
    e:
      binds: [e/frr.conf:/etc/frr/frr.conf:ro]
    f:
      binds: [f/frr.conf:/etc/frr/frr.conf:ro]
  # Containerlab usa MTU 9500 por defecto; aquí queremos el valor de Ethernet.
  links:
    - endpoints: ["a:eth1", "b:eth1"]
      mtu: 1500
    - endpoints: ["a:eth2", "c:eth1"]
      mtu: 1500
    - endpoints: ["b:eth2", "c:eth2"]
      mtu: 1500
    - endpoints: ["b:eth3", "d:eth1"]
      mtu: 1500
    - endpoints: ["c:eth3", "d:eth2"]
      mtu: 1500
    - endpoints: ["c:eth4", "e:eth1"]
      mtu: 1500
    - endpoints: ["d:eth3", "e:eth2"]
      mtu: 1500
    - endpoints: ["d:eth4", "f:eth1"]
      mtu: 1500
    - endpoints: ["e:eth3", "f:eth2"]
      mtu: 1500

frr defaults traditional
hostname abr1
log file /tmp/ospfd.log
!
interface eth1
 ip address 10.205.16.2/30
 ip ospf network point-to-point
 ip ospf cost 10
!
interface eth2
 ip address 10.205.1.1/30
 ip ospf network point-to-point
 ip ospf cost 10
!
router ospf
 ospf router-id 10.205.0.12
 network 10.205.16.0/20 area 1
 network 10.205.1.0/30 area 0
 ! un solo prefijo hacia afuera por todo lo del área 1
 area 1 range 10.205.16.0/20

frr defaults traditional
hostname abr1
log file /tmp/ospfd.log
!
interface eth1
 ip address 10.205.16.2/30
 ip ospf network point-to-point
 ip ospf cost 10
!
interface eth2
 ip address 10.205.1.1/30
 ip ospf network point-to-point
 ip ospf cost 10
!
router ospf
 ospf router-id 10.205.0.12
 network 10.205.16.0/20 area 1
 network 10.205.1.0/30 area 0

frr defaults traditional
hostname abr2
log file /tmp/ospfd.log
!
interface eth1
 ip address 10.205.2.2/30
 ip ospf network point-to-point
 ip ospf cost 10
!
interface eth2
 ip address 10.205.32.1/30
 ip ospf network point-to-point
 ip ospf cost 10
!
router ospf
 ospf router-id 10.205.0.14
 network 10.205.2.0/30 area 0
 network 10.205.32.0/20 area 2

frr defaults traditional
hostname core
log file /tmp/ospfd.log
!
interface eth1
 ip address 10.205.1.2/30
 ip ospf network point-to-point
 ip ospf cost 10
!
interface eth2
 ip address 10.205.2.1/30
 ip ospf network point-to-point
 ip ospf cost 10
!
router ospf
 ospf router-id 10.205.0.13
 network 10.205.1.0/30 area 0
 network 10.205.2.0/30 area 0

frr defaults traditional
hostname x1
log file /tmp/ospfd.log
!
interface eth1
 ip address 10.205.16.1/30
 ip ospf network point-to-point
 ip ospf cost 10
!
! dos LAN de área 1, simuladas con interfaces dummy
interface lan1
 ip address 10.205.17.1/24
!
interface lan2
 ip address 10.205.18.1/24
!
router ospf
 ospf router-id 10.205.0.11
 network 10.205.16.0/20 area 1

frr defaults traditional
hostname y1
log file /tmp/ospfd.log
!
interface eth1
 ip address 10.205.32.2/30
 ip ospf network point-to-point
 ip ospf cost 10
!
! una LAN de área 2
interface lan1
 ip address 10.205.33.1/24
!
router ospf
 ospf router-id 10.205.0.15
 network 10.205.32.0/20 area 2

frr defaults traditional
hostname r1
log file /tmp/ospfd.log
!
interface lo
 ip address 10.205.0.1/32
!
! hacia r2
interface eth1
 ip address 10.205.12.1/30
 ip ospf network point-to-point
!
! hacia r3
interface eth2
 ip address 10.205.13.1/30
 ip ospf network point-to-point
!
! la LAN de h1
interface eth3
 ip address 10.205.101.1/24
 ip ospf cost 10
!