SNPDict{
	const <emptyBasePair = #[\none,\none];
	const <emptyBase = #[\none];
	var <snpDict;
	var <snpArr;
	var <positionLookup;
	var <unknownLookup;
	var <unknownArr;
	var <unknownToDelete;
	var <>length;
	var <positions = 0;
	var <unknowns = 0;
	var <userID;

	*new{
		arg aLength, aUserID = 0;
		^super.new.init(aLength, aUserID);
	}

	init{
		arg aLength, aUserID;
		userID = aUserID.asInt;
		length = aLength.asInt;
		snpDict = Dictionary.new(length);
		//snpArr = Array.new(length);
		positionLookup = Dictionary.new(length);
		unknownLookup = Dictionary.new(length);
		//unknownArr = Array.new(length);
	}
	
	updatePositionLookup{//sort the dictionary's position lookup table when updating a new position
		arg position, positionAdd;
		if(positionAdd,{//add or remove a position in the lookup table
			positionLookup.add(position.asFloat -> true);
		},{
			positionLookup.removeAt(position.asFloat);
		});
	}

	updateUnknownLookup{//sort the dictionary's unknown lookup table when updating a SNP with unknown resolver
		arg position, positionAdd;
		if(positionAdd,{
			unknownLookup.add(position.asFloat -> true);
		},{
			unknownLookup.removeAt(position.asFloat);
		});
	}

	orderLookup{//order the lookup tables (position and unknown) and store them to Arrays (for sequential access)
		arg table;
		switch(table,
			0,{
				snpArr = positionLookup.order;
				("Done sorting position lookup table. Positions: "++snpArr.size.asString).postln;
				^true;
			},
			1,{
				unknownArr = unknownLookup.order;
				("Done sorting unknown lookup table. Unknowns: "++snpArr.size.asString).postln;
				^true;
			},
			2,{
				snpArr = positionLookup.order;
				("Done sorting position lookup table. Positions: "++snpArr.size.asString).postln;
				unknownArr = unknownLookup.order;
				("Done sorting unknown lookup table. Unknowns: "++snpArr.size.asString).postln;
				unknownLookup = nil;
				positionLookup = nil;
				^true;
			},{
				("Unknown operation on sorting lookup tables: "++table.asString).postln;
				^false;
			}
		);
	}

	storeSNP{//store a combo to the snpDict and the lookup tables when reading from opensnp.org -file
		arg snp, position;
		var positionHolder, new = 0;//the SNP holder in snpDict
		if(snpDict.includesKey(position.asSymbol), {//if there is an entry already, add this one after it
			snpDict.at(position.asSymbol).add(snp.chromosome -> snp);
			new = -1;
		},{//else create the first one in this slot
			positionHolder = Dictionary.new(25);	
			positionHolder.add(snp.chromosome -> snp);
			snpDict.put(position.asSymbol, positionHolder);
			this.updatePositionLookup(position, true);
			new = 1;
			positions = positions+1;
		});
		if(snp.hasResolver.not,{//if the SNP has no resolver, update the unknown lookup table
			this.updateUnknownLookup(position, true);
		});
		^new;
	}

	storeSNPFromFile{//store a combo to the snpDict and the lookup tables when reading from own file
		arg snp, position;
		var positionHolder, new = 0;//the SNP holder in snpDict
		if(snpDict.includesKey(position.asSymbol), {//if there is an entry already, add this one after it
			snpDict.at(position.asSymbol).add(snp.chromosome -> snp);
		},{//else create the first one in this slot
			positionHolder = Dictionary.new(25);
			positionHolder.add(snp.chromosome -> snp);
			snpDict.put(position.asSymbol, positionHolder);
		});
	}
	
	initLookupFromFile{//init lookup table from file with size given
		arg posLookup, unLookup;
		snpArr = Array.new(posLookup);
		unknownArr = Array.new(unLookup);
	}

	addPositionLookupFromFile{//put a position to the position lookup table when reading from own file
		arg posArr, posSNP;
		snpArr.add(posSNP);
	}

	addUnknownLookupFromFile{//put a position to the position lookup table when reading from own file
		arg posArr, posSNP;
		unknownArr.add(posSNP);
	}
	
	updateResolver{//update a SNP resolver at a given position
		arg position, id, resolver;
		var resolverLeft;
		if(resolver!=SNPInfo.emptyBasePair && resolver!=SNPInfo.emptyBase,{//if the resolver is none, don't do anything
			snpDict.at(position.asSymbol).do({
				arg snpItem;
				if(id==snpItem.id, {
					snpItem.resolver_(resolver);
					("Resolver updated.").postln;
					^true;
				});
			});
//			resolverLeft = this.noneResolverAtPosition(position);
//			if(resolverLeft == false,{//if there are no unknowns left, delete position from lookup table
//				unknownArr.removeAt(unknownArr.indexOf(position.asFloat));
//			});
//			resolverLeft = nil;
		},{
			("Not updating position "++position++". Resolver is none.").postln;
			^false;
		});
	}

	deleteSNP{//delete a SNP at a given position
		arg snp, position;
		var snpCounter = 0, deleted = false;
		snpDict.at(position.asSymbol).do({
			arg snpItem, i;
//			if(snpItem.notNil, {
				snpCounter = snpCounter + 1;
				if(snp.id == snpItem.id{
					snpItem.removeAt(position.asSymbol);
					snpCounter = snpCounter - 1;
					deleted = true;
				});
//			});
		});
		if(snpCounter < 1,{//delete the complete position if there is no SNP left
			snpDict.removeAt(position.asSymbol);
			this.sortPositionLookup(-1, position);
			this.sortUnknownLookup(-1, position);
		});
		^deleted;
	}

	noneResolverAtPosition{//return a Dictionary of Chromosome -> SNP pairs that don't have a resolver or false if none found
		arg position;
		var noneResolver = Dictionary.new(25), noneResolverCount = 0;
		if(snpDict.includesKey(position.asSymbol),{//if the position exists, check it
			snpDict.at(position.asSymbol).keysValuesDo({
				arg chromosome, snp;
				if(snp.hasResolver.not,{
					noneResolver.add(chromosome -> snp);
					noneResolverCount = noneResolverCount + 1;
				});
			});
			if(noneResolverCount>0,{
				^noneResolver;
			},{
				^false;
			});
		},{
			^false;
		});
	}

	snpAtPosition{//return a Dictionary of chromosome -> SNP pairs at a given position, or false if none available
		arg position;
		if(snpDict.includesKey(position.asSymbol),{//check if the key is there
			^snpDict.at(position.asSymbol);//return the Dictionary at position
		},{
			^false;
		});
	}
	
	distanceToNextPosition{//calculate the distance from current position, to the one following
		arg position;
		var now; 
		if(position==0.0,{//if it's the beginning, return first position later on
			now = -1;
		},{
			now = snpArr.indexOf(position.asFloat);
		});
		switch(now,
			nil,{^position},
			snpArr.size-1,{^0},
			-1,{^snpArr[0]},
			{^snpArr[(snpArr.indexOf(position.asFloat)+1)]-position;}
		);
	}

	queryStatistics{//query statistics about this SNPDict
		//TODO: shortest/longest/mean distance between SNPs
		//TODO: unknown/total SNPs
		//TODO: number of SNPs per chromosome
		//TODO: unknown/total SNPs per chromosome
		//TODO: total positions
	}
}