ScriptPolicyNone    Policy = 0 // not yet reviewed
	ScriptPolicyAllowed Policy = 1
	ScriptPolicyBlocked Policy = 2
	ScriptPolicyDelete  Policy = 3
	ScriptPolicyReplace Policy = 4
async fn review(config:ReviewConfig)->Result<(),ReviewError>{
	// download unreviewed policies
	// review them
	let cookie=submissions_api::Cookie::new(&config.session_id).map_err(ReviewError::Cookie)?;
	let api=submissions_api::external::Context::new(config.api_url,cookie).map_err(ReviewError::Reqwest)?;

	let unreviewed_policies=api.get_script_policies(submissions_api::types::GetScriptPoliciesRequest{
		Page:1,
		Limit:100,
		FromScriptHash:None,
		ToScriptID:None,
		Policy:Some(submissions_api::types::Policy::None),
	}).await.map_err(ReviewError::GetPolicies)?;

	for unreviewed_policy in unreviewed_policies{
		// download source code
		let script_response=api.get_script_from_hash(submissions_api::types::HashRequest{
			hash:unreviewed_policy.FromScriptHash.as_str(),
		}).await
		.map_err(ReviewError::GetScriptFromHash)?
		.ok_or(ReviewError::NoScript)?;

		let source=script_response.Source;
		//load source into current.lua
		tokio::fs::write("current.lua",source.as_str()).await.map_err(ReviewError::WriteCurrent)?;

		//prompt action in terminal
		//wait for input
		let script_action;
		loop{
			print!("action: ");
			std::io::Write::flush(&mut std::io::stdout()).map_err(ReviewError::ActionIO)?;
			let mut action_string=String::new();
			std::io::stdin().read_line(&mut action_string).map_err(ReviewError::ActionIO)?;
			if let Ok(parsed_script_action)=action_string.parse::<ScriptActionParseResult>(){
				script_action=parsed_script_action;
				break;
			}
		}
		// default to_script_id is from from_script_id (only changed for replace policy)
		let mut to_script_id=None;
		// interpret action
		let reviewed_policy=match script_action{
			ScriptActionParseResult::Pass=>{
				//if current.lua was updated, create an allowed and replace file and set script_action to replace(new_id)
				let modified_source=tokio::fs::read_to_string("current.lua").await.map_err(ReviewError::ReadCurrent)?;
				if modified_source==source{
					submissions_api::types::Policy::Allowed
				}else{
					// compute hash
					let hash=hash_source(source.as_str());

					// check if modified script already exists
					let maybe_script_response=api.get_script_from_hash(submissions_api::types::HashRequest{
						hash:format!("{:016x}",hash).as_str(),
					}).await.map_err(ReviewError::DeduplicateModified)?;

					// write to_script_id, uploading modified script if necessary
					to_script_id=Some(match maybe_script_response{
						Some(script_response)=>script_response.ID,
						None=>api.create_script(submissions_api::types::CreateScriptRequest{
							Name:script_response.Name.as_str(),
							Source:modified_source.as_str(),
							SubmissionID:Some(script_response.SubmissionID),
						}).await.map_err(ReviewError::UploadModified)?.ID
					});

					// use replace policy
					submissions_api::types::Policy::Replace
				}
			},
			ScriptActionParseResult::Block=>submissions_api::types::Policy::Blocked,
			ScriptActionParseResult::Exit=>break,
			ScriptActionParseResult::Delete=>submissions_api::types::Policy::Delete,
		};

		// update policy
		api.update_script_policy(submissions_api::types::UpdateScriptPolicyRequest{
			ID:unreviewed_policy.ID,
			FromScriptID:None,
			ToScriptID:to_script_id,
			Policy:Some(reviewed_policy),
		}).await.map_err(ReviewError::UpdateScriptPolicy)?;
	}

	Ok(())
}