// readGeneticAnalysis provides function to read genetic analyses

package readGeneticAnalysis

import "seekia/resources/geneticReferences/monogenicDiseases"
import "seekia/resources/geneticReferences/polygenicDiseases"
import "seekia/resources/geneticReferences/traits"


import "seekia/internal/helpers"

import "encoding/json"
import "strings"
import "errors"

// This works for person and couple analyses
func ReadGeneticAnalysisString(inputAnalysisString string)([]map[string]string, error){

	inputAnalysisBytes := []byte(inputAnalysisString)

	var newAnalysisMapList []map[string]string

	err := json.Unmarshal(inputAnalysisBytes, &newAnalysisMapList)
	if (err != nil) { return nil, err }

	return newAnalysisMapList, nil
}

//Outputs:
//	-[]string: All raw genome identifiers list (excluding combined genomes)
//	-bool: Multiple genomes exist
//	-string: OnlyExcludeConflicts GenomeIdentifier
//	-string: OnlyIncludeShared GenomeIdentifier
//	-error
func GetMetadataFromPersonGeneticAnalysis(inputGeneticAnalysisMapList []map[string]string)([]string, bool, string, string, error){

	for _, element := range inputGeneticAnalysisMapList{

		itemType, exists := element["ItemType"]
		if (exists == false){
			return nil, false, "", "", errors.New("Malformed genetic analysis map list: Item missing itemType")
		}
		if (itemType != "Metadata"){
			continue
		}

		analysisVersion, exists := element["AnalysisVersion"]
		if (exists == false){
			return nil, false, "", "", errors.New("Cannot read analysis: Metadata missing analysisVersion")
		}

		if (analysisVersion != "1"){
			// This analysis must have been created by a newer version of Seekia
			// We cannot read it
			return nil, false, "", "", errors.New("Cannot read analysis: Is a newer analysis version.")
		}

		analysisType, exists := element["AnalysisType"]
		if (exists == false || analysisType != "Person"){
			return nil, false, "", "", errors.New("Trying to get metadata from non-person analysis.")
		}

		combinedGenomesExist, exists := element["CombinedGenomesExist"]
		if (exists == false){
			return nil, false, "", "", errors.New("Malformed analysis map list: Metadata missing CombinedGenomesExist")
		}
		if (combinedGenomesExist == "No"){

			mainGenomeIdentifier, exists := element["GenomeIdentifier"]
			if (exists == false){
				return nil, false, "", "", errors.New("Malformed analysis map list: Single-genome analysis Metadata missing GenomeIdentifier")
			}
			
			allRawGenomeIdentifiersList := []string{mainGenomeIdentifier}

			return allRawGenomeIdentifiersList, false, "", "", nil
		}

		onlyExcludeConflictsGenomeIdentifier, exists := element["OnlyExcludeConflictsGenomeIdentifier"]
		if (exists == false){
			return nil, false, "", "", errors.New("Malformed analysis map list: Metadata missing OnlyExcludeConflictsGenomeIdentifier")
		}
		onlyIncludeSharedGenomeIdentifier, exists := element["OnlyIncludeSharedGenomeIdentifier"]
		if (exists == false){
			return nil, false, "", "", errors.New("Malformed genetic analysis map list: Metadata missing OnlyIncludeSharedGenomeIdentifier")
		}

		allRawGenomeIdentifiersListString, exists := element["AllRawGenomeIdentifiersList"]
		if (exists == false){
			return nil, false, "", "", errors.New("Malformed analysis map list: Multi-genome Metadata missing AllRawGenomeIdentifiersList")
		}

		allRawGenomeIdentifiersList := strings.Split(allRawGenomeIdentifiersListString, "+")

		if (len(allRawGenomeIdentifiersList) < 2){
			return nil, false, "", "", errors.New("Malformed analysis map list: Multi-genome Metadata contains AllRawGenomeIdentifiersList with less than two identifiers")
		}

		return allRawGenomeIdentifiersList, true, onlyExcludeConflictsGenomeIdentifier, onlyIncludeSharedGenomeIdentifier, nil
	}

	return nil, false, "", "", errors.New("GetMetadataFromPersonGeneticAnalysis called with malformed person analysis map list: missing Metadata item.")
} 

//Outputs:
//	-string: Pair 1 Person A Genome Identifier
//	-string: Pair 1 Person B Genome Identifier
//	-bool: Second Genome pair exists
//	-string: Pair 2 Person A Genome Identifier
//	-string: Pair 2 Person B Genome Identifier
//	-bool: Person A Has Multiple Genomes
//	-string: Person A OnlyExcludeConflicts Genome Identifier
//	-string: Person A OnlyIncludeShared Genome Identifier
//	-bool: Person B Has Multiple Genomes
//	-string: Person B OnlyExcludeConflicts Genome Identifier
//	-string: Person B OnlyIncludeShared Genome Identifier
//	-error
func GetMetadataFromCoupleGeneticAnalysis(inputGeneticAnalysisMapList []map[string]string)(string, string, bool, string, string, bool, string, string, bool, string, string, error){

	for _, element := range inputGeneticAnalysisMapList{

		itemType, exists := element["ItemType"]
		if (exists == false){
			return "", "", false, "", "", false, "", "", false, "", "", errors.New("Malformed genetic analysis map list: Item missing itemType")
		}
		if (itemType != "Metadata"){
			continue
		}

		analysisVersion, exists := element["AnalysisVersion"]
		if (exists == false){
			return "", "", false, "", "", false, "", "", false, "", "", errors.New("Cannot read analysis: Metadata missing analysisVersion")
		}

		if (analysisVersion != "1"){
			// This analysis must have been created by a newer version of Seekia
			// We cannot read it
			return "", "", false, "", "", false, "", "", false, "", "", errors.New("Cannot read analysis: Is a newer analysis version.")
		}

		analysisType, exists := element["AnalysisType"]
		if (exists == false || analysisType != "Couple"){
			return "", "", false, "", "", false, "", "", false, "", "", errors.New("Trying to get metadata from non-couple analysis.")
		}

		pair1PersonAGenomeIdentifier, exists := element["Pair1PersonAGenomeIdentifier"]
		if (exists == false){
			return "", "", false, "", "", false, "", "", false, "", "", errors.New("Malformed couple analysis: Metadata missing Pair1PersonAGenomeIdentifier")
		}

		pair1PersonBGenomeIdentifier, exists := element["Pair1PersonBGenomeIdentifier"]
		if (exists == false){
			return "", "", false, "", "", false, "", "", false, "", "", errors.New("Malformed couple analysis: Metadata missing Pair1PersonBGenomeIdentifier")
		}

		secondPairExists, exists := element["SecondPairExists"]
		if (exists == false){
			return "", "", false, "", "", false, "", "", false, "", "", errors.New("Malformed analysis map list: Metadata missing CombinedGenomesExist")
		}
		if (secondPairExists == "No"){

			return pair1PersonAGenomeIdentifier, pair1PersonBGenomeIdentifier, false, "", "", false, "", "", false, "", "", nil
		}

		pair2PersonAGenomeIdentifier, exists := element["Pair2PersonAGenomeIdentifier"]
		if (exists == false){
			return "", "", false, "", "", false, "", "", false, "", "", errors.New("Malformed couple analysis map list: Metadata missing Pair2PersonAGenomeIdentifier")
		}

		pair2PersonBGenomeIdentifier, exists := element["Pair2PersonBGenomeIdentifier"]
		if (exists == false){
			return "", "", false, "", "", false, "", "", false, "", "", errors.New("Malformed couple analysis map list: Metadata missing Pair2PersonBGenomeIdentifier")
		}

		getPersonAMultipleGenomesInfo := func()(bool, string, string, error){

			personAHasMultipleGenomes, exists := element["PersonAHasMultipleGenomes"]
			if (exists == false){
				return false, "", "", errors.New("Couple analysis malformed: Missing PersonAHasMultipleGenomes")
			}

			if (personAHasMultipleGenomes == "No"){
				return false, "", "", nil	
			}

			personAOnlyExcludeConflictsGenomeIdentifier, exists := element["PersonAOnlyExcludeConflictsGenomeIdentifier"]
			if (exists == false) {
				return false, "", "", errors.New("Couple analysis malformed: Missing PersonAOnlyExcludeConflictsGenomeIdentifier")
			}

			personAOnlyIncludeSharedGenomeIdentifier, exists := element["PersonAOnlyIncludeSharedGenomeIdentifier"]
			if (exists == false) {
				return false, "", "", errors.New("Couple analysis malformed: Missing PersonAOnlyIncludeSharedGenomeIdentifier")
			}

			return true, personAOnlyExcludeConflictsGenomeIdentifier, personAOnlyIncludeSharedGenomeIdentifier, nil
		}

		getPersonBMultipleGenomesInfo := func()(bool, string, string, error){

			personBHasMultipleGenomes, exists := element["PersonBHasMultipleGenomes"]
			if (exists == false){
				return false, "", "", errors.New("Couple analysis malformed: Missing PersonBHasMultipleGenomes")
			}

			if (personBHasMultipleGenomes == "No"){
				return false, "", "", nil
			}

			personBOnlyExcludeConflictsGenomeIdentifier, exists := element["PersonBOnlyExcludeConflictsGenomeIdentifier"]
			if (exists == false) {
				return false, "", "", errors.New("Couple analysis malformed: Missing PersonBOnlyExcludeConflictsGenomeIdentifier")
			}

			personBOnlyIncludeSharedGenomeIdentifier, exists := element["PersonBOnlyIncludeSharedGenomeIdentifier"]
			if (exists == false) {
				return false, "", "", errors.New("Couple analysis malformed: Missing PersonBOnlyIncludeSharedGenomeIdentifier")
			}

			return true, personBOnlyExcludeConflictsGenomeIdentifier, personBOnlyIncludeSharedGenomeIdentifier, nil
		}

		personAHasMultipleGenomes, personAOnlyExcludeConflictsGenomeIdentifier, personAOnlyIncludeSharedGenomeIdentifier, err := getPersonAMultipleGenomesInfo()
		if (err != nil) { return "", "", false, "", "", false, "", "", false, "", "", err }

		personBHasMultipleGenomes, personBOnlyExcludeConflictsGenomeIdentifier, personBOnlyIncludeSharedGenomeIdentifier, err := getPersonBMultipleGenomesInfo()
		if (err != nil) { return "", "", false, "", "", false, "", "", false, "", "", err }

		return pair1PersonAGenomeIdentifier, pair1PersonBGenomeIdentifier, true, pair2PersonAGenomeIdentifier, pair2PersonBGenomeIdentifier, personAHasMultipleGenomes, personAOnlyExcludeConflictsGenomeIdentifier, personAOnlyIncludeSharedGenomeIdentifier, personBHasMultipleGenomes, personBOnlyExcludeConflictsGenomeIdentifier, personBOnlyIncludeSharedGenomeIdentifier, nil
	}

	return "", "", false, "", "", false, "", "", false, "", "", errors.New("GetMetadataFromCoupleGeneticAnalysis called with malformed couple analysis map list: missing Metadata item.")
}


// This function will take a couple and person analysis
// It takes in a genome identifier from the couple analysis
// It returns the equivalent genome identifier from the person analysis
// This is needed for combined genomes, because their identifiers are generated randomly for each analysis
//Inputs:
//	-bool: Is person A
//	-[]map[string]string: Person A Analysis Map List
//	-[]map[string]string: Person B Analysis Map List
//	-[]map[string]string: Couple Analysis Map List
//	-string: Input Genome Identifier (Should be from Couple identifier)
//Outputs:
//	-string: Genome identifier from person analysis
//	-bool: Person analysis has multiple genomes
//	-bool: Genome is a combined genome
//	-string: Genome combined type ("Only Exclude Conflicts"/"Only Include Shared")
//	-error
func GetMatchingPersonAnalysisGenomeIdentifierFromCoupleAnalysis(isPersonA bool, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, inputGenomeIdentifier string)(string, bool, bool, string, error){

	// We need to figure out which genome identifier the current genome identifier corresponds to within the person analysis
	// If the genome is not a combined genome, then the genome identifier should be identical between each analysis
	// If it is a combined genome, we need to determine which genome it corresponds to

	_, _, secondGenomePairExists, _, _, personAHasMultipleGenomes, personAOnlyExcludeConflictsGenomeIdentifier, personAOnlyIncludeSharedGenomeIdentifier, personBHasMultipleGenomes, personBOnlyExcludeConflictsGenomeIdentifier, personBOnlyIncludeSharedGenomeIdentifier, err := GetMetadataFromCoupleGeneticAnalysis(coupleAnalysisMapList)
	if (err != nil) { return "", false, false, "", err }

	if (isPersonA == true){

		if (personAHasMultipleGenomes == false){
			// This person does not have multiple genomes. The genome identifier is the same between both analyses
			return inputGenomeIdentifier, false, false, "", nil
		}

		if (secondGenomePairExists == false){
			return inputGenomeIdentifier, true, false, "", nil
		}

		_, multipleGenomesExist, onlyExcludeConflictsGenomeIdentifier, onlyIncludeSharedGenomeIdentifier, err := GetMetadataFromPersonGeneticAnalysis(personAAnalysisMapList)
		if (err != nil) { return "", false, false, "", err }
		if (multipleGenomesExist == false){
			return "", false, false, "", errors.New("Couple analysis says person has multiple genomes, person analysis does not.")
		}

		if (inputGenomeIdentifier == personAOnlyExcludeConflictsGenomeIdentifier){
			return onlyExcludeConflictsGenomeIdentifier, true, true, "Only Exclude Conflicts", nil
		}
		if (inputGenomeIdentifier == personAOnlyIncludeSharedGenomeIdentifier){
			return onlyIncludeSharedGenomeIdentifier, true, true, "Only Include Shared", nil
		}
		return "", false, false, "", errors.New("Combined genome identifier from couple analysis does not correspond to either combined genome from person analysis.")
	}

	// isPersonA == false

	if (personBHasMultipleGenomes == false){
		// This person does not have multiple genomes. The genome identifier is the same between both analyses
		return inputGenomeIdentifier, false, false, "", nil
	}

	if (secondGenomePairExists == false){
		return inputGenomeIdentifier, true, false, "", nil
	}

	_, multipleGenomesExist, onlyExcludeConflictsGenomeIdentifier, onlyIncludeSharedGenomeIdentifier, err := GetMetadataFromPersonGeneticAnalysis(personBAnalysisMapList)
	if (err != nil) { return "", false, false, "", err }
	if (multipleGenomesExist == false){
		return "", false, false, "", errors.New("Couple analysis says person has multiple genomes, person analysis does not.")
	}

	if (inputGenomeIdentifier == personBOnlyExcludeConflictsGenomeIdentifier){
		return onlyExcludeConflictsGenomeIdentifier, true, true, "Only Exclude Conflicts", nil
	}
	if (inputGenomeIdentifier == personBOnlyIncludeSharedGenomeIdentifier){
		return onlyIncludeSharedGenomeIdentifier, true, true, "Only Include Shared", nil
	}

	return "", false, false, "", errors.New("Combined genome identifier from couple analysis does not correspond to either combined genome from person analysis.")
}


//Outputs:
//	-bool: Probabilities known
//	-int: Probability of having disease
//	-string: Probability of having disease formatted (with % suffix)
//	-int: Probability of passing a disease variant
//	-string: Probability of passing a disease variant formatted (with % suffix)
//	-int: Number of variants tested
//	-bool: Conflict exists 
//	-error
func GetPersonMonogenicDiseaseInfoFromGeneticAnalysis(personAnalysisMapList []map[string]string, diseaseName string, genomeIdentifier string, personHasMultipleGenomes bool)(bool, int, string, int, string, int, bool, error){

	for _, element := range personAnalysisMapList{

		itemType, exists := element["ItemType"]
		if (exists == false) {
			return false, 0, "", 0, "", 0, false, errors.New("Malformed analysisMapList: Item missing itemType")
		}

		if (itemType != "MonogenicDisease"){
			continue
		}

		currentDiseaseName, exists := element["DiseaseName"]
		if (exists == false){
			return false, 0, "", 0, "", 0, false, errors.New("Malformed analysisMapList: Monogenic Disease item missing DiseaseName")
		}

		if (currentDiseaseName != diseaseName){
			continue
		}

		numberOfVariantsTested, exists := element[genomeIdentifier + "_NumberOfVariantsTested"]
		if (exists == false){
			return false, 0, "", 0, "", 0, false, errors.New("Malformed person analysis: Monogenic Disease item missing _NumberOfVariantsTested")
		}

		numberOfVariantsTestedInt, err := helpers.ConvertStringToInt(numberOfVariantsTested)
		if (err != nil){
			return false, 0, "", 0, "", 0, false, errors.New("Malformed person analysis: Monogenic Disease item contains invalid _NumberOfVariantsTested: " + numberOfVariantsTested)
		}

		getConflictExistsBool := func()(bool, error){

			if (personHasMultipleGenomes == false){
				return false, nil
			}

			conflictExists, exists := element["ConflictExists"]
			if (exists == false) {
				return false, errors.New("Malformed analysisMapList: Missing ConflictExists")
			}

			if (conflictExists == "Yes"){
				return true, nil
			}
			return false, nil
		}

		conflictExistsBool, err := getConflictExistsBool()
		if (err != nil) { return false, 0, "", 0, "", 0, false, err }

		probabilityOfHavingDisease, exists := element[genomeIdentifier + "_ProbabilityOfHavingDisease"]
		if (exists == false) {
			return false, 0, "", 0, "", 0, false, errors.New("Malformed analysisMapList: Monogenic Disease map missing _ProbabilityOfHavingDisease")
		}

		if (probabilityOfHavingDisease == "Unknown"){
			return false, 0, "", 0, "", numberOfVariantsTestedInt, conflictExistsBool, nil
		}

		probabilityOfHavingDiseaseInt, err := helpers.ConvertStringToInt(probabilityOfHavingDisease)
		if (err != nil){
			return false, 0, "", 0, "", 0, false, errors.New("Malformed person analysis: Monogenic Disease map contains invalid _ProbabilityOfHavingDisease: " + probabilityOfHavingDisease)
		}

		probabilityOfHavingDiseaseFormatted := probabilityOfHavingDisease + "%"

		probabilityOfPassingAVariant, exists := element[genomeIdentifier + "_ProbabilityOfPassingADiseaseVariant"]
		if (exists == false) {
			return false, 0, "", 0, "", 0, false, errors.New("Malformed analysisMapList: Monogenic Disease map missing _ProbabilityOfPassingADiseaseVariant")
		}

		probabilityOfPassingAVariantInt, err := helpers.ConvertStringToInt(probabilityOfPassingAVariant)
		if (err != nil){
			return false, 0, "", 0, "", 0, false, errors.New("Malformed person analysis: Monogenic Disease map contains invalid _ProbabilityOfPassingADiseaseVariant: " + probabilityOfPassingAVariant)
		}

		probabilityOfPassingAVariantFormatted := probabilityOfPassingAVariant + "%"

		return true, probabilityOfHavingDiseaseInt, probabilityOfHavingDiseaseFormatted, probabilityOfPassingAVariantInt, probabilityOfPassingAVariantFormatted, numberOfVariantsTestedInt, conflictExistsBool, nil
	}

	return false, 0, "", 0, "", 0, false, errors.New("GetPersonMonogenicDiseaseInfoFromGeneticAnalysis failed: Cannot find monogenicDisease item in person analysis. Disease name: " + diseaseName)
}

//Outputs:
//	-bool: Probabilities known
//	-int: Percentage Probability of offspring having disease
//	-string: Probability of offspring having disease formatted (with % suffix)
//	-int: Percentage probability of offspring having a disease variant
//	-string: Percentage probability of offspring having a disease variant formatted (with % suffix)
//	-bool: Conflict exists between genome pairs
//	-error
func GetOffspringMonogenicDiseaseInfoFromGeneticAnalysis(coupleAnalysisMapList []map[string]string, diseaseName string, genomePairIdentifier string, secondGenomePairExists bool)(bool, int, string, int, string, bool, error){

	for _, element := range coupleAnalysisMapList{

		itemType, exists := element["ItemType"]
		if (exists == false) {
			return false, 0, "", 0, "", false, errors.New("Malformed couple analysis: Item missing itemType")
		}

		if (itemType != "MonogenicDisease"){
			continue
		}

		currentDiseaseName, exists := element["DiseaseName"]
		if (exists == false){
			return false, 0, "", 0, "", false, errors.New("Malformed couple analysis: Monogenic Disease item missing DiseaseName")
		}

		if (diseaseName != currentDiseaseName){
			continue
		}

		getConflictExistsBool := func()(bool, error){

			if (secondGenomePairExists == false){
				return false, nil
			}

			conflictExists, exists := element["ConflictExists"]
			if (exists == false) {
				return false, errors.New("Malformed couple analysis: Monogenic disease map missing ConflictExists")
			}

			if (conflictExists == "Yes"){
				return true, nil
			}

			return false, nil
		}

		conflictExistsBool, err := getConflictExistsBool()
		if (err != nil) { return false, 0, "", 0, "", false, err }

		probabilityOfOffspringHavingDisease, exists := element[genomePairIdentifier + "_ProbabilityOffspringHasDisease"]
		if (exists == false) {
			return false, 0, "", 0, "", false, errors.New("Malformed couple analysis: Monogenic Disease map missing _ProbabilityOffspringHasDisease")
		}
		
		if (probabilityOfOffspringHavingDisease == "Unknown"){
			return false, 0, "", 0, "", conflictExistsBool, nil
		}
		
		probabilityOfOffspringHavingDiseaseInt, err := helpers.ConvertStringToInt(probabilityOfOffspringHavingDisease)
		if (err != nil){
			return false, 0, "", 0, "", false, errors.New("Malformed couple analysis: Monogenic Disease map contains invalid _ProbabilityOffspringHasDisease: " + probabilityOfOffspringHavingDisease)
		}

		probabilityOfOffspringHavingDiseaseFormatted := probabilityOfOffspringHavingDisease + "%"

		probabilityOfOffspringHavingVariant, exists := element[genomePairIdentifier + "_ProbabilityOffspringHasVariant"]
		if (exists == false) {
			return false, 0, "", 0, "", false, errors.New("Malformed analysisMapList: Monogenic Disease map missing _ProbabilityOffspringHasVariant")
		}

		probabilityOfOffspringHavingVariantInt, err := helpers.ConvertStringToInt(probabilityOfOffspringHavingVariant)
		if (err != nil){
			return false, 0, "", 0, "", false, errors.New("Malformed analysisMapList: Monogenic Disease map missing _ProbabilityOffspringHasVariant")
		}
	
		probabilityOfOffspringHavingVariantFormatted := probabilityOfOffspringHavingVariant + "%"

		return true, probabilityOfOffspringHavingDiseaseInt, probabilityOfOffspringHavingDiseaseFormatted, probabilityOfOffspringHavingVariantInt, probabilityOfOffspringHavingVariantFormatted, conflictExistsBool, nil
	}

	return false, 0, "", 0, "", false, errors.New("GetOffspringMonogenicDiseaseInfoFromGeneticAnalysis called with invalid analysis: Cannot find disease info in couple analysis: " + diseaseName)
}

//Outputs:
//	-bool: Number of mutations known
//	-int: Number of mutations
//	-error
func GetPersonMonogenicDiseaseVariantInfoFromGeneticAnalysis(personAnalysisMapList []map[string]string, diseaseName string, variantIdentifier string, genomeIdentifier string)(bool, int, error){

	for _, element := range personAnalysisMapList{

		itemType, exists := element["ItemType"]
		if (exists == false) {
			return false, 0, errors.New("Malformed person analysis: Item missing itemType")
		}

		if (itemType != "MonogenicDiseaseVariant"){
			continue
		}

		currentDiseaseName, exists := element["DiseaseName"]
		if (exists == false){
			return false, 0, errors.New("Malformed person analysis: Monogenic Disease item missing DiseaseName")
		}

		if (currentDiseaseName != diseaseName){
			continue
		}

		currentVariantIdentifier, exists := element["VariantIdentifier"]
		if (exists == false) {
			return false, 0, errors.New("Malformed person analysis: MonogenicDiseaseVariant item missing VariantIdentifier")
		}

		if (currentVariantIdentifier != variantIdentifier){
			continue
		}

		genomeHasVariantValue, exists := element[genomeIdentifier + "_HasVariant"]
		if (exists == false){
			return false, 0, errors.New("Malformed person analysis: MonogenicDiseaseVariant item missing _HasVariant key for genome")
		}

		if (genomeHasVariantValue == "Unknown"){
			return false, 0, nil
		}
		if (genomeHasVariantValue == "No;No"){
			return true, 0, nil
		}
		if (genomeHasVariantValue == "Yes;No" || genomeHasVariantValue == "No;Yes"){
			return true, 1, nil
		}
		if (genomeHasVariantValue == "Yes;Yes"){
			return true, 2, nil
		}

		return false, 0, errors.New("Malformed person analysis: Invalid genomeHasVariantValue: " + genomeHasVariantValue)
	}

	return false, 0, errors.New("GetPersonMonogenicDiseaseVariantInfoFromGeneticAnalysis failed: Info not found.")
}


//Outputs:
//	-bool: Offspring Probabilities Known 
//	-int: Lower Bound Percentage Probability of 0 mutations
//	-int: Upper Bound Percentage Probability of 0 mutations
//	-string: Percentage probability of 0 mutations formatted (has % suffix and - between non-identical bounds)
//	-int: Lower Bound Percentage probability of only 1 mutation
//	-int: Upper Bound Percentage probability of only 1 mutation
//	-string: Percentage probability of 1 mutation formatted (has % suffix and - between non-identical bounds)
//	-int: Lower Bound Percentage probability of 2 mutations
//	-int: Upper Bound Percentage probability of 2 mutations
//	-string: Percentage probability of 2 mutations formatted (has % suffix and - between non-identical bounds)
//	-error
func GetOffspringMonogenicDiseaseVariantInfoFromGeneticAnalysis(coupleAnalysisMapList []map[string]string, diseaseName string, variantIdentifier string, genomePairIdentifier string)(bool, int, int, string, int, int, string, int, int, string, error){

	for _, element := range coupleAnalysisMapList{

		itemType, exists := element["ItemType"]
		if (exists == false) {
			return false, 0, 0, "", 0, 0, "", 0, 0, "", errors.New("Malformed coupleAnalysisMapList: Item missing itemType")
		}

		if (itemType != "MonogenicDiseaseVariant"){
			continue
		}
		currentDiseaseName, exists := element["DiseaseName"]
		if (exists == false) {
			return false, 0, 0, "", 0, 0, "", 0, 0, "", errors.New("Malformed couple Analysis: MonogenicDiseaseVariant item missing DiseaseName")
		}
	
		if (currentDiseaseName != diseaseName){
			continue
		}

		currentVariantIdentifier, exists := element["VariantIdentifier"]
		if (exists == false) {
			return false, 0, 0, "", 0, 0, "", 0, 0, "", errors.New("Malformed couple analysis: MonogenicDiseaseVariant item missing VariantIdentifier")
		}

		if (currentVariantIdentifier != variantIdentifier){
			continue
		}

		probabilityOf0MutationsLowerBound, exists := element[genomePairIdentifier + "_ProbabilityOf0MutationsLowerBound"]
		if (exists == false){
			return false, 0, 0, "", 0, 0, "", 0, 0, "", errors.New("Malformed analysisMapList: MonogenicDiseaseVariant item missing _ProbabilityOf0MutationsLowerBound key")
		}
		if (probabilityOf0MutationsLowerBound == "Unknown"){
			return false, 0, 0, "", 0, 0, "", 0, 0, "", nil
		}

		probabilityOf0MutationsUpperBound, exists := element[genomePairIdentifier + "_ProbabilityOf0MutationsUpperBound"]
		if (exists == false){
			return false, 0, 0, "", 0, 0, "", 0, 0, "", errors.New("Malformed analysisMapList: MonogenicDiseaseVariant item missing _ProbabilityOf0MutationsUpperBound")
		}

		probabilityOf1MutationLowerBound, exists := element[genomePairIdentifier + "_ProbabilityOf1MutationLowerBound"]
		if (exists == false){
			return false, 0, 0, "", 0, 0, "", 0, 0, "", errors.New("Malformed analysisMapList: MonogenicDiseaseVariant item missing _ProbabilityOf1MutationLowerBound key")
		}

		probabilityOf1MutationUpperBound, exists := element[genomePairIdentifier + "_ProbabilityOf1MutationUpperBound"]
		if (exists == false){
			return false, 0, 0, "", 0, 0, "", 0, 0, "", errors.New("Malformed analysisMapList: MonogenicDiseaseVariant item missing _ProbabilityOf1MutationUpperBound")
		}

		probabilityOf2MutationsLowerBound, exists := element[genomePairIdentifier + "_ProbabilityOf2MutationsLowerBound"]
		if (exists == false){
			return false, 0, 0, "", 0, 0, "", 0, 0, "", errors.New("Malformed analysisMapList: MonogenicDiseaseVariant item missing _ProbabilityOf2MutationsLowerBound key")
		}

		probabilityOf2MutationsUpperBound, exists := element[genomePairIdentifier + "_ProbabilityOf2MutationsUpperBound"]
		if (exists == false){
			return false, 0, 0, "", 0, 0, "", 0, 0, "", errors.New("Malformed analysisMapList: MonogenicDiseaseVariant item missing _ProbabilityOf2MutationsUpperBound")
		}

		probabilityOf0MutationsLowerBoundInt, err := helpers.ConvertStringToInt(probabilityOf0MutationsLowerBound)
		if (err != nil){
			return false, 0, 0, "", 0, 0, "", 0, 0, "", errors.New("Malformed couple analysis: MonogenicDiseaseVariant contains invalid _ProbabilityOf0MutationsLowerBound: " + probabilityOf0MutationsLowerBound)
		}

		probabilityOf0MutationsUpperBoundInt, err := helpers.ConvertStringToInt(probabilityOf0MutationsUpperBound)
		if (err != nil){
			return false, 0, 0, "", 0, 0, "", 0, 0, "", errors.New("Malformed couple analysis: MonogenicDiseaseVariant contains invalid _ProbabilityOf0MutationsUpperBound: " + probabilityOf0MutationsUpperBound)
		}

		probabilityOf1MutationLowerBoundInt, err := helpers.ConvertStringToInt(probabilityOf1MutationLowerBound)
		if (err != nil){
			return false, 0, 0, "", 0, 0, "", 0, 0, "", errors.New("Malformed couple analysis: MonogenicDiseaseVariant contains invalid _ProbabilityOf1MutationLowerBound: " + probabilityOf1MutationLowerBound)
		}

		probabilityOf1MutationUpperBoundInt, err := helpers.ConvertStringToInt(probabilityOf1MutationUpperBound)
		if (err != nil){
			return false, 0, 0, "", 0, 0, "", 0, 0, "", errors.New("Malformed couple analysis: MonogenicDiseaseVariant contains invalid _ProbabilityOf1MutationUpperBound: " + probabilityOf1MutationUpperBound)
		}

		probabilityOf2MutationsLowerBoundInt, err := helpers.ConvertStringToInt(probabilityOf2MutationsLowerBound)
		if (err != nil){
			return false, 0, 0, "", 0, 0, "", 0, 0, "", errors.New("Malformed couple analysis: MonogenicDiseaseVariant contains invalid _ProbabilityOf2MutationsLowerBound: " + probabilityOf2MutationsLowerBound)
		}

		probabilityOf2MutationsUpperBoundInt, err := helpers.ConvertStringToInt(probabilityOf2MutationsUpperBound)
		if (err != nil){
			return false, 0, 0, "", 0, 0, "", 0, 0, "", errors.New("Malformed couple analysis: MonogenicDiseaseVariant contains invalid _ProbabilityOf2MutationsUpperBound: " + probabilityOf2MutationsUpperBound)
		}

		getOffspringProbabilityOf0MutationsFormatted := func()string{

			probabilityOf0MutationsLowerBoundFormatted := probabilityOf0MutationsLowerBound + "%"	

			if (probabilityOf0MutationsLowerBoundInt == probabilityOf0MutationsUpperBoundInt){
				return probabilityOf0MutationsLowerBoundFormatted
			}
		
			probabilityOf0MutationsUpperBoundFormatted := probabilityOf0MutationsUpperBound + "%"

			formattedResult := probabilityOf0MutationsLowerBoundFormatted + " - " + probabilityOf0MutationsUpperBoundFormatted

			return formattedResult
		}

		probabilityOf0MutationsFormatted := getOffspringProbabilityOf0MutationsFormatted()

		getOffspringProbabilityOf1MutationFormatted := func()string{

			probabilityOf1MutationLowerBoundFormatted := probabilityOf1MutationLowerBound + "%"	

			if (probabilityOf1MutationLowerBoundInt == probabilityOf1MutationUpperBoundInt){
				return probabilityOf1MutationLowerBoundFormatted
			}

			probabilityOf1MutationUpperBoundFormatted := probabilityOf1MutationUpperBound + "%"

			formattedResult := probabilityOf1MutationLowerBoundFormatted + " - " + probabilityOf1MutationUpperBoundFormatted

			return formattedResult
		}

		probabilityOf1MutationFormatted := getOffspringProbabilityOf1MutationFormatted()

		getOffspringProbabilityOf2MutationsFormatted := func()string{

			probabilityOf2MutationsLowerBoundFormatted := probabilityOf2MutationsLowerBound + "%"	

			if (probabilityOf2MutationsLowerBoundInt == probabilityOf2MutationsUpperBoundInt){
				return probabilityOf2MutationsLowerBoundFormatted
			}

			probabilityOf2MutationsUpperBoundFormatted := probabilityOf2MutationsUpperBound + "%"

			formattedResult := probabilityOf2MutationsLowerBoundFormatted + " - " + probabilityOf2MutationsUpperBoundFormatted

			return formattedResult
		}

		probabilityOf2MutationsFormatted := getOffspringProbabilityOf2MutationsFormatted()

		return true, probabilityOf0MutationsLowerBoundInt, probabilityOf0MutationsUpperBoundInt, probabilityOf0MutationsFormatted, probabilityOf1MutationLowerBoundInt, probabilityOf1MutationUpperBoundInt, probabilityOf1MutationFormatted, probabilityOf2MutationsLowerBoundInt, probabilityOf2MutationsUpperBoundInt, probabilityOf2MutationsFormatted, nil
	}

	return false, 0, 0, "", 0, 0, "", 0, 0, "", errors.New("GetOffspringMonogenicDiseaseVariantInfoFromGeneticAnalysis failed: Info not found.")
}


//Outputs:
//	-bool: Polygenic Disease Risk Score known
//	-int: Disease risk score
//	-string: Disease risk score formatted (contains "/10" suffix)
//	-int: Number of loci tested
//	-bool: Conflict exists
//	-error
func GetPersonPolygenicDiseaseInfoFromGeneticAnalysis(personAnalysisMapList []map[string]string, diseaseName string, genomeIdentifier string, personHasMultipleGenomes bool)(bool, int, string, int, bool, error){

	for _, element := range personAnalysisMapList{

		analysisItemType, exists := element["ItemType"]
		if (exists == false) {
			return false, 0, "", 0, false, errors.New("Malformed person analysis: Item missing ItemType")
		}

		if (analysisItemType != "PolygenicDisease"){
			continue
		}

		itemDiseaseName, exists := element["DiseaseName"]
		if (exists == false) {
			return false, 0, "", 0, false, errors.New("Malformed person analysis: PolygenicDisease item missing DiseaseName")
		}

		if (itemDiseaseName != diseaseName){
			continue
		}

		numberOfLociTested, exists := element[genomeIdentifier + "_NumberOfLociTested"]
		if (exists == false){
			return false, 0, "", 0, false, errors.New("Malformed person analysis: PolygenicDisease item missing _NumberOfLociTested")
		}

		numberOfLociTestedInt, err := helpers.ConvertStringToInt(numberOfLociTested)
		if (err != nil){
			return false, 0, "", 0, false, errors.New("Malformed person analysis: PolygenicDisease item contains invalid _NumberOfLociTested: " + numberOfLociTested)
		}

		getConflictExistsBool := func()(bool, error){

			if (personHasMultipleGenomes == false){
				return false, nil
			}

			conflictExists, exists := element["ConflictExists"]
			if (exists == false) {
				return false, errors.New("Malformed analysisMapList: PolygenicDisease analysis missing ConflictExists")
			}

			if (conflictExists == "Yes"){
				return true, nil
			}

			return false, nil
		}

		conflictExistsBool, err := getConflictExistsBool()
		if (err != nil) { return false, 0, "", 0, false, err }

		if (numberOfLociTestedInt == 0){
			return false, 0, "", numberOfLociTestedInt, conflictExistsBool, nil
		}

		personRiskScore, exists := element[genomeIdentifier + "_RiskScore"]
		if (exists == false){
			return false, 0, "", 0, false, errors.New("Person analysis missing _RiskScore key.")
		}

		personRiskScoreInt, err := helpers.ConvertStringToInt(personRiskScore)
		if (err != nil) {
			return false, 0, "", 0, false, errors.New("Person analysis contains invalid _RiskScore: " + personRiskScore)
		}

		personRiskScoreFormatted := personRiskScore + "/10"

		return true, personRiskScoreInt, personRiskScoreFormatted, numberOfLociTestedInt, conflictExistsBool, nil
	}

	return false, 0, "", 0, false, errors.New("GetPersonPolygenicDiseaseInfoFromGeneticAnalysis failed: Disease info not found.")
}


//Outputs:
//	-bool: Disease Risk Score known
//	-int: Disease risk score
//	-string: Disease risk score formatted (contains "/10" suffix)
//	-int: Number of loci tested
//	-bool: Conflict exists
//	-error
func GetOffspringPolygenicDiseaseInfoFromGeneticAnalysis(coupleAnalysisMapList []map[string]string, diseaseName string, genomePairIdentifier string, secondGenomePairExists bool)(bool, int, string, int, bool, error){

	for _, element := range coupleAnalysisMapList{
				
		analysisItemType, exists := element["ItemType"]
		if (exists == false) {
			return false, 0, "", 0, false, errors.New("Malformed couple analysis: Item missing ItemType")
		}

		if (analysisItemType != "PolygenicDisease"){
			continue
		}

		itemDiseaseName, exists := element["DiseaseName"]
		if (exists == false) {
			return false, 0, "", 0, false, errors.New("Malformed couple analysis: PolygenicDisease item missing DiseaseName")
		}

		if (itemDiseaseName != diseaseName){
			continue
		}

		numberOfLociTested, exists := element[genomePairIdentifier + "_NumberOfLociTested"]
		if (exists == false){
			return false, 0, "", 0, false, errors.New("Malformed couple analysis: PolygenicDisease item missing _NumberOfLociTested")
		}

		numberOfLociTestedInt, err := helpers.ConvertStringToInt(numberOfLociTested)
		if (err != nil){
			return false, 0, "", 0, false, errors.New("Malformed couple analysis: PolygenicDisease item contains invalid _NumberOfLociTested: " + numberOfLociTested)
		}

		getConflictExistsBool := func()(bool, error){

			if (secondGenomePairExists == false){
				return false, nil
			}

			conflictExists, exists := element["ConflictExists"]
			if (exists == false) {
				return false, errors.New("Malformed analysisMapList: PolygenicDisease analysis missing ConflictExists")
			}

			if (conflictExists == "Yes"){
				return true, nil
			}

			return false, nil
		}

		conflictExistsBool, err := getConflictExistsBool()
		if (err != nil) { return false, 0, "", 0, false, err }

		offspringRiskScore, exists := element[genomePairIdentifier + "_OffspringRiskScore"]
		if (exists == false){
			return false, 0, "", 0, false, errors.New("Couple analysis missing _RiskScore key.")
		}

		if (offspringRiskScore == "Unknown"){
			return false, 0, "", numberOfLociTestedInt, conflictExistsBool, nil
		}		

		offspringRiskScoreInt, err := helpers.ConvertStringToInt(offspringRiskScore)
		if (err != nil) {
			return false, 0, "", 0, false, errors.New("Couple analysis contains invalid _RiskScore: " + offspringRiskScore)
		}

		offspringRiskScoreFormatted := offspringRiskScore + "/10"

		return true, offspringRiskScoreInt, offspringRiskScoreFormatted, numberOfLociTestedInt, conflictExistsBool, nil
	}

	return false, 0, "", 0, false, errors.New("GetOffspringPolygenicDiseaseInfoFromGeneticAnalysis failed: Cannot find disease info for disease: " + diseaseName)
}

//Outputs:
//	-bool: Risk Weight and base pair known
//	-int: Locus risk weight
//	-string: Locus base pair
//	-bool: Locus odds ratio known
//	-float64: Locus odds ratio
//	-string: Locus odds ratio formatted (with x suffix)
//	-error
func GetPersonPolygenicDiseaseLocusInfoFromGeneticAnalysis(personAnalyisMapList []map[string]string, diseaseName string, locusIdentifier string, genomeIdentifier string)(bool, int, string, bool, float64, string, error){

	for _, element := range personAnalyisMapList{

		itemType, exists := element["ItemType"]
		if (exists == false) {
			return false, 0, "", false, 0, "", errors.New("Malformed person analysis: Item missing itemType")
		}

		if (itemType != "PolygenicDiseaseLocus"){
			continue
		}

		currentDiseaseName, exists := element["DiseaseName"]
		if (exists == false){
			return false, 0, "", false, 0, "", errors.New("Malformed person analysis: PolygenicDiseaseLocus item missing DiseaseName")
		}

		if (currentDiseaseName != diseaseName){
			continue
		}

		currentLocusIdentifier, exists := element["LocusIdentifier"]
		if (exists == false) {
			return false, 0, "", false, 0, "", errors.New("Malformed person analysis: PolygenicDiseaseLocus item missing LocusIdentifier")
		}

		if (currentLocusIdentifier != locusIdentifier){
			continue
		}

		genomeLocusRiskWeight, exists := element[genomeIdentifier + "_RiskWeight"]
		if (exists == false){
			return false, 0, "", false, 0, "", errors.New("Malformed person analysis: PolygenicDiseaseLocus item missing _RiskWeight")
		}

		if (genomeLocusRiskWeight == "Unknown"){
			return false, 0, "", false, 0, "", nil
		}

		locusBasePair, exists := element[genomeIdentifier + "_LocusBasePair"]
		if (exists == false){
			return false, 0, "", false, 0, "", errors.New("Malformed person analysis: PolygenicDiseaseLocus item missing LocusBasePair")
		}

		genomeLocusRiskWeightInt, err := helpers.ConvertStringToInt(genomeLocusRiskWeight)
		if (err != nil){
			return false, 0, "", false, 0, "", errors.New("Malformed person analysis: PolygenicDiseaseLocus item contains invalid _RiskWeight: " + genomeLocusRiskWeight)
		}

		genomeLocusOddsRatio, exists := element[genomeIdentifier + "_OddsRatio"]
		if (exists == false){
			return false, 0, "", false, 0, "", errors.New("Malformed person analysis: PolygenicDiseaseLocus item missing _OddsRatio")
		}

		if (genomeLocusOddsRatio == "Unknown"){
			return true, genomeLocusRiskWeightInt, locusBasePair, false, 0, "", nil
		}

		locusOddsRatioFloat64, err := helpers.ConvertStringToFloat64(genomeLocusOddsRatio)
		if (err != nil){
			return false, 0, "", false, 0, "", errors.New("Malformed person analysis: PolygenicDiseaseLocus item contains invalid _OddsRatio: " + genomeLocusOddsRatio)
		}

		genomeLocusOddsRatioString := helpers.ConvertFloat64ToStringRounded(locusOddsRatioFloat64, 2)

		locusOddsRatioFormatted := genomeLocusOddsRatioString + "x"

		return true, genomeLocusRiskWeightInt, locusBasePair, true, locusOddsRatioFloat64, locusOddsRatioFormatted, nil
	}

	return false, 0, "", false, 0, "", errors.New("GetPersonPolygenicDiseaseLocusInfoFromGeneticAnalysis failed: Locus info not found.")
}

//Outputs:
//	-bool: Offspring risk weight known
//	-int: Offspring risk weight
//	-bool: Offspring odds ratio known
//	-float64: Offspring odds ratio
//	-string: Offspring odds ratio formatted (with + and < from unknownFactors weight sum and x suffix)
//	-error
func GetOffspringPolygenicDiseaseLocusInfoFromGeneticAnalysis(coupleAnalysisMapList []map[string]string, diseaseName string, locusIdentifier string, genomePairIdentifier string)(bool, int, bool, float64, string, error){

	for _, element := range coupleAnalysisMapList{

		itemType, exists := element["ItemType"]
		if (exists == false) {
			return false, 0, false, 0, "", errors.New("Malformed couple analysis: Item missing itemType")
		}

		if (itemType != "PolygenicDiseaseLocus"){
			continue
		}
		currentDiseaseName, exists := element["DiseaseName"]
		if (exists == false) {
			return false, 0, false, 0, "", errors.New("Malformed couple analysis: PolygenicDiseaseLocus item missing DiseaseName")
		}

		if (currentDiseaseName != diseaseName){
			continue
		}

		currentLocusIdentifier, exists := element["LocusIdentifier"]
		if (exists == false) {
			return false, 0, false, 0, "", errors.New("Malformed couple analysis: PolygenicDiseaseLocus item missing LocusIdentifier")
		}

		if (currentLocusIdentifier != locusIdentifier){
			continue
		}

		offspringRiskWeight, exists := element[genomePairIdentifier + "_OffspringRiskWeight"]
		if (exists == false){
			return false, 0, false, 0, "", errors.New("Malformed couple analysis: PolygenicDiseaseLocus item missing _OffspringRiskWeight key")
		}

		if (offspringRiskWeight == "Unknown"){
			return false, 0, false, 0, "", nil
		}
	
		offspringRiskWeightInt, err := helpers.ConvertStringToInt(offspringRiskWeight)
		if (err != nil){
			return false, 0, false, 0, "", errors.New("Malformed couple analysis: PolygenicDiseaseLocus item contains invalid _OffspringRiskWeight key: " + offspringRiskWeight)
		}

		offspringOddsRatio, exists := element[genomePairIdentifier + "_OffspringOddsRatio"]
		if (exists == false){
			return false, 0, false, 0, "", errors.New("Malformed couple analysis: PolygenicDiseaseLocus item missing _OffspringOddsRatio key")
		}
		if (offspringOddsRatio == "Unknown"){
			return true, offspringRiskWeightInt, false, 0, "", nil
		}

		offspringOddsRatioFloat64, err := helpers.ConvertStringToFloat64(offspringOddsRatio)
		if (err != nil){
			return false, 0, false, 0, "", errors.New("Malformed couple analysis: Contains invalid _OffspringOddsRatio: " + offspringOddsRatio)
		}

		offspringUnknownOddsRatiosWeightSum, exists := element[genomePairIdentifier + "_OffspringUnknownOddsRatiosWeightSum"]
		if (exists == false){
			return false, 0, false, 0, "", errors.New("Malformed couple analysis: PolygenicDiseaseLocus item missing _OffspringUnknownOddsRatiosWeightSum key")
		}

		offspringUnknownOddsRatiosWeightSumInt, err := helpers.ConvertStringToInt(offspringUnknownOddsRatiosWeightSum)
		if (err != nil){
			return false, 0, false, 0, "", errors.New("Malformed couple analysis: PolygenicDiseaseLocus item contains invalid _OffspringUnknownOddsRatiosWeightSum key: " + offspringUnknownOddsRatiosWeightSum)
		}

		getOddsRatioFormatted := func()string{

			if (offspringUnknownOddsRatiosWeightSumInt == 0){
				result := offspringOddsRatio + "x"
				return result
			}
			if (offspringUnknownOddsRatiosWeightSumInt < 0){
				result := "<" + offspringOddsRatio + "x"
				return result
			}
			// offspringUnknownOddsRatiosWeightSumInt > 0
			result := offspringOddsRatio + "x+"
			return result
		}

		oddsRatioFormatted := getOddsRatioFormatted()

		return true, offspringRiskWeightInt, true, offspringOddsRatioFloat64, oddsRatioFormatted, nil
	}

	return false, 0, false, 0, "", errors.New("Malformed couple analysis: Polygenic Disease locus not found.")
}

type LocusValue struct{

	Base1 string
	Base2 string

	// Are the bases ordered or in random order?
	LocusIsPhased bool
}

//Outputs:
//	-map[int64]LocusValue (rsID -> Base pair) (missing rsIDs represent unknown values)
//	-bool: Any Trait Rule known/tested
//	-map[string]int: Trait outcomes scores map (outcome -> Number of points)
//	-int: Number of rules tested
//	-bool: Conflict exists
//	-error
func GetPersonTraitInfoFromGeneticAnalysis(personAnalysisMapList []map[string]string, traitName string, genomeIdentifier string, personHasMultipleGenomes bool)(map[int64]LocusValue, bool, map[string]int, int, bool, error){

	for _, element := range personAnalysisMapList{

		analysisItemType, exists := element["ItemType"]
		if (exists == false) {
			return nil, false, nil, 0, false, errors.New("Malformed person analysis: Item missing ItemType")
		}

		if (analysisItemType != "Trait"){
			continue
		}
		
		itemTraitName, exists := element["TraitName"]
		if (exists == false) {
			return nil, false, nil, 0, false, errors.New("Malformed person analysis: Trait item missing TraitName")
		}

		if (itemTraitName != traitName){
			continue
		}

		traitObject, err := traits.GetTraitObject(traitName)
		if (err != nil) { return nil, false, nil, 0, false, err }

		traitLociList := traitObject.LociList

		// Map Structure: rsID -> Locus Value
		locusValuesMap := make(map[int64]LocusValue)

		for _, rsID := range traitLociList{

			rsidString := helpers.ConvertInt64ToString(rsID)

			locusValue, exists := element[genomeIdentifier + "_LocusValue_rs" + rsidString]
			if (exists == false){
				return nil, false, nil, 0, false, errors.New("Malformed person analysis: missing trait locus value for locus: " + rsidString)
			}

			if (locusValue == "Unknown"){
				// No value exists for this locus
				continue
			}

			locusIsPhasedString, exists := element[genomeIdentifier + "_LocusIsPhased_rs" + rsidString]
			if (exists == false){
				return nil, false, nil, 0, false, errors.New("Malformed person analysis: Contains trait locus value which is missing locusIsPhased information.")
			}

			locusIsPhased, err := helpers.ConvertYesOrNoStringToBool(locusIsPhasedString)
			if (err != nil){
				return nil, false, nil, 0, false, errors.New("Malformed person analysis: Contains invalid trait locusIsPhased rsID value: " + locusIsPhasedString)
			}

			locusBase1, locusBase2, semicolonExists := strings.Cut(locusValue, ";")
			if (semicolonExists == false){
				return nil, false, nil, 0, false, errors.New("Malformed person analysis: Contains invalid trait locus value: " + locusValue)
			}

			locusValueObject := LocusValue{
				Base1: locusBase1,
				Base2: locusBase2,
				LocusIsPhased: locusIsPhased,
			}

			locusValuesMap[rsID] = locusValueObject
		}

		numberOfRulesTestedString, exists := element[genomeIdentifier + "_NumberOfRulesTested"]
		if (exists == false){
			return nil, false, nil, 0, false, errors.New("Malformed person analysis: Trait item missing _NumberOfRulesTested")
		}

		numberOfRulesTested, err := helpers.ConvertStringToInt(numberOfRulesTestedString)
		if (err != nil){
			return nil, false, nil, 0, false, errors.New("Malformed person analysis: Trait item contains invalid _NumberOfRulesTested: " + numberOfRulesTestedString)
		}

		getConflictExistsBool := func()(bool, error){

			if (personHasMultipleGenomes == false){
				return false, nil
			}

			conflictExists, exists := element["ConflictExists"]
			if (exists == false) {
				return false, errors.New("Malformed analysisMapList: Trait analysis missing ConflictExists")
			}

			if (conflictExists == "Yes"){
				return true, nil
			}

			return false, nil
		}

		conflictExistsBool, err := getConflictExistsBool()
		if (err != nil) { return nil, false, nil, 0, false, err }

		if (numberOfRulesTested == 0){
			return locusValuesMap, false, nil, 0, conflictExistsBool, nil
		}

		traitOutcomesList := traitObject.OutcomesList

		traitOutcomeScoresMap := make(map[string]int)

		for _, traitOutcome := range traitOutcomesList{

			outcomeScoreString, exists := element[genomeIdentifier + "_OutcomeScore_" + traitOutcome]
			if (exists == false){
				return nil, false, nil, 0, false, errors.New("Person analysis missing _OutcomePoints_" + traitOutcome + " key.")
			}
		
			outcomeScoreInt, err := helpers.ConvertStringToInt(outcomeScoreString)
			if (err != nil){
				return nil, false, nil, 0, false, errors.New("Person analysis contains invalid _OutcomeScore_ value: " + outcomeScoreString)
			}

			traitOutcomeScoresMap[traitOutcome] = outcomeScoreInt
		}

		return locusValuesMap, true, traitOutcomeScoresMap, numberOfRulesTested, conflictExistsBool, nil
	}

	return nil, false, nil, 0, false, errors.New("GetPersonTraitInfoFromGeneticAnalysis failed: Cannot find trait info for trait: " + traitName)
}



//Outputs:
//	-bool: Trait Outcome Scores known
//	-map[string]float64: Trait average outcome scores map (OutcomeName -> AverageScore)
//	-int: Number of rules tested
//	-bool: Conflict exists
//	-error
func GetOffspringTraitInfoFromGeneticAnalysis(coupleAnalysisMapList []map[string]string, traitName string, genomePairIdentifier string, secondGenomePairExists bool)(bool, map[string]float64, int, bool, error){

	for _, element := range coupleAnalysisMapList{
				
		analysisItemType, exists := element["ItemType"]
		if (exists == false) {
			return false, nil, 0, false, errors.New("Malformed couple analysis: Item missing ItemType")
		}

		if (analysisItemType != "Trait"){
			continue
		}
		
		itemTraitName, exists := element["TraitName"]
		if (exists == false) {
			return false, nil, 0, false, errors.New("Malformed couple analysis: Trait item missing TraitName")
		}

		if (itemTraitName != traitName){
			continue
		}

		numberOfRulesTestedString, exists := element[genomePairIdentifier + "_NumberOfRulesTested"]
		if (exists == false){
			return false, nil, 0, false, errors.New("Malformed couple analysis: Trait item missing _NumberOfRulesTested")
		}

		numberOfRulesTested, err := helpers.ConvertStringToInt(numberOfRulesTestedString)
		if (err != nil){
			return false, nil, 0, false, errors.New("Malformed couple analysis: Trait item contains invalid _NumberOfRulesTested: " + numberOfRulesTestedString)
		}

		getConflictExistsBool := func()(bool, error){

			if (secondGenomePairExists == false){
				return false, nil
			}

			conflictExists, exists := element["ConflictExists"]
			if (exists == false) {
				return false, errors.New("Malformed analysisMapList: Trait analysis missing ConflictExists")
			}

			if (conflictExists == "Yes"){
				return true, nil
			}

			return false, nil
		}

		conflictExistsBool, err := getConflictExistsBool()
		if (err != nil) { return false, nil, 0, false, err }

		if (numberOfRulesTested == 0){
			return false, nil, 0, conflictExistsBool, nil
		}

		traitObject, err := traits.GetTraitObject(traitName)
		if (err != nil) { return false, nil, 0, false, err }

		traitOutcomesList := traitObject.OutcomesList

		traitOutcomeScoresMap := make(map[string]float64)

		for _, traitOutcome := range traitOutcomesList{

			averageOutcomeScoreString, exists := element[genomePairIdentifier + "_OffspringAverageOutcomeScore_" + traitOutcome]
			if (exists == false){
				return false, nil, 0, false, errors.New("Couple analysis missing _OutcomePoints_" + traitOutcome + " key.")
			}
		
			averageOutcomeScoreFloat64, err := helpers.ConvertStringToFloat64(averageOutcomeScoreString)
			if (err != nil){
				return false, nil, 0, false, errors.New("Couple analysis contains invalid _OutcomeScore_ value: " + averageOutcomeScoreString)
			}

			traitOutcomeScoresMap[traitOutcome] = averageOutcomeScoreFloat64
		}

		return true, traitOutcomeScoresMap, numberOfRulesTested, conflictExistsBool, nil
	}

	return false, nil, 0, false, errors.New("GetOffspringTraitInfoFromGeneticAnalysis failed: Cannot find trait info for trait: " + traitName)
}

//Outputs:
//	-bool: Rule status known (we know if the rule is passed or not)
//	-bool: Genome passes rule
//	-map[string]string: Rule locus identifier -> genome base pair
//	-error
func GetPersonTraitRuleInfoFromGeneticAnalysis(personAnalyisMapList []map[string]string, traitName string, ruleIdentifier string, genomeIdentifier string)(bool, bool, map[string]string, error){

	for _, element := range personAnalyisMapList{

		itemType, exists := element["ItemType"]
		if (exists == false) {
			return false, false, nil, errors.New("Malformed person analysis: Item missing itemType")
		}

		if (itemType != "TraitRule"){
			continue
		}

		currentTraitName, exists := element["TraitName"]
		if (exists == false){
			return false, false, nil, errors.New("Malformed person analysis: Trait item missing TraitName")
		}

		if (currentTraitName != traitName){
			continue
		}

		currentRuleIdentifier, exists := element["RuleIdentifier"]
		if (exists == false) {
			return false, false, nil, errors.New("Malformed person analysis: TraitRule item missing RuleIdentifier")
		}

		if (currentRuleIdentifier != ruleIdentifier){
			continue
		}

		genomePassesRuleString, exists := element[genomeIdentifier + "_PassesRule"]
		if (exists == false){
			return false, false, nil, errors.New("Malformed person analysis: TraitRule item missing _PassesRule")
		}

		// Map Structure: Locus Identifier -> Locus base pair
		ruleLocusBasePairsMap := make(map[string]string)

		locusKeysPrefix := genomeIdentifier + "_RuleLocusBasePair_"

		for key, value := range element{

			isLocusValueEntry := strings.HasPrefix(key, locusKeysPrefix)
			if (isLocusValueEntry == false){
				continue
			}

			locusIdentifier := strings.TrimPrefix(key, locusKeysPrefix)

			if (value == "Unknown"){
				continue
			}

			ruleLocusBasePairsMap[locusIdentifier] = value
		}

		if (genomePassesRuleString == "Unknown"){
			return false, false, ruleLocusBasePairsMap, nil
		}

		genomePassesRuleBool, err := helpers.ConvertYesOrNoStringToBool(genomePassesRuleString)
		if (err != nil){
			return false, false, nil, errors.New("Malformed person analysis: TraitRule item contains invalid _PassesRule: " + genomePassesRuleString)
		}

		return true, genomePassesRuleBool, ruleLocusBasePairsMap, nil
	}

	return false, false, nil, errors.New("GetPersonTraitRuleInfoFromGeneticAnalysis failed: Trait rule info not found.")
}


//Outputs:
//	-bool: Offspring trait rule probability known
//	-int: Offspring probability of passing rule (0 - 100)
//	-string: Offspring probability of passing rule formatted (with % suffix)
//	-error
func GetOffspringTraitRuleInfoFromGeneticAnalysis(coupleAnalysisMapList []map[string]string, traitName string, ruleIdentifier string, genomePairIdentifier string)(bool, int, string, error){

	for _, element := range coupleAnalysisMapList{

		itemType, exists := element["ItemType"]
		if (exists == false) {
			return false, 0, "", errors.New("Malformed couple analysis: Item missing itemType")
		}

		if (itemType != "TraitRule"){
			continue
		}
		currentTraitName, exists := element["TraitName"]
		if (exists == false) {
			return false, 0, "", errors.New("Malformed couple analysis: TraitRule item missing TraitName")
		}
	
		if (currentTraitName != traitName){
			continue
		}

		currentRuleIdentifier, exists := element["RuleIdentifier"]
		if (exists == false) {
			return false, 0, "", errors.New("Malformed couple analysis: TraitRule item missing RuleIdentifier")
		}

		if (currentRuleIdentifier != ruleIdentifier){
			continue
		}

		offspringProbabilityOfPassingRule, exists := element[genomePairIdentifier + "_OffspringProbabilityOfPassingRule"]
		if (exists == false){
			return false, 0, "", errors.New("Malformed couple analysis: TraitRule item missing _OffspringProbabilityOfPassingRule key")
		}

		if (offspringProbabilityOfPassingRule == "Unknown"){
			return false, 0, "", nil
		}
	
		offspringProbabilityOfPassingRuleInt, err := helpers.ConvertStringToInt(offspringProbabilityOfPassingRule)
		if (err != nil) {
			return false, 0, "", errors.New("Malformed couple analysis: TraitRule item contains invalid _OffspringProbabilityOfPassingRule: " + offspringProbabilityOfPassingRule)
		}

		offspringProbabilityOfPassingRuleFormatted := offspringProbabilityOfPassingRule + "%"

		return true, offspringProbabilityOfPassingRuleInt, offspringProbabilityOfPassingRuleFormatted, nil
	}

	return false, 0, "", errors.New("GetOffspringTraitRuleInfoFromGeneticAnalysis failed: Trait rule info not found.")
}


// We use this function to verify a person genetic analysis is well formed
func ReadPersonGeneticAnalysisForTests(personAnalysisMapList []map[string]string)error{

	allRawGenomeIdentifiersList, personHasMultipleGenomes, onlyExcludeConflictsGenomeIdentifier, onlyIncludeSharedGenomeIdentifier, err := GetMetadataFromPersonGeneticAnalysis(personAnalysisMapList)
	if (err != nil) { return err }

	allGenomeIdentifiersList := allRawGenomeIdentifiersList
	if (personHasMultipleGenomes == true){
		allGenomeIdentifiersList = append(allGenomeIdentifiersList, onlyExcludeConflictsGenomeIdentifier, onlyIncludeSharedGenomeIdentifier)
	}

	monogenicDiseaseObjectsList, err := monogenicDiseases.GetMonogenicDiseaseObjectsList()
	if (err != nil) { return err }

	for _, monogenicDiseaseObject := range monogenicDiseaseObjectsList{

		diseaseName := monogenicDiseaseObject.DiseaseName

		for _, genomeIdentifier := range allGenomeIdentifiersList{

			_, _, _, _, _, _, _, err := GetPersonMonogenicDiseaseInfoFromGeneticAnalysis(personAnalysisMapList, diseaseName, genomeIdentifier, personHasMultipleGenomes)
			if (err != nil) { return err }
		}

		diseaseVariantObjectsList := monogenicDiseaseObject.VariantsList

		for _, diseaseVariantObject := range diseaseVariantObjectsList{

			variantIdentifier := diseaseVariantObject.VariantIdentifier

			for _, genomeIdentifier := range allGenomeIdentifiersList{

				_, _, err := GetPersonMonogenicDiseaseVariantInfoFromGeneticAnalysis(personAnalysisMapList, diseaseName, variantIdentifier, genomeIdentifier)
				if (err != nil) { return err }
			}
		}
	}

	polygenicDiseaseObjectsList, err := polygenicDiseases.GetPolygenicDiseaseObjectsList()
	if (err != nil) { return err }

	for _, diseaseObject := range polygenicDiseaseObjectsList{

		diseaseName := diseaseObject.DiseaseName

		for _, genomeIdentifier := range allGenomeIdentifiersList{

			_, _, _, _, _, err := GetPersonPolygenicDiseaseInfoFromGeneticAnalysis(personAnalysisMapList, diseaseName, genomeIdentifier, personHasMultipleGenomes)
			if (err != nil) { return err }
		}

		diseaseLocusObjectsList := diseaseObject.LociList

		for _, diseaseLocusObject := range diseaseLocusObjectsList{

			locusIdentifier := diseaseLocusObject.LocusIdentifier

			for _, genomeIdentifier := range allGenomeIdentifiersList{

				_, _, _, _, _, _, err := GetPersonPolygenicDiseaseLocusInfoFromGeneticAnalysis(personAnalysisMapList, diseaseName, locusIdentifier, genomeIdentifier)
				if (err != nil) { return err }
			}
		}
	}

	traitObjectsList, err := traits.GetTraitObjectsList()
	if (err != nil) { return err }

	for _, traitObject := range traitObjectsList{

		traitName := traitObject.TraitName

		for _, genomeIdentifier := range allGenomeIdentifiersList{

			_, _, _, _, _, err := GetPersonTraitInfoFromGeneticAnalysis(personAnalysisMapList, traitName, genomeIdentifier, personHasMultipleGenomes)
			if (err != nil) { return err }
		}

		traitRulesList := traitObject.RulesList

		for _, traitRuleObject := range traitRulesList{

			ruleIdentifier := traitRuleObject.RuleIdentifier

			for _, genomeIdentifier := range allGenomeIdentifiersList{

				_, _, _, err := GetPersonTraitRuleInfoFromGeneticAnalysis(personAnalysisMapList, traitName, ruleIdentifier, genomeIdentifier)
				if (err != nil) { return err }
			}
		}
	}

	return nil
}


// We use this function to verify a person genetic analysis is well formed
func ReadCoupleGeneticAnalysisForTests(coupleAnalysisMapList []map[string]string)error{

	pair1PersonAGenomeIdentifier, pair1PersonBGenomeIdentifier, secondGenomePairExists, pair2PersonAGenomeIdentifier, pair2PersonBGenomeIdentifier, _, _, _, _, _, _, err := GetMetadataFromCoupleGeneticAnalysis(coupleAnalysisMapList)
	if (err != nil) { return err }

	pair1GenomeIdentifier := pair1PersonAGenomeIdentifier + "+" + pair1PersonBGenomeIdentifier

	allGenomePairIdentifiersList := []string{pair1GenomeIdentifier}

	if (secondGenomePairExists == true){

		pair2GenomeIdentifier := pair2PersonAGenomeIdentifier + "+" + pair2PersonBGenomeIdentifier

		allGenomePairIdentifiersList = append(allGenomePairIdentifiersList, pair2GenomeIdentifier)
	}

	monogenicDiseaseObjectsList, err := monogenicDiseases.GetMonogenicDiseaseObjectsList()
	if (err != nil) { return err }

	for _, monogenicDiseaseObject := range monogenicDiseaseObjectsList{

		diseaseName := monogenicDiseaseObject.DiseaseName

		for _, genomePairIdentifier := range allGenomePairIdentifiersList{

			_, _, _, _, _, _, err = GetOffspringMonogenicDiseaseInfoFromGeneticAnalysis(coupleAnalysisMapList, diseaseName, genomePairIdentifier, secondGenomePairExists)
			if (err != nil) { return err }
		}

		diseaseVariantObjectsList := monogenicDiseaseObject.VariantsList

		for _, diseaseVariantObject := range diseaseVariantObjectsList{

			variantIdentifier := diseaseVariantObject.VariantIdentifier

			for _, genomePairIdentifier := range allGenomePairIdentifiersList{

				_, _, _, _, _, _, _, _, _, _, err := GetOffspringMonogenicDiseaseVariantInfoFromGeneticAnalysis(coupleAnalysisMapList, diseaseName, variantIdentifier, genomePairIdentifier)
				if (err != nil) { return err }
			}
		}
	}

	polygenicDiseaseObjectsList, err := polygenicDiseases.GetPolygenicDiseaseObjectsList()
	if (err != nil) { return err }

	for _, diseaseObject := range polygenicDiseaseObjectsList{

		diseaseName := diseaseObject.DiseaseName

		for _, genomePairIdentifier := range allGenomePairIdentifiersList{

			_, _, _, _, _, err := GetOffspringPolygenicDiseaseInfoFromGeneticAnalysis(coupleAnalysisMapList, diseaseName, genomePairIdentifier, secondGenomePairExists)
			if (err != nil) { return err }
		}

		diseaseLocusObjectsList := diseaseObject.LociList

		for _, diseaseLocusObject := range diseaseLocusObjectsList{

			locusIdentifier := diseaseLocusObject.LocusIdentifier

			for _, genomePairIdentifier := range allGenomePairIdentifiersList{

				_, _, _, _, _, err := GetOffspringPolygenicDiseaseLocusInfoFromGeneticAnalysis(coupleAnalysisMapList, diseaseName, locusIdentifier, genomePairIdentifier)
				if (err != nil) { return err }
			}
		}
	}

	traitObjectsList, err := traits.GetTraitObjectsList()
	if (err != nil) { return err }

	for _, traitObject := range traitObjectsList{

		traitName := traitObject.TraitName

		for _, genomePairIdentifier := range allGenomePairIdentifiersList{

			_, _, _, _, err := GetOffspringTraitInfoFromGeneticAnalysis(coupleAnalysisMapList, traitName, genomePairIdentifier, secondGenomePairExists)
			if (err != nil) { return err }
		}

		traitRulesList := traitObject.RulesList

		for _, traitRuleObject := range traitRulesList{

			ruleIdentifier := traitRuleObject.RuleIdentifier

			for _, genomePairIdentifier := range allGenomePairIdentifiersList{		

				_, _, _, err := GetOffspringTraitRuleInfoFromGeneticAnalysis(coupleAnalysisMapList, traitName, ruleIdentifier, genomePairIdentifier)
				if (err != nil) { return err }
			}
		}
	}

	return nil	
}