use crate::graph::{Graph, GraphProfile};
use crate::theorems::{basic, forbidden, toughness};

pub fn dominating_numbers(g: Graph) -> (String, Option<u32>, u32) {
    let line = g.to_g6();
    let mut independent_dominating = None;

    let mut smallest_geodesic = None;
    let mut geodesic_sets = Vec::new();

    let mut done = false;

    for cs in g.cutsets() {
        if done {
            break;
        }
        let dom = cs.is_dominating_in(&g);
        let idp = cs.graph.is_independent();
        if independent_dominating.is_none() && dom && idp {
            independent_dominating = Some(cs.cardinality as u32);
        }

        let mut visited = vec![0; g.size];
        for vx in &cs.vertices {
            if *vx == 1 {
                g.dfs(*vx as usize, &mut visited);
            }
            if visited.iter().sum::<usize>() == g.size {
                let geodesic_size: u32 = cs.vertices.iter().sum();
                if let Some(smallest_geodesic) = smallest_geodesic {
                    if geodesic_size > smallest_geodesic {
                        done = true;
                        break;
                    }
                } else {
                    smallest_geodesic = Some(geodesic_size);
                }
                println!("cs {:?}", cs.vertices);
                geodesic_sets.push(cs.vertices.clone());
            }
        }
    }

    println!("geodesic_sets = {}", geodesic_sets.len());
    let mut fg = g.size as u32;
    println!("start");
    for check in &geodesic_sets {
        println!("{:?}", check);
        let mut verts = check.clone();
        for set in &geodesic_sets {
            for v in 0..g.size {
                if check[v] == set[v] {
                    verts[v] = 0;
                }
            }
        }
        let new_fg = verts.iter().sum::<u32>();
        if new_fg < fg {
            fg = new_fg;
        }
    }
    println!("end");

    (line, independent_dominating, fg)
}

pub fn apply_theorems(g: Graph) -> GraphProfile {
    // let db = db.clone();
    // counters.graphs += 1;
    let line = g.to_g6();
    let mut profile = GraphProfile::new(&line);

    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 {
        profile.insert("tough_1".to_string(), true);
    }
    if toughness >= 2.0 {
        profile.insert("tough_2".to_string(), true);
    }
    let min_degree = g.min_degree() as f64;

    if forbidden::theorem3_1(&g) {
        profile.insert("t3_1".to_string(), true);
        // println!("g6:t3_1:{}", line);
    }

    if forbidden::theorem3_2(&g) {
        profile.insert("t3_2".to_string(), true);
        // println!("g6:t3_2:{}", line);
    }

    if forbidden::corollary3_5(&g) {
        profile.insert("c3_5".to_string(), true);
        // println!("g6:c3_5:{}", line);
    }
    if forbidden::theorem85(&g) {
        profile.insert("t85".to_string(), true);
        // println!("g6:t85:{}", line);
    }
    if forbidden::theorem86(&g) {
        profile.insert("t86".to_string(), true);
        // println!("g6:t86:{}", line);
    }
    if forbidden::theorem87(&g) {
        profile.insert("t87".to_string(), true);
        // println!("g6:t87:{}", line);
    }
    if forbidden::theorem88(&g) {
        profile.insert("t88".to_string(), true);
        // println!("g6:t88:{}", line);
    }
    if forbidden::theorem96(&g) {
        profile.insert("t96".to_string(), true);
        // println!("g6:t96:{}", line);
    }
    if forbidden::conjecture17(&g) {
        profile.insert("conj17".to_string(), true);
        // println!("g6:conj17:{}", line);
    }
    if forbidden::theorem_all_2con(&g) {
        profile.insert("all_2c".to_string(), true);
        // println!("g6:all_2c:{}", line);
    }
    if toughness::theorem15(&g, toughness, min_degree) {
        profile.insert("t15_hamiltonian".to_string(), true);
        // println!("g6:bigalke-jung:{}", line);
    }
    if toughness::theorem25(&g, toughness, min_degree) {
        profile.insert("t25_hamiltonian".to_string(), true);
        // println!("g6:bauer:{}", line);
    }
    if basic::dirac_theorem(&g) {
        profile.insert("dirac_hamiltonian".to_string(), true);
        // println!("g6:dirac:{}", line);
    }
    if basic::ore_theorem(&g) {
        profile.insert("ore_hamiltonian".to_string(), true);
        // println!("g6:ore:{}", line);
    }
    if basic::posa_theorem(&g) {
        profile.insert("posa_hamiltonian".to_string(), true);
        // println!("g6:posa:{}", line);
    }
    if is_complete {
        profile.insert("bch_hamiltonian".to_string(), true);
        // 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 _ = sqlx::query!("INSERT INTO graphs (g6) VALUES (?);", line)
    //     .execute(&db)
    //     .await;

    profile
}

pub async fn async_theorems1(g: Graph) -> GraphProfile {
    // counters.graphs += 1;
    let line = g.to_g6();
    let mut profile = GraphProfile::new(&line);

    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 {
        profile.insert("tough_1".to_string(), true);
    }
    if toughness >= 2.0 {
        profile.insert("tough_2".to_string(), true);
    }
    let min_degree = g.min_degree() as f64;

    if forbidden::theorem3_1(&g) {
        profile.insert("t3_1".to_string(), true);
        // println!("g6:t3_1:{}", line);
    }

    if forbidden::theorem3_2(&g) {
        profile.insert("t3_2".to_string(), true);
        // println!("g6:t3_2:{}", line);
    }

    if forbidden::corollary3_5(&g) {
        profile.insert("c3_5".to_string(), true);
        // println!("g6:c3_5:{}", line);
    }
    if forbidden::theorem85(&g) {
        profile.insert("t85".to_string(), true);
        // println!("g6:t85:{}", line);
    }
    if forbidden::theorem86(&g) {
        profile.insert("t86".to_string(), true);
        // println!("g6:t86:{}", line);
    }
    if forbidden::theorem87(&g) {
        profile.insert("t87".to_string(), true);
        // println!("g6:t87:{}", line);
    }
    if forbidden::theorem88(&g) {
        profile.insert("t88".to_string(), true);
        // println!("g6:t88:{}", line);
    }
    if forbidden::theorem96(&g) {
        profile.insert("t96".to_string(), true);
        // println!("g6:t96:{}", line);
    }
    if forbidden::conjecture17(&g) {
        profile.insert("conj17".to_string(), true);
        // println!("g6:conj17:{}", line);
    }
    if forbidden::theorem_all_2con(&g) {
        profile.insert("all_2c".to_string(), true);
        // println!("g6:all_2c:{}", line);
    }
    if toughness::theorem15(&g, toughness, min_degree) {
        profile.insert("t15_hamiltonian".to_string(), true);
        // println!("g6:bigalke-jung:{}", line);
    }
    if toughness::theorem25(&g, toughness, min_degree) {
        profile.insert("t25_hamiltonian".to_string(), true);
        // println!("g6:bauer:{}", line);
    }
    if basic::dirac_theorem(&g) {
        profile.insert("dirac_hamiltonian".to_string(), true);
        // println!("g6:dirac:{}", line);
    }
    if basic::ore_theorem(&g) {
        profile.insert("ore_hamiltonian".to_string(), true);
        // println!("g6:ore:{}", line);
    }
    if basic::posa_theorem(&g) {
        profile.insert("posa_hamiltonian".to_string(), true);
        // println!("g6:posa:{}", line);
    }
    if is_complete {
        profile.insert("bch_hamiltonian".to_string(), true);
        // 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 _ =
    //     sqlx::query!("INSERT INTO graphs (g6) VALUES (?);", line)
    //         .execute(&db)
    //         .await;

    profile
}