use lp_modeler::problem::{LpObjective, Problem, LpProblem};
use lp_modeler::operations::{LpOperations};
use lp_modeler::variables::LpInteger;
use lp_modeler::solvers::{SolverTrait, CbcSolver};

// Define problem variables
let ref a = LpInteger::new("a");
let ref b = LpInteger::new("b");
let ref c = LpInteger::new("c");

// Define problem and objective sense
let mut problem = LpProblem::new("One Problem", LpObjective::Maximize);

// Objective Function: Maximize 10*a + 20*b
problem += 10.0 * a + 20.0 * b;

// Constraint: 500*a + 1200*b + 1500*c <= 10000
problem += (500*a + 1200*b + 1500*c).le(10000);

// Constraint: a <= b
problem += (a).le(b);

// Specify solver
let solver = CbcSolver::new();

// Run optimisation and process output hashmap
match solver.run(&problem) {
    Ok((status, var_values)) => {
        println!("Status {:?}", status);
        for (name, value) in var_values.iter() {
            println!("value of {} = {}", name, value);
        }
    },
    Err(msg) => println!("{}", msg),
}

problem.write_lp("problem.lp")

extern crate lp_modeler;
#[macro_use] extern crate maplit;

use std::collections::HashMap;

use lp_modeler::variables::*;
use lp_modeler::variables::LpExpression::*;
use lp_modeler::operations::LpOperations;
use lp_modeler::problem::{LpObjective, LpProblem, LpFileFormat};
use lp_modeler::solvers::{SolverTrait, CbcSolver};

// Problem Data
let men = vec!["A", "B", "C"];
let women = vec!["D", "E", "F"];
let compat_scores = hashmap!{
    ("A", "D") => 50.0,
    ("A", "E") => 75.0,
    ("A", "F") => 75.0,
    ("B", "D") => 60.0,
    ("B", "E") => 95.0,
    ("B", "F") => 80.0,
    ("C", "D") => 60.0,
    ("C", "E") => 70.0,
    ("C", "F") => 80.0,
};

// Define Problem
let mut problem = LpProblem::new("Matchmaking", LpObjective::Maximize);

// Define Variables
let mut vars = HashMap::new();
for m in &men{
    for w in &women{
        vars.insert((m, w), LpBinary::new(&format!("{}_{}", m, w)));
    }
}

// Define Objective Function
let mut obj_vec: Vec<LpExpression> = Vec::new();
for (&(&m, &w), var) in &vars{
    let obj_coef = compat_scores.get(&(m, w)).unwrap();
    obj_vec.push(*obj_coef * var);
}
problem += lp_sum(&obj_vec);

// Define Constraints
// Constraint 1: Each man must be assigned to exactly one woman
for m in &men{
    let mut constr_vec = Vec::new();

    for w in &women{
        constr_vec.push(1.0 * vars.get(&(m, w)).unwrap());
    }

    problem += lp_sum(&constr_vec).equal(1);
}

// Constraint 2: Each woman must be assigned to exactly one man
for w in &women{
    let mut constr_vec = Vec::new();

    for m in &men{
        constr_vec.push(1.0 * vars.get(&(m, w)).unwrap());
    }

    problem += lp_sum(&constr_vec).equal(1);
}

// Run Solver
let solver = CbcSolver::new();
let result = solver.run(&problem);

// Terminate if error, or assign status & variable values
assert!(result.is_ok(), result.unwrap_err());
let (solver_status, var_values) = result.unwrap();

// Compute final objective function value
let mut obj_value = 0f32;
for (&(&m, &w), var) in &vars{
    let obj_coef = compat_scores.get(&(m, w)).unwrap();
    let var_value = var_values.get(&var.name).unwrap();
    
    obj_value += obj_coef * var_value;
}

// Print output
println!("Status: {:?}", solver_status);
println!("Objective Value: {}", obj_value);
// println!("{:?}", var_values);
for (var_name, var_value) in &var_values{
    let int_var_value = *var_value as u32;
    if int_var_value == 1{
        println!("{} = {}", var_name, int_var_value);
    }
}