use std::io::{self, BufRead};
use std::time::Instant;

mod graph;
use crate::graph::Graph;

mod theorems;
use crate::theorems::{basic, forbidden, toughness};

struct Counters {
    graphs: i32,
    tough_1: i32,
    tough_2: i32,
    bch_hamiltonian: i32,
    t15_hamiltonian: i32,
    t25_hamiltonian: i32,
    dirac_hamiltonian: i32,
    ore_hamiltonian: i32,
    posa_hamiltonian: i32,
}

impl Counters {
    fn new() -> Counters {
        return Counters {
            graphs: 0,
            tough_1: 0,
            tough_2: 0,
            bch_hamiltonian: 0,
            t15_hamiltonian: 0,
            t25_hamiltonian: 0,
            dirac_hamiltonian: 0,
            ore_hamiltonian: 0,
            posa_hamiltonian: 0,
        };
    }
}

fn main() {
    let stdin = io::stdin();

    let mut time = 0;
    let mut counters = Counters::new();

    for line in stdin.lock().lines() {
        let line = line.unwrap();

        let g = Graph::from_g6(&line);
        counters.graphs += 1;

        let start = Instant::now();
        let closure = g.get_closure();
        let is_complete = closure.is_complete();
        println!("Graph:\n{g}");
        println!("Closure:\n{closure}");
        println!("{is_complete}");

        // let toughness = if g.is_complete() {
        //     f64::MAX
        // } else {
        //     g.get_toughness()
        // };
        // println!("{toughness}");

        // if toughness >= 1.0 {
        //     counters.tough_1 += 1;
        // }
        // if toughness >= 2.0 {
        //     counters.tough_2 += 1;
        // }

        // let min_degree = g.min_degree() as f64;
        // println!("{min_degree}");

        // TODO: add counter
        // if forbidden::theorem3_1(&g) {
        //     println!("g6:t3_1:{}", line);
        // }

        // TODO: add counter
        // if forbidden::theorem3_2(&g) {
        //     println!("g6:t3_2:{}", line);
        // }

        // TODO: add counter
        // if forbidden::corollary3_5(&g) {
        //     println!("g6:c3_5:{}", line);
        // }

        // if forbidden::theorem85(&g) {
        //     println!("g6:t85:{}", line);
        // }
        // if forbidden::theorem86(&g) {
        //     println!("g6:t86:{}", line);
        // }
        // if forbidden::theorem87(&g) {
        //     println!("g6:t87:{}", line);
        // }
        // if forbidden::theorem88(&g) {
        //     println!("g6:t88:{}", line);
        // }
        // if forbidden::theorem96(&g) {
        //     println!("g6:t96:{}", line);
        // }
        // if forbidden::conjecture17(&g) {
        //     println!("g6:conj17:{}", line);
        // }
        // if forbidden::theorem_all_2con(&g) {
        //     println!("g6:all_2c:{}", line);
        // }

        // if toughness::theorem15(&g, toughness, min_degree) {
        //     counters.t15_hamiltonian += 1;
        //     println!("g6:bigalke-jung:{}", line);
        // }

        // if toughness::theorem25(&g, toughness, min_degree) {
        //     counters.t25_hamiltonian += 1;
        //     println!("g6:bauer:{}", line);
        // }

        // if basic::dirac_theorem(&g) {
        //     counters.dirac_hamiltonian += 1;
        //     println!("g6:dirac:{}", line);
        // }

        // if basic::ore_theorem(&g) {
        //     counters.ore_hamiltonian += 1;
        //     println!("g6:ore:{}", line);
        // }

        // if basic::posa_theorem(&g) {
        //     counters.posa_hamiltonian += 1;
        //     println!("g6:posa:{}", line);
        // }

        // if is_complete {
        //     counters.bch_hamiltonian += 1;
        //     println!("g6:bondy-chvatal:{}", line);
        // }

        // if is_complete && false {
        //     println!("Graph: {line}\n{g}");

        //     let components_count = g.count_components();
        //     println!("Components count: {components_count}");
        //     let min_degree = g.min_degree();
        //     println!("Minimal degree: {min_degree}");

        //     let cutset = g.max_independent_cutset();
        //     println!("Maximal independent cutset:\n{}", cutset.graph);
        //     println!("Included vertices: {:?}", cutset.vertices);
        //     println!("Cutset cardinality: {}", cutset.cardinality);

        //     let cycle = basic::bondy_chvatal_hamiltonian_cycle(&g);
        //     print!("Hamiltonian cycle: ");
        //     let start = 0;
        //     let mut current = start;
        //     loop {
        //         print!("{}", current + 1);
        //         print!(" -> ");
        //         current = cycle[current];
        //         if current == start {
        //             println!("{}", current + 1);
        //             break;
        //         }
        //     }
        // }

        let elapsed = start.elapsed();
        time += elapsed.as_nanos();
    }

    println!("Total count of graphs: {}", counters.graphs);
    println!("Count of 1-tough graphs: {}", counters.tough_1);
    println!("Count of 2-tough graphs: {}", counters.tough_2);
    println!(
        "Count of Dirac's Hamiltonian graphs: {}",
        counters.dirac_hamiltonian
    );
    println!(
        "Count of Ore's Hamiltonian graphs: {}",
        counters.ore_hamiltonian
    );
    println!(
        "Count of Posa's Hamiltonian graphs: {}",
        counters.posa_hamiltonian
    );
    println!(
        "Count of Bondy-Chvatal Hamiltonian graphs: {}",
        counters.bch_hamiltonian
    );
    println!(
        "Count of Theorem 15 Hamiltonian graphs: {}",
        counters.t15_hamiltonian
    );
    println!(
        "Count of Theorem 25 Hamiltonian graphs: {}",
        counters.t25_hamiltonian
    );
    println!("Time elapsed: {}s", time as f64 / 1e9);
}