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

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

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

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

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

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

pub struct Battle {
  a: Cryp,
  b: Cryp,
  // winner: Option<Cryp>,
}

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 }
}

pub fn battle(mut a: Cryp, mut b: Cryp) -> Battle {
  // println!("battle:",);
  // println!("{:?}", cryps[0]);
  // println!("{:?}", cryps[1]);

  loop {
    let a_turn = cryp_turn(&a);
    let b_turn = cryp_turn(&b);

    a = a.assign_dmg(&b, &a_turn, &b_turn);
    b = b.assign_dmg(&a, &b_turn, &a_turn);
    // println!("{:?}", combat);


    let mut finished = false;
    {
      if vec![&a, &b].iter().any(|c| c.hp == 0) {
        finished = true
      }
    }

    if finished {
      break Battle { a, b };
    }
  }
}

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();

  // have to reassign here because battle takes ownership
  let Battle { a: plr, b: mob } = battle(plr, mob);

  let win = vec![&plr, &mob].iter().any(|c| c.id == plr.id && c.hp > 0);

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

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

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

    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);

    // LEVEL CAP
    if c.lvl == 12 {
      break c;
    }

    continue;
  }
}

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

  #[test]
  fn pve_test() {
    let player = Cryp::new()
      .named("ca phe sua da".to_string())
      .level(2)
      .create();

    levelling(player);
    return;
  }

}