use rand::prelude::*;
use cryp::Cryp;

struct Turn {
  dmg: Roll,
  def: Roll,
}

#[derive(Debug)]
enum Attribute {
  Dmg,
  Def,
}

// impl Attribute {
//   pub fn as_str(&self) -> &'static str {
//     match self {
//         Dmg => "dmg",
//         Def => "def",
//     }
//   }
// }

struct Roll {
  value: u64,
  roll: u64,
  result: u64,
  att: Attribute
}

struct Encounter {
  mob: Cryp,
  success: bool,
}



fn att_roll(value: u64, att: Attribute) -> Roll {
  let mut rng = thread_rng();
  let roll: u64 = rng.gen();
  return Roll { att, value, roll, result: value & roll };
}

fn print_roll(r: &Roll) {
  println!("{:?}", r.att);
  println!("{:064b} &", r.roll);
  println!("{:064b}", r.value);
  println!("{:064b} - {:?}", r.result, r.result);
  println!("");
}

fn cryp_turn(c: &Cryp) -> Turn {
  // println!("{:?}'s turn:", c.name);
  let dmg = att_roll(c.dmg, Attribute::Dmg);
  let def = att_roll(c.def, Attribute::Def);

  // print_roll(&dmg);
  // print_roll(&def);

  return Turn { dmg, def }
}

fn assign_dmg(plr: &Cryp, opp: &Cryp, plr_t: &Turn, opp_t: &Turn) -> Cryp {
  let final_dmg = opp_t.dmg.result.saturating_sub(plr_t.def.result);
  let blocked = opp_t.dmg.result.saturating_sub(final_dmg);
  let new_stam = plr.stam.saturating_sub(final_dmg);

  println!("{:?} deals {:?} dmg to {:?} ({:?} blocked / {:?} hp remaining)"
    ,opp.name
    ,final_dmg
    ,plr.name
    ,blocked
    ,new_stam);

  return Cryp {
    dmg: plr.dmg,
    def: plr.def,
    stam: new_stam,
    xp: plr.xp,
    lvl: plr.lvl,
    id: plr.id,
    name: plr.name.clone()
  };
}

fn combat_phase(a: &Cryp, b: &Cryp) -> Vec<Cryp> {
  let a_turn = cryp_turn(&a);
  let b_turn = cryp_turn(&b);
  return vec![
  assign_dmg(&a, &b, &a_turn, &b_turn),
  assign_dmg(&b, &a, &b_turn, &a_turn),
  ];
}

pub fn battle(a: &Cryp, b: &Cryp) -> Vec<Cryp> {
  let mut cryps = vec![
    a.clone(),
    b.clone()
  ];

  // println!("battle:",);
  // println!("{:?}", cryps[0]);
  // println!("{:?}", cryps[1]);
  loop {
    let combat = combat_phase(&cryps[0], &cryps[1]);
    // println!("{:?}", combat);
    if combat.iter().any(|c| c.stam == 0) {
      return combat;
    }
    cryps = combat;
  }
}

fn pve(plr: &Cryp) -> Encounter {
  let mut rng = thread_rng();
  let mob_lvl: u8 = rng.gen_range(1, plr.lvl);

  let mob = Cryp::new()
    .named("bamboo basher".to_string())
    .level(mob_lvl)
    .create();

  let battle = battle(plr, &mob);
  let win = battle.iter().any(|c| c.id == plr.id && c.stam > 0);

  if win {
    return Encounter {
      mob: mob,
      success: true,
    };
  }

  return Encounter {
    mob: mob,
    success: false,
  };
}

pub fn levelling(mut c: Cryp) -> Cryp {
  loop {
    let enc = pve(&c);

    if !enc.success {
      println!("{:?} has been KO'd", c.name);
      break c;
    }

    println!("{:?} rekt {:?}", c.name, enc.mob.name);
    c = c.add_xp();
    println!("{:?} now has {:?} xp and is lvl {:?}", c.name, c.xp, c.lvl);

    if c.lvl == 12 {
      break c;
    }

    continue;
  }
}