extern crate regex;
use std::env;
use std::process;
use std::fs::File;
use std::io::prelude::*;
use regex::Regex;
use std::fmt::{ Formatter, Debug };
use std::fmt;

fn main() {
	let args = env::args().collect();

	let filename = parse_filename(&args);

	let mut contents = String::new();
	get_contents(&filename, &mut contents);

	//println!("{}", contents);

	let (samples, program) = parse_content(&contents);

	//println!("Samples:\n{:?}\n\nProgram:\n{:?}", samples, program);

	let part1 = has3pos(&samples);

	println!("Part1: {}", part1);

	let opcodes = deduce_opcodes(&samples);

	let part2 = execute(program, opcodes)[0];

	println!("Part2: {}", part2);

}

fn execute(program: Program, opcodes: Vec<OpCode>) -> Vec<usize> {
	let mut codes = opcodes.clone();
	codes.sort_by_key(|code| code.num);
	let mut reg = vec![0,0,0,0];

	for line in program.lines.iter() {
		//println!("{:?}", reg);
		let params = line[1..4].to_vec();
		println!("{} {:?}",codes[line[0]].name, params);
		(codes[line[0]].f)(&params,&mut reg);
		//println!("");
	}

	reg
}

fn deduce_opcodes(samples: &Vec<Sample>) -> Vec<OpCode> {
	let mut opcodes = Vec::new();
	let named_functions = get_named_functions();

	let mut candidates = Vec::new();
	for (name, function) in named_functions.iter() {
		let mut possibilities = Vec::new();
		for num in 0..16 {
			let no_possibility = samples.iter()
				.filter(|sample| sample.code[0] == num)
				.any(|sample| !sample.could_be(function));

			if !no_possibility{
				let opcode = OpCode {name: name.clone(), num: num, f: *function};
				possibilities.push(opcode)
			}
		}
		//println!("Possibilities:\n{:?}", possibilities);
		candidates.push(possibilities);
	}

	//println!("Candidates:\n{:?}", candidates);
	let mut found = Vec::new();

	while found.len() < 16 {
		for possibilities in candidates.iter() {
			let new: Vec<OpCode> = possibilities.iter().cloned().filter(|pos| !found.contains(&pos.num)).collect();
			if new.len() == 1 {
				opcodes.push(new[0].clone());
				found.push(new[0].num)
			}
		}
	}

	opcodes
}

fn get_functions() -> Vec<fn(&Vec<usize>, &mut Vec<usize>)> {
	let mut functions: Vec<fn(&Vec<usize>, &mut Vec<usize>)> = Vec::new();
	functions.push(addi); functions.push(addr);
	functions.push(muli); functions.push(mulr);
	functions.push(bani); functions.push(banr);
	functions.push(bori); functions.push(borr);
	functions.push(seti); functions.push(setr);
	functions.push(gtir); functions.push(gtri); functions.push(gtrr);
	functions.push(eqir); functions.push(eqri); functions.push(eqrr);
	functions
}

fn get_named_functions() -> Vec<(String, fn(&Vec<usize>, &mut Vec<usize>))> {
	let mut functions: Vec<(String, fn(&Vec<usize>, &mut Vec<usize>))> = Vec::new();
	functions.push(("addi".to_string(),addi)); functions.push(("addr".to_string(), addr));
	functions.push(("muli".to_string(),muli)); functions.push(("mulr".to_string(),mulr));
	functions.push(("bani".to_string(),bani)); functions.push(("banr".to_string(),banr));
	functions.push(("bori".to_string(),bori)); functions.push(("borr".to_string(),borr));
	functions.push(("seti".to_string(),seti)); functions.push(("setr".to_string(),setr));
	functions.push(("gtir".to_string(),gtir)); functions.push(("gtri".to_string(),gtri)); functions.push(("gtrr".to_string(),gtrr));
	functions.push(("eqir".to_string(),eqir)); functions.push(("eqri".to_string(),eqri)); functions.push(("eqrr".to_string(),eqrr));
	functions
}

fn has3pos(samples: &Vec<Sample>) -> i64 {
	let functions = get_functions();

	samples.iter().map(|sample| sample.num_candidates(&functions)).filter(|num| *num >= 3).count() as i64

}

fn parse_content(contents: &str) -> (Vec<Sample>, Program) {
	let mut samples = Vec::new();
	let mut prog = Vec::new();
	let mut lines = contents.trim_right().lines();
	let re = Regex::new(r"(\d+)").unwrap();

	while let Some(line) = lines.next() {
		 if line.starts_with("Before") {
			 let mut before = Vec::new();
			 for cap in re.captures_iter(line) {
				 before.push(cap[1].parse::<usize>().unwrap());
			 }

			 let mut code = Vec::new();
			 let code_line = lines.next().expect("Wrongly formatted sample");
			 for cap in re.captures_iter(code_line) {
				 code.push(cap[1].parse::<usize>().unwrap());
			 }

			 let mut after = Vec::new();
			 let after_line = lines.next().expect("Wrongly formatted sample");
			 for cap in re.captures_iter(after_line) {
				 after.push(cap[1].parse::<usize>().unwrap());
			 }

			 samples.push(Sample {before, code, after} );

		 }
		 if line != "" {
			 let mut source = Vec::new();
			 for cap in re.captures_iter(line) {
				 source.push(cap[1].parse::<usize>().unwrap());
			 }
			 prog.push(source);
		 }
	}

	(samples, Program {lines: prog})
}

#[derive(Clone)]
struct OpCode {
	name: String,
	num: usize,
	f: fn(&Vec<usize>, &mut Vec<usize>),
}

impl Debug for OpCode {
	fn fmt(&self, f: &mut Formatter) -> fmt::Result {
		write!(f, "OpCode {{ name: {}, num: {} }}", self.name, self.num)
	}

}

#[derive(Debug)]
struct Sample {
	before: Vec<usize>,
	code: Vec<usize>,
	after: Vec<usize>,
}

impl Sample {
	fn could_be(&self, f: impl Fn(&Vec<usize>, &mut Vec<usize>)) -> bool {
		let mut reg = self.before.clone();
		f(&self.code[1..4].to_vec(), &mut reg);
		reg == self.after
	}

	fn num_candidates(&self, functions: &Vec<fn(&Vec<usize>, &mut Vec<usize>)>) -> i64 {
		functions.iter().filter(|f| self.could_be(f)).count() as i64
	}
}

#[derive(Debug)]
struct Program {
	lines: Vec<Vec<usize>>,
}

fn parse_filename(args: &Vec<String>) -> &str {

	if args.len() < 2 {
		println!("Too few arguements, please give a filename");
		process::exit(1);
	}
    args.get(1).expect("No filename provided")
}

fn get_contents(filename: &str, contents: &mut String) {
    let mut f = File::open(filename).expect("File not found");

    f.read_to_string(contents)
        .expect("Something went wrong reading the file");
}

fn addr(params: &Vec<usize>, reg: &mut Vec<usize>) {
	if let [a,b,c] = params[0..3] {
		reg[c] = reg[a] + reg[b];
	} else {
		panic!("Wrong amount of paramters to addr")
	}
}

fn addi(params: &Vec<usize>, reg: &mut Vec<usize>) {
	if let [a,b,c] = params[0..3] {
		reg[c] = reg[a] + b;
	} else {
		panic!("Wrong amount of paramters to addr")
	}
}

fn mulr(params: &Vec<usize>, reg: &mut Vec<usize>) {
	if let [a,b,c] = params[0..3] {
		reg[c] = reg[a] * reg[b];
	} else {
		panic!("Wrong amount of paramters to addr")
	}
}

fn muli(params: &Vec<usize>, reg: &mut Vec<usize>) {
	if let [a,b,c] = params[0..3] {
		reg[c] = reg[a] * b;
	} else {
		panic!("Wrong amount of paramters to addr")
	}
}

fn banr(params: &Vec<usize>, reg: &mut Vec<usize>) {
	if let [a,b,c] = params[0..3] {
		reg[c] = reg[a] & reg[b];
	} else {
		panic!("Wrong amount of paramters to addr")
	}
}

fn bani(params: &Vec<usize>, reg: &mut Vec<usize>) {
	if let [a,b,c] = params[0..3] {
		reg[c] = reg[a] & b;
	} else {
		panic!("Wrong amount of paramters to addr")
	}
}

fn borr(params: &Vec<usize>, reg: &mut Vec<usize>) {
	if let [a,b,c] = params[0..3] {
		reg[c] = reg[a] | reg[b];
	} else {
		panic!("Wrong amount of paramters to addr")
	}
}

fn bori(params: &Vec<usize>, reg: &mut Vec<usize>) {
	if let [a,b,c] = params[0..3] {
		reg[c] = reg[a] | b;
	} else {
		panic!("Wrong amount of paramters to addr")
	}
}

fn setr(params: &Vec<usize>, reg: &mut Vec<usize>) {
	if let [a,_b,c] = params[0..3] {
		reg[c] = reg[a];
	} else {
		panic!("Wrong amount of paramters to addr")
	}
}

fn seti(params: &Vec<usize>, reg: &mut Vec<usize>) {
	if let [a,_b,c] = params[0..3] {
		reg[c] = a;
	} else {
		panic!("Wrong amount of paramters to addr")
	}
}

fn gtir(params: &Vec<usize>, reg: &mut Vec<usize>) {
	if let [a,b,c] = params[0..3] {
		reg[c] = if a > reg[b] { 1 } else { 0 }
	} else {
		panic!("Wrong amount of paramters to addr")
	}
}

fn gtri(params: &Vec<usize>, reg: &mut Vec<usize>) {
	if let [a,b,c] = params[0..3] {
		reg[c] = if reg[a] > b { 1 } else { 0 }
	} else {
		panic!("Wrong amount of paramters to addr")
	}
}

fn gtrr(params: &Vec<usize>, reg: &mut Vec<usize>) {
	if let [a,b,c] = params[0..3] {
		reg[c] = if reg[a] > reg[b] { 1 } else { 0 }
	} else {
		panic!("Wrong amount of paramters to addr")
	}
}

fn eqir(params: &Vec<usize>, reg: &mut Vec<usize>) {
	if let [a,b,c] = params[0..3] {
		reg[c] = if a == reg[b] { 1 } else { 0 }
	} else {
		panic!("Wrong amount of paramters to addr")
	}
}

fn eqri(params: &Vec<usize>, reg: &mut Vec<usize>) {
	if let [a,b,c] = params[0..3] {
		reg[c] = if reg[a] == b { 1 } else { 0 }
	} else {
		panic!("Wrong amount of paramters to addr")
	}
}

fn eqrr(params: &Vec<usize>, reg: &mut Vec<usize>) {
	if let [a,b,c] = params[0..3] {
		reg[c] = if reg[a] == reg[b] { 1 } else { 0 }
	} else {
		panic!("Wrong amount of paramters to addr")
	}
}

#[cfg(test)]
mod test {
	use super::*;

	#[test]
	fn test_addr() {
		let mut reg = vec![1,2,3,4];
		let params = vec![0,1,3];
		addr(&params, &mut reg);
		assert_eq!(reg, vec![1,2,3,3])
	}

	#[test]
	fn test_addi() {
		let mut reg = vec![1,2,3,4];
		let params = vec![0,1,3];
		addi(&params, &mut reg);
		assert_eq!(reg, vec![1,2,3,2])
	}

	#[test]
	fn test_mulr() {
		let mut reg = vec![1,2,3,4];
		let params = vec![0,1,3];
		mulr(&params, &mut reg);
		assert_eq!(reg, vec![1,2,3,2])
	}

	#[test]
	fn test_muli() {
		let mut reg = vec![1,2,3,4];
		let params = vec![0,1,3];
		muli(&params, &mut reg);
		assert_eq!(reg, vec![1,2,3,1])
	}

	#[test]
	fn test_banr() {
		let mut reg = vec![1,2,3,4];
		let params = vec![0,1,3];
		banr(&params, &mut reg);
		assert_eq!(reg, vec![1,2,3,0])
	}

	#[test]
	fn test_bani() {
		let mut reg = vec![1,2,3,4];
		let params = vec![0,1,3];
		bani(&params, &mut reg);
		assert_eq!(reg, vec![1,2,3,1])
	}

	#[test]
	fn test_borr() {
		let mut reg = vec![1,2,3,4];
		let params = vec![0,1,3];
		borr(&params, &mut reg);
		assert_eq!(reg, vec![1,2,3,3])
	}

	#[test]
	fn test_bori() {
		let mut reg = vec![1,2,3,4];
		let params = vec![0,1,3];
		bori(&params, &mut reg);
		assert_eq!(reg, vec![1,2,3,1])
	}

	#[test]
	fn test_setr() {
		let mut reg = vec![1,2,3,4];
		let params = vec![0,1,3];
		setr(&params, &mut reg);
		assert_eq!(reg, vec![1,2,3,1])
	}

	#[test]
	fn test_seti() {
		let mut reg = vec![1,2,3,4];
		let params = vec![0,1,3];
		seti(&params, &mut reg);
		assert_eq!(reg, vec![1,2,3,0])
	}

	#[test]
	fn test_gtir() {
		let mut reg = vec![1,2,3,4];
		let params = vec![0,1,3];
		gtir(&params, &mut reg);
		assert_eq!(reg, vec![1,2,3,0])
	}

	#[test]
	fn test_gtri() {
		let mut reg = vec![1,2,3,4];
		let params = vec![0,1,3];
		gtri(&params, &mut reg);
		assert_eq!(reg, vec![1,2,3,0])
	}

	#[test]
	fn test_gtrr() {
		let mut reg = vec![1,2,3,4];
		let params = vec![0,1,3];
		gtrr(&params, &mut reg);
		assert_eq!(reg, vec![1,2,3,0])
	}

	#[test]
	fn test_eqir() {
		let mut reg = vec![1,2,3,4];
		let params = vec![0,1,3];
		eqir(&params, &mut reg);
		assert_eq!(reg, vec![1,2,3,0])
	}

	#[test]
	fn test_eqri() {
		let mut reg = vec![1,2,3,4];
		let params = vec![0,1,3];
		eqri(&params, &mut reg);
		assert_eq!(reg, vec![1,2,3,1])
	}

	#[test]
	fn test_eqrr() {
		let mut reg = vec![1,2,3,4];
		let params = vec![0,1,3];
		eqrr(&params, &mut reg);
		assert_eq!(reg, vec![1,2,3,0])
	}

	#[test]
	fn test_could_be_mulr() {
		let sample = Sample {before: vec![3,2,1,1], code: vec![9,2,1,2], after: vec![3,2,2,1]};
		assert_eq!(sample.could_be(mulr), true)
	}
	#[test]
	fn test_could_be_addi() {
		let sample = Sample {before: vec![3,2,1,1], code: vec![9,2,1,2], after: vec![3,2,2,1]};
		assert_eq!(sample.could_be(addi), true)
	}
	#[test]
	fn test_could_be_seti() {
		let sample = Sample {before: vec![3,2,1,1], code: vec![9,2,1,2], after: vec![3,2,2,1]};
		assert_eq!(sample.could_be(seti), true)
	}
	#[test]
	fn test_could_not_be_banr() {
		let sample = Sample {before: vec![3,2,1,1], code: vec![9,2,1,2], after: vec![3,2,2,1]};
		assert_eq!(sample.could_be(banr), false)
	}

	#[test]
	fn num_candidates() {
		let sample = Sample {before: vec![3,2,1,1], code: vec![9,2,1,2], after: vec![3,2,2,1]};
		let functions = get_functions();

		assert_eq!(sample.num_candidates(&functions), 3)
	}
}