use config::*;
pub mod prelude;

pub use prelude::*;

pub fn mine<Config>(
  method: Method,
  voters: Vec<(
    Config::AccountId,
    VoteWeight,
    BoundedVec<Config::AccountId, Config::MaxVotesPerVoter>,
  )>,
  targets: Vec<Config::AccountId>,
  round: u32,
  desired_targets: u32,
) -> Result<RawSolution<SolutionOf<Config>>, anyhow::Error>
where
  Config: MinerConfig,
{
  let (solution, score, _solution_or_snapshot_size, _trimming_status) =
    match method {
      Method::SeqPhragmen => Miner::<Config>::mine_solution_with_snapshot::<
        SeqSolver<Config>,
      >(voters, targets, desired_targets)
      .expect("seq miner failed"),
      Method::PhragMMS => Miner::<Config>::mine_solution_with_snapshot::<
        MmsSolver<Config>,
      >(voters, targets, desired_targets)
      .expect("mms miner failed"),
    };
  // TODO: Miner::<C>::feasibility_check(); -> ready_solution
  Ok(RawSolution {
    solution,
    score,
    round,
  })
}

pub struct Solutions {
  pub raw_solution: Vec<u8>,
  pub ready_solution: Vec<u8>,
}

pub fn solve(
  chain: &str,
  method: &str,
  snapshot_bytes: &[u8],
  round: u32,
  desired_targets: u32,
  iterations: usize,
  tolerance: u128,
) -> Result<Solutions, anyhow::Error> {
  BalanceIterations::set(iterations);
  Tolerance::set(tolerance);
  let method = method.parse::<Method>()?;
  let chain = chain.parse::<Chain>()?;
  let mut snapshot_bytes = snapshot_bytes;
  with_chain!(chain, {
    type Snapshot = RoundSnapshot<
      AccountId,
      Voter<AccountId, <Config as MinerConfig>::MaxVotesPerVoter>,
    >;

    let snapshot: Snapshot = Decode::decode(&mut snapshot_bytes)?;

    let raw_solution: RawSolution<SolutionOf<Config>> = mine::<Config>(
      method,
      snapshot.voters.clone(),
      snapshot.targets.clone(),
      round,
      desired_targets,
    )?;

    let ready_solution: ReadySolution<
      <Config as MinerConfig>::AccountId,
      <Config as MinerConfig>::MaxWinners,
    > = Miner::<Config>::feasibility_check(
      raw_solution.clone(),
      ElectionCompute::Signed,
      desired_targets,
      snapshot,
      round,
      Some(ElectionScore::default()),
    )
    .map_err(|e| anyhow::anyhow!("feasibility check failed: {:?}", e))?;

    Ok(Solutions {
      raw_solution: raw_solution.encode(),
      ready_solution: ready_solution.encode(),
    })
  }) // with_chain!()
}