use std::env;
use std::process;
use std::fs::File;
use std::io::prelude::*;
use inline_python::*;

fn main() -> std::io::Result<()> {
    let args: Vec<_> = env::args().collect();
    if args.len() < 4 { println!("Need clique size, complete graph order, and output filename."); process::exit(1); }
    let sclique: usize = args[1].clone().to_string().parse::<usize>().unwrap();
    let order: usize = args[2].clone().to_string().parse::<usize>().unwrap();
    let output_name: &String = &args[3];
    println!("{} {} {}", sclique, order, output_name);

    let mut buffer = File::create(output_name)?;
    let mut buffer2 = File::create(".a")?;

    let mut edges: Vec<[u32; 2]> = Vec::new(); 
    let c = Context::new();

    c.run(python! {
        import networkx as nx;
        import itertools as it
        G = nx.complete_graph('order);
        def issize(val):
            return len(val)<='sclique
        B = [c for c in list(it.takewhile(issize, nx.enumerate_all_cliques(G))) if len(c)=='sclique];
    });

    let cliques = c.get::<Vec<Vec<u32>>>("B");
    write!(buffer, "p cnf {} {}\n", ((order * (order - 1)) / 2), 2*cliques.len())?;
    for clique in cliques {
        for a in 0..sclique {
            for b in a+1..sclique {
                //i += 1;
                let edge: [u32; 2] = [clique[a], clique[b]];
                let result = edges.iter().position(|&val| val==edge);
                let eindex = match result {
                    Some(val) => val+1,
                    None => {
                        edges.push(edge);
                        println!("{} = {:?}", edges.len(), edge);
                        edges.len()
                    }
                };
                write!(buffer, "{} ", eindex)?;
                write!(buffer2, "-{} ", eindex)?;
            }
        }
        write!(buffer, "0\n")?;
        write!(buffer2, "0\n")?;
    }
    Ok(())
}