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,
    t3_1: i32,
    t3_2: i32,
    c3_5: i32,
    t85: i32,
    t86: i32,
    t87: i32,
    t88: i32,
    t96: i32,
    conj17: i32,
    all_2c: 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,
            t3_1: 0,
            t3_2: 0,
            c3_5: 0,
            t85: 0,
            t86: 0,
            t87: 0,
            t88: 0,
            t96: 0,
            conj17: 0,
            all_2c: 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();

        let toughness = if g.is_complete() {
            f64::MAX
        } else {
            g.get_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;

        if forbidden::theorem3_1(&g) {
            counters.t3_1 += 1;
            println!("g6:t3_1:{}", line);
        }

        if forbidden::theorem3_2(&g) {
            counters.t3_2 += 1;
            println!("g6:t3_2:{}", line);
        }

        if forbidden::corollary3_5(&g) {
            counters.c3_5 += 1;
            println!("g6:c3_5:{}", line);
        }
        if forbidden::theorem85(&g) {
            counters.t85 += 1;
            println!("g6:t85:{}", line);
        }
        if forbidden::theorem86(&g) {
            counters.t86 += 1;
            println!("g6:t86:{}", line);
        }
        if forbidden::theorem87(&g) {
            counters.t87 += 1;
            println!("g6:t87:{}", line);
        }
        if forbidden::theorem88(&g) {
            counters.t88 += 1;
            println!("g6:t88:{}", line);
        }
        if forbidden::theorem96(&g) {
            counters.t96 += 1;
            println!("g6:t96:{}", line);
        }
        if forbidden::conjecture17(&g) {
            counters.conj17 += 1;
            println!("g6:conj17:{}", line);
        }
        if forbidden::theorem_all_2con(&g) {
            counters.all_2c += 1;
            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);
}