HSRAvatar{{
	
	private Config config;
	
	/* Constructor to be called during registration where you supply config*/
	public HSRAvatar(Config cfg){
		config = cfg;
	}
	
	/**proposing random unique claims which are not in the forbidden list**/
	public ProposeResponse propose(ProposeRequest pr){
		List<Claim> claims = List.create();
		SCGConfig scg_cfg = config.getScgCfg();
		int maxProposals = scg_cfg.getMaxProposals() -1;
		for(Claim c: pr.getForbidden()){
			c.finishParse();
		}
		for(int i =0; i< maxProposals;i++){
			Claim claim = generateRandomClaim();
			while(pr.getForbidden().contains(claim) || claims.contains(claim)){
				claim = generateRandomClaim();
			}
			claims = claims.append(claim);
		}
		return new ProposeResponse(claims);
	}
	
	/**Random oppose method - randomly agrees, refutes or strengthens by a factor of 1 **/
	public OpposeResponse oppose(OpposeRequest or){
		return new OpposeResponse(or.getClaims().map(new List.Map<Claim, OpposeAction>() {
			public OpposeAction map(Claim claim){
				Random rand = new Random();
				int randOppose = rand.nextInt(3);
				if(randOppose == 0)
					return new NoOpposition();
				else if(randOppose == 1){
					claim.finishParse();
					HSRInstanceSet is = (HSRInstanceSet)claim.getInstanceSet().getInstanceSet();
					int n = is.getSingleton().getN();
					int q = (int)Math.ceil(claim.getQuality() * n);
					SCGConfig scg_cfg = config.getScgCfg();
					if (claim.getProtocol() instanceof Positive){
						if(q>1)
							return new Strengthening(claim.getQuality() - scg_cfg.getMinStrengthening());
						else
							return new Refuting();
					}else{
						if(q<n){
							return new Strengthening(claim.getQuality() + scg_cfg.getMinStrengthening());
						}else{
							return new Refuting();
						}
					}
						 
				}else 
					return new Refuting();
            }
		}));
	}
	
	/** providing instance - in HSR this is trivial as the instanceSet is singleton**/
	public ProvideResponse provide(ProvideRequest pr){
		pr.getClaim().finishParse();
		HSRInstanceSet hsrInstanceSet = (HSRInstanceSet) pr.getClaim().getInstanceSet().getInstanceSet();
		HSRInstance hsrInstance = new HSRInstance(hsrInstanceSet.getSingleton().getN(), hsrInstanceSet.getSingleton().getK());
		Instance instance = null;
		try {
			instance = new Instance(FullyQualifiedClassName.parse("hsr.HSRInstance") , hsrInstance, new verbatim(hsrInstance.print()));
		} catch (Exception e) {	}
		return new ProvideResponse(instance);
	}
	
	/**solving using trivial algorithm of dropping jars lowest rung upwards - max number of left branch = 1**/
	public SolveResponse solve(SolveRequest sr){
		if(sr.getInstance().getInstance() == null){
			sr.getInstance().finishParse();
		}
		HSRInstance hsrInstance = (HSRInstance)sr.getInstance().getInstance();
		HSRSolution solution = solve(1, hsrInstance.getN());
		try{
			SolveResponse response = new SolveResponse(new Solution(FullyQualifiedClassName.parse("hsr.HSRSolution"), solution, new verbatim(solution.print())));
			return response;
		}catch(Exception e){
			return null;
		}
		
		
	}
	private HSRSolution solve(int n, int maxValueIntermediateNode){
		if(n == maxValueIntermediateNode) return new Simple(n-1);
		else{
			return new Compound(n, new Simple(n-1), solve(n+1, maxValueIntermediateNode));
		}
	}
	
	/** Generates random claim */
	private Claim generateRandomClaim(){
		Claim claim = null;
		Random rand = new Random();
		boolean nextBoolean = rand.nextBoolean();
		int randN = 2+ rand.nextInt(20);
		//check if N value is less than maxN in HSRConfig
		DomainConfig dom_cfg = config.getDomainCfg();
		dom_cfg.finishParse();
		HSRConfig hsr_cfg = (HSRConfig)dom_cfg.getConfig();
		if(randN > hsr_cfg.getMaxN()){
			randN = 2+ rand.nextInt(hsr_cfg.getMaxN() - 2);
		}
		int randK = 1 + rand.nextInt(randN - 1);
		int randQ = 1+ rand.nextInt(randN - 1);
		HSRInstance singleton = new HSRInstance(randN, randK); // get the maximum allowed n from config
		HSRInstanceSet instanceSet = new HSRInstanceSet(singleton );
		
		try {
			InstanceSet instance = new InstanceSet(FullyQualifiedClassName.parse("hsr.HSRInstanceSet"), instanceSet , new verbatim(instanceSet.print()));
			if(nextBoolean)
				claim = new Claim(instance, FullyQualifiedClassName.parse("hsr.protocol.Positive"), new Positive(), ((double)randQ)/randN);
			else 
				claim = new Claim(instance, FullyQualifiedClassName.parse("hsr.protocol.Negative"), new Negative(), ((double)randQ)/randN);
		} catch (scg.ParseException e) { }
		
		return claim;
	}
}}