#rR gscope_taxo.tcl
#rR ici on trouvera Tax qui appelle soit TaxGetz (obsolete) soit TaxNCBI soit TaxUniProt (voir TaxSystem)
#rR Attention dans un meme cafe des sciences on ne peut pas mélanger les 2 

#rR Normalement Tax appelle QuestionDeScience EVImm Tax  pouen epas avoir à le charger
#rR   sauf si EVImm (bien sûr) ou si TaxWithQDS 0 est positionné.
#rR   Le chargemetn dure 30 secondes depuis 2017/04/18 car j'ai mis le array dans un tableau.
#rR Si un projet Gscope veut faire beaucoup de Tax alors il vaut mieux faire
#rR   TaxWithQDS 0  en début  puis utiliser Tax en self service.

#rR il y a aussi des choses pour faire une base de donnees Sql (Luc a tout fait pour ça)

#rR attention les Name d'un noeud ne sont pas uniques. Il y a par exemple 2 craniata, l'un étant un genre de moule !!!

proc TaxoblaKeepOnly {{KeepWhat ""} {Extension ""} {TaxoblaOrigin ""}} {
    if {$KeepWhat     ==""} { set KeepWhat "AEB_ListOf_OX" }
    if {$Extension    ==""} { set Extension $KeepWhat }
    if {$TaxoblaOrigin==""} { set TaxoblaOrigin "taxobla" }

    set LesKeepedOX {}
    if {[regexp {^([A-Z]+)_([^_]+)_([^_]+)$} $KeepWhat Match Domaines Lo W]} {
	foreach D [split $Domaines ""] {
	    Espionne "OiCodeForDomain $D $Lo $W"
	    set LesOX [OiCodeForDomain $D $Lo $W]
	    LConcat LesKeepedOX $LesOX
	}
    }

    Espionne $LesKeepedOX
    foreach OX $LesKeepedOX {
	set Keep($OX) 1
    }

    NousAllonsAuBoulot [RepertoireDuGenome]
    set DestDir "taxobla$Extension"
    foreach Nom [ListeDesPABs] {
	if {[PasTouche $Nom]} { continue }
	set Orig "$TaxoblaOrigin/$Nom"
	set Dest "$DestDir/$Nom"
	file mkdir $DestDir
	if {[FileExists $Orig] && [FileAbsent $Dest]} {
	    set LeNew {}
	    foreach Ligne [LesLignesDuFichier $Orig] {
		scan $Ligne "%s %s %s" Pn Score OX
		if { ! [info exists Keep($OX)]} { continue }
		lappend LeNew $Ligne
	    }
	    SauveLesLignes $LeNew dans $Dest
	    Espionne $Dest
	    lappend LesNouveaux $Dest
	}
	FinPasTouche $Nom
    }
    OnRevientDuBoulot
    return $LesNouveaux
}  

proc NiceChildrenOf TaxId {
    set TaxId [Tax $TaxId "TaxId"]
    set LesC {}
    foreach C [Tax $TaxId Children] {
	lappend LesC [Tax $C Name]
    }
    return $LesC
}

proc CreeTaxoblaWithMyMissBlast {} {
    set LesCrees {}
    foreach Ligne [MyMissBlast] {
	scan $Ligne "%s %s %s" Nom Id Seq
	set SL [string length $Seq]
	set Ac [NIAG $Nom "A"]
	set PN 0.00
	set Score 1
	set TaxId [NotreOX]
	set Orga [NotreOS]
	set Info [PremiereLigneDuFichier [GscopeFile $Nom prottfa]]
	set Info [join [lrange [split $Info " "] 2 end] " "]
	set Info "$Id $Ac $Info SL=$SL" 
	if {[string length $Orga]>36} { set Orga "[string range $Orga 0 36]..." }
	set LigneTaxobla [format "%7s\t%6s\t%8s\t%-40s\t%s" $PN $Score $TaxId $Orga $Info]
	Espionne $LigneTaxobla
	set FicTaxobla [GscopeFile $Nom taxobla]
	if {[FileExists $FicTaxobla] && [file size $FicTaxobla]>0} {
	    if { ! [OuiOuNon "$FicTaxobla already exists; Do I overwrite ?"]} { continue }
	} 
	lappend LesCrees [Sauve $LigneTaxobla dans $FicTaxobla]
    }
    return $LesCrees
}

proc CreeTaxoblaVide {} {
    if { ! [OuiOuNon "Attention on crée des fichiers vides ... Si les blasts sont faits plus tard il faut penser à les supprimer\nJe crée quand même les vides"]} { return "" }
    set LesCrees {}
    foreach Nom [ListeDesPABs] {
	set FiTaxo [GscopeFile $Nom "taxobla"]
	if {[FileAbsent $FiTaxo]} {
	    lappend LesCrees [Sauve "" dans $FiTaxo] } 
    }
    return $LesCrees
}

proc TaxonomyDuBlastPourTous {{RepBlast ""} {RepTaxobla ""} {CutPN ""} {MaxListe ""}} {
    if {$RepBlast==""}   { set RepBlast   "[RepertoireDuGenome]/blastp" }
    if {$RepTaxobla==""} { set RepTaxobla "[RepertoireDuGenome]/taxobla" }
    if { ! [regexp "/" $RepBlast]}   { set RepBlast   "[RepertoireDuGenome]/$RepBlast" }
    if { ! [regexp "/" $RepTaxobla]} { set RepTaxobla "[RepertoireDuGenome]/$RepTaxobla" }
    if {[FileAbsent $RepTaxobla]} { file mkdir $RepTaxobla }
    set I 0
    set LesFichierTaxoblaCrees {}
    foreach Nom [ListeDesPABs] {
	if {$I%100==0} { Espionne "TaxonomyDuBlast $Nom" }
	incr I
	set FichierTaxobla $RepTaxobla/$Nom
	if {[file exists $FichierTaxobla] && [file size $FichierTaxobla]>0} { continue }
	set FichierBlast "$RepBlast/$Nom"
	if {[PasTouche "Taxobla$Nom"]} { continue } 
	set F [TaxonomyDuBlast $FichierBlast $CutPN $MaxListe $FichierTaxobla "AvecMemoTaxo"]
	lappend LesFichierTaxoblaCrees $F
	set L [llength [LesLignesDuFichier $F]]
	Espionne "$FichierTaxobla [format %6d $L] different organisms"
	FinPasTouche "Taxobla$Nom"
    }
    return $LesFichierTaxoblaCrees
}

proc LesOrganismesDuBlast {TexteOuListeOuFichier {CutPN ""} {MaxListe ""} {GetWhat ""} {AvecMemoTaxo ""}} {
    #Pour raison de compatibilité je le garde pour le moment pour Arnaud
    return [TaxonomyDuBlast $TexteOuListeOuFichier $CutPN $MaxListe $GetWhat $AvecMemoTaxo]
}

proc TaxonomyDuBlast {TexteOuListeOuFichier {CutPN ""} {MaxListe ""} {GetWhat ""} {AvecMemoTaxo ""}} {
    #rR Toute cette histoire de taxonomy présente dans le blast date de CilioCarta (2015)
    #rR Ca marche si la banque blast a été créée avec les OX que je rajoute pour tout Uniprot
    #rR on lit les chevrons du blast qui contiennent l'expect et le TaxId (pour CilioCarta en tout cas)
    #rR on rend la liste du premier hit de chaque orga rencontré sauf si CutPN contient KeepAll

    set KeepAll [regexp -nocase "KeepAll" $CutPN]
    if {$KeepAll} {
	regsub -nocase "KeepAll" $CutPN "" CutPN
    }

    if {$CutPN==""   || $CutPN   =="-" } { set CutPN "9999999" } 
    if {$MaxListe==""|| $MaxListe=="-" } { set MaxListe "9999999" } 
    if {$GetWhat==""}  { set GetWhat "Show" } 

    if {[regexp -nocase "Memo" $AvecMemoTaxo]} { global MemoTaxoPourTaxobla }

    set LesRetenus {}

    set Nom ""
    if {[EstUnPAB $TexteOuListeOuFichier]} {
	set Nom $TexteOuListeOuFichier
	set TexteOuListeOuFichier [GscopeFile $Nom "blastp"]
	if {[FileAbsent TexteOuListeOuFichier]} {
	    set ListeDesLignes {}
	} else {
	    set ListeDesLignes [LesLignesDuFichier $TexteOuListeOuFichier]
	}
	#rR ici on prend le fichier 
	set FichierTaxobla [GscopeFile $Nom "taxobla"]
	if {[file exists $FichierTaxobla]} {
	    set LesRetenus [LesLignesDuFichier $FichierTaxobla]
	}
    } elseif {[regexp "^/FromOi/(.+)$" $TexteOuListeOuFichier Match Nom]} {
	set ListeDesLignes [BlastFromOi $Nom]
    } elseif {[regexp "\n" $TexteOuListeOuFichier]} {
	set ListeDesLignes [split $TexteOuListeOuFichier "\n"]
    } elseif {[regexp " " $TexteOuListeOuFichier]} {
	set ListeDesLignes $TexteOuListeOuFichier
    } elseif {[file exists $TexteOuListeOuFichier]} {
	set ListeDesLignes [LesLignesDuFichier $TexteOuListeOuFichier]
	set Nom [file tail $TexteOuListeOuFichier]
    } elseif {[string length $TexteOuListeOuFichier] > 100} {
	set ListeDesLignes [split [Base64Decode $TexteOuListeOuFichier] "\n"]
    } else {
	FaireLire "I don't know how to analyse the blast\n$TexteOuListeOuFichier\n\
		It's not a text, not a list, not a file"
	return ""
    }

    if {$LesRetenus=={}} {
	set DansChevron 0
	set NbLus 0
	foreach Ligne $ListeDesLignes {
	    set Chev [regexp "^>" $Ligne]
	    if { ! $DansChevron && ! $Chev} { continue }
	    if { ! $DansChevron &&   $Chev} {
		regsub ">" $Ligne "" Ligne
		scan $Ligne "%s" Access		
		if {[info exists DejaVu($Access)]} { set DansChevron 0 ; continue }
		set DejaVu($Access) $Ligne
		set Info $Ligne
		set Expect ""
		set DansChevron 1
		continue
	    }
	    if {[regexp "^ *Identities" $Ligne]} { set DansChevron 0 ; continue }
	    if {[regexp {Expect *= *([^\,]+)} $Ligne Match sPN]} {

		set Score [expr round([StringApres "Score =" dans $Ligne])]           ;#rR rajoute le 2015/06/08 

		regsub {^[eE]} $sPN "1e" sPN
		#	scan $sPN "%f" PN
		set PN $sPN
		if {[catch { expr $PN > $CutPN } ]} {
		    Warne "Oh le vilain $PN"
		    set PN 1E-200
		}
		if {[expr $PN <= $CutPN]} {
		    regsub -all " +" $Info " " Info
		    set Info [string trim $Info]
		    set TaxId ""
		    if {[regexp -nocase {(TAXID|OX)(=|:)([0-9]+)( |$)} $Info Match K S T]} {
			set TaxId $T
		    } else {
			if {[regexp {OS=(.*)$} $Info Match OS]} {
			    regsub { [A-Z]+=.*$} $OS "" OS
			    regsub -all {\[} $OS "\\\[" OS
			    regsub -all {\]} $OS "\\\]" OS
			    regsub {\.$} $OS "" OS
			    if {[info exists MemoTaxoPourTaxobla($OS)]} {
				set TaxId $MemoTaxoPourTaxobla($OS)
			    } else {
				regsub -all " " $OS "_" O_S
				set TaxId [Tax $O_S]
				if {$TaxId==""} {
				    lassign [split $O_S "_"] Genre Espece
				    set G_E "${Genre}_$Espece"
				    set TaxId [Tax $G_E]
				}
				set MemoTaxoPourTaxobla($OS) $TaxId
			    }
			} 
		    }
		    if {[info exists MemoTaxoPourTaxobla($TaxId)]} {
			set Orga $MemoTaxoPourTaxobla($TaxId)
		    } else {
			if {$TaxId!=""} {
			    set Orga [Tax $TaxId]
			    set MemoTaxoPourTaxobla($TaxId) $Orga
			} else {
			    set Orga "Unknown unknown"
			}
		    }
		    if { $KeepAll || ! [info exists DejaVu($TaxId)] } {
			if {[string length $Orga]>36} { set Orga "[string range $Orga 0 36]..." }
			lappend LesRetenus [format "%7s\t%6s\t%8s\t%-40s\t%s" $PN $Score $TaxId $Orga $Info]  ;#rR rajout de score 2015/06/08
			if {[incr NbLus]>$MaxListe} { break }
			set DejaVu($TaxId) 1
		    }
		}
		set Info ""
		set Access ""
		set DansChevron 0
		continue
	    }
	    append Info " $Ligne"
	}
    }
    
    if {$GetWhat=="GetList"} { return $LesRetenus }
    if {$GetWhat=="GetText"} { return [join $LesRetenus "\n"] }
    if {$GetWhat=="Show"} {
	#rR On peut postponé les TouchePour ... ils sont mis en mémoire et rajoutés en queue des boutons :)
	set Clavier "Postpone"
	TouchePour $Clavier NouvelleGamme
	TouchePour $Clavier NouvelleCouleur "Orange"
	TouchePour $Clavier "See Taxo"        "AfficheTaxoFromTaxoLine \[selection get\] $Nom"
	TouchePour "<2>"    "/ Fetch"         "AfficheFetchFromTaxoLine \[selection get\] $Nom"
	TouchePour $Clavier NouvelleCouleur "Magenta"
	TouchePour $Clavier "OutlierOrganism" "OutlierOrganismInBlast $Nom"
	TouchePour $Clavier "Set Current Clade" "HighlightClade @F@ New"          ;#rR les @F@ seront remplacés par la fenêtre car Postpone
	TouchePour "<2>"    "/ See"             "HighlightClade @F@ See"
	TouchePour $Clavier "Highlight Clade"   "HighlightClade @F@ Current"
	if {[PourWscope]} { return [AfficheListe $LesRetenus "GrandeLargeur" $Nom] }
	set F [AfficheListe $LesRetenus "GrandeLargeur" $Nom]
    }

    set Fichier ""
    if {[regexp "/" $GetWhat]} { set Fichier $GetWhat }
    if {$GetWhat=="Save" && [EstUnPAB $Nom]} { mkdir "[RepertoireDuGenome]/taxobla"; set Fichier [GscopeFile $Nom "taxobla"] }
    if {$Fichier!=""} { return [SauveLesLignes $LesRetenus dans $Fichier] }
    if {$GetWhat=="GetText"} { return [join $LesRetenus "\n"] }
    return $LesRetenus
}

proc HighlightClade {Fenetre Action} {
    set Clade ""
    if {$Action=="Current"} { set Clade [CladeCourant] } 
    if {$Action=="New"}     { set Clade [CladeCourant "New"] } 
    if {$Action=="See"}     { return    [CladeCourant "See"] } 

    set Clade [Tax $Clade "TaxId"]
    set LesIllumines {}
    set Max -10
    foreach Ligne [split [PagePropre $Fenetre] "\n"] {
	if {[incr Max -1]==0} { break }
	set TaxId ""
	scan $Ligne "%s %s %d" E S TaxId
	if { ! [JeSuisTonAncetre $Clade $TaxId]} { continue }
	lappend LesIllumines " $TaxId "
    }
    if {$LesIllumines=={}} { return {} }
    return [IllumineLaListe $LesIllumines $Fenetre ]
}

proc AfficheTaxoFromTaxoLine {Ligne {Titre ""}} {
    set LeMessage {}
    foreach Li [split $Ligne "\n"] {
	set TaxId [lindex [LesMotsDeLaLigne $Li] 2]
	set Message "[format %-7s $TaxId] [TaxClass $TaxId Name]"
	lappend LeMessage $Message
    }
    return [AfficheListe $LeMessage "" $Titre]
}

proc AfficheFetchFromTaxoLine {Ligne {Titre ""}} {
    if {[regexp "\n" $Ligne]} {
	set LesFen {}
	foreach Li [split $Ligne "\n"] {
	    lappend LesFen [AfficheFetchFromTaxoLine $Li $Titre] 
	}
	return $LesFen
    }
    set iDernierDoubleBlanc [string last "  " $Ligne]
    set Access ""
    scan [string range $Ligne $iDernierDoubleBlanc end] "%s" Access
    return [AfficheFetch $Access $Titre]
}

proc TaxWithQds {{Valeur ""}} {
    global TaxWithQds

    if {$Valeur!=""} { set TaxWithQds $Valeur }

    if {[info exists TaxWithQds]} { return $TaxWithQds }
    if {[TaxSystem]=="AK"} { return 0 }
    if {[OnTraite "EVImm"]} { set TaxWithQds 0 }
    return $TaxWithQds 
}

proc Tax {Query {Quoi ""} {Valeur ""}} {

    if {$Query==""} { return "" } 

    regsub -all " +" [string trim $Query] "_" Query

    if { [TaxWithQds] } { return [QuestionDeScience EVImm "ret Tax $Query $Quoi $Valeur"] }
    
    set TaxSystem [TaxSystem]
    return [Tax$TaxSystem $Query $Quoi $Valeur]
}

proc TaxSystem {{Value ""}} {
    global TaxSystem

#   set DefaultValue "NCBI"
#   set DefaultValue "UniProt"
    set DefaultValue "AK"

    if {$Value!=""} {
	set VALUE [string toupper $Value]
	set TaxSys(GETZ)    "Getz"
	set TaxSys(NCBI)    "NCBI"
	set TaxSys(UNIPROT) "UniProt"
	set TaxSys(AK)      "AK"
	if {[info exists TaxSys($VALUE)]} {
	    set Value $TaxSys($VALUE)
	} else {
	    set DEFAULT [string toupper $DefaultValue]
	    set Better $TaxSys($DEFAULT)
	    Warne "Attention $Value is not a valid TaxSystem I'll use $Better" 
	    set Value $Better
	}
	set TaxSystem $Value
    }
    if { ! [info exists TaxSystem]} { set TaxSystem $DefaultValue }
    return $TaxSystem
}

proc TestTaxParQdsMemo {} {
    Espionne [TaxParQdsMemo "Frog virus 3 (isolate Goorha)"]
    Espionne [TaxParQdsMemo "Frog virus 3 (isolate Goorha)"]
    Espionne [TaxParQdsMemo 9606]
    Espionne [TaxParQdsMemo "Homo sapiens"]
    Espionne [TaxParQdsMemo "Homo_sapiens"]
}

proc TaxParQdsMemo {{Qui ""}} {
    #rR on appelle QuestionDeScience et on mémorise pour le coup d'après.
    global TaxParQdsMemo

    regsub -all "_" $Qui " " Qui

    if {[info exists TaxParQdsMemo($Qui)]} { return $TaxParQdsMemo($Qui)}

    set Q $Qui
    regsub -all {\[} $Q "\\\[" Q 
    regsub -all {\]} $Q "\\\]" Q 
    set R [Tax $Q]
    set TaxParQdsMemo($Qui) $R
    if {$R!=""} { set TaxParQdsMemo($R) $Qui }
    return $R
}



proc TestSock {} {
    LogWscope "dans TestSock"
    return "Bonjour"
}

proc LesClassesDuDescriptif {Nom {Expect ""}} {
    set FD [GscopeFile $Nom "descriptifs"]
    if {[FileAbsent $FD]} { return {} }
    set LesClasses {}
    foreach Ligne [LesLignesDuFichier $FD] {
	set Classe [StringSuivant "OC:" dans $Ligne]
	regsub {OX: .*} $Classe "" Classe
	if {$Classe==""} { continue }
	lappend LesClasses $Classe
    }
    return $LesClasses
}

proc CreateSqlTaxonomySynonym {} {
    
    set LesTaxId [lsort -integer [TaxNCBI List TaxId]]
    set Pk 0
    foreach TaxId $LesTaxId {
	set Name     [TaxNCBI $TaxId "Name"]
	set ItsNames [TaxNCBI $TaxId "ItsNames"]
	if {$Name==""} { continue }

	foreach Syno $ItsNames {
	    set BeauSyno $Syno
	    regsub -all {\\} $BeauSyno {\\\\} BeauSyno
	    regsub -all {\'} $BeauSyno "\\'"  BeauSyno
	    if { ! [string equal $Syno $BeauSyno]} { Espionne "$Syno\n$BeauSyno" }
	    if {[info exists SynoDejaVu($Syno)]} {
#		FaireLire "DejaVu $TaxId $Syno $SynoDejaVu($Syno)"
	    }
	    set SynoDejaVu($Syno) $TaxId

	    incr Pk
	    set Csv "$Pk|$TaxId|$BeauSyno"
	    lappend LesSynCsv $Csv
	}
    }
    set FicSynCsv [SauveLesLignes $LesSynCsv dans "[RepertoireDuGenome]/createtaxoSyn.csv"]
    return $FicSynCsv
} 

proc CreateSqlTaxonomy {} {
    
    set LesTaxId [lsort -integer [TaxNCBI List TaxId]]
    foreach TaxId $LesTaxId {
	set Name   [TaxNCBI $TaxId "Name"]
	set Parent [TaxNCBI $TaxId "Parent"]
	Espionne "$TaxId $Name"
	if {$Name==""} { continue }

	if {[info exists NameDejaVu($TaxId)]} {
	    FaireLire "DejaVu $TaxId $NameDejaVu($TaxId)"
	}
	if {0 && [info exists TaxIdDejaVu($Name)]} {
	    FaireLire "DejaVu $Name $TaxIdDejaVu($Name)"
	}
	set NameDejaVu($TaxId) $Name 
	set TaxIdDejaVu($Name)  $TaxId

	regsub -all {\'} $Name "\\'" BeauName
	set Csv "$TaxId|$Parent|$BeauName"
	lappend LesCreCsv $Csv
    }
    foreach TaxId $LesTaxId {
	set Parent [TaxNCBI $TaxId "Parent"]
	if { ! [info exists TaxIdDejaVu($Name)]} {
	    FaireLire "Parent $Parent of $TaxId $NameDejaVu($TaxId)\ndoesn't exist."
	    continue
	}
    }
    set FicCreCsv [SauveLesLignes $LesCreCsv dans "[RepertoireDuGenome]/createtaxoCre.csv"]
    return $FicCreCsv
} 

proc CreateMsfOfFamiliarOrganismsForAll {} {
    set CreateFiles {}
    set Rep "[RepertoireDuGenome]/msffam"
    if { ! [file exists $Rep]} { file mkdir $Rep }
    foreach Nom [ListeDesPABs] {
	set FamMsfFile "$Rep/$Nom"
	if {[file exists $FamMsfFile]} { continue }
	set FamMsf [MsfOfFamiliarOrganisms $Nom]
	if {$FamMsf==""} { continue }
	Espionne [Sauve $FamMsf dans $FamMsfFile]
	lappend CreateFiles $$FamMsfFile
    }
    return $CreateFiles
}

proc AfficheMsfOfFamiliarOrganisms NomOrigine {
    
    set Nom [file tail $NomOrigine]
    set FamMsf [MsfOfFamiliarOrganisms $Nom]
    if {$FamMsf==""} { return "" }
    return [AfficheVariable $FamMsf "AvecEtudeMSFGrandeLargeur" $NomOrigine]
}

proc MsfOfFamiliarOrganisms Nom {
    set FichierMSF "[RepertoireDuGenome]/msf/$Nom"
    if { ! [file exists $FichierMSF]} { return "" }
    set MSF [ContenuDuFichier $FichierMSF]
    set LesAccess [FamiliarOrganismsInMSF $Nom]
    if {$LesAccess==""} { return "" }
    set PetitMSF [MSFSelection $MSF $LesAccess "In"]
    return $PetitMSF
}

proc FamiliarOrganismsInMSF Nom {

    set Nom [file tail $Nom]
    set FichierMSF "[RepertoireDuGenome]/msf/$Nom"
    DecortiqueUnMSF $FichierMSF LesAccess
    set LesAccessInteressants {}
    foreach Access $LesAccess {
	set TaxIds [TaxIdDuAccess $Access $Nom]
	if {$TaxIds==""} { continue }
	foreach TaxId [split $TaxIds " "] {
	    if {$TaxId==""} { continue }
	    if {[FamiliarTaxId $TaxId]} {
		lappend LesAccessInteressants $Access
		break
	    }
	}
    }
    return $LesAccessInteressants
}

proc TaxIdOfFamiliarOrganisms {} {
    set LesOrgaTaxId {}
    foreach Orga [FamiliarOrganism LaListeMerci] {
	set TaxId [Tax $Orga TaxId]
	if {$TaxId=="" || [regexp "ERROR" $TaxId]} {
	    FaireLire "I can't find TaxId for $Orga. I'll skip"
	    continue
	}
	lappend LesOrgaTaxId "$Orga $TaxId"
    }
    SauveLesLignes $LesOrgaTaxId dans "[RepertoireDuGenome]/fiches/familiar_organism_with_taxid"
    return $LesOrgaTaxId
}

proc EstUnEucaryote TaxId {
    if {[regexp -nocase {[a-z]} $TaxId]} { set TaxId [Tax $TaxId] }

    set Class [TaxClass $TaxId "" "" TaxId] 
    return [regexp " 2759;" $Class]
}

proc EstUneBacterie TaxId {
    if {[regexp -nocase {[a-z]} $TaxId]} { set TaxId [Tax $TaxId] }

    set Class [TaxClass $TaxId "" "" TaxId] 
    return [regexp " 2;" $Class]
}

proc TaxoValide {Liste {Quoi ""}} {
    if {$Quoi == ""} { set Quoi "GetValid" } 
    set LesValides {}
    set LesInconnus {}
    foreach A $Liste {
	if {[Tax $A "TaxId"]==""} {
	    lappend LesInconnus $A
	} else {
	    lappend LesValides $A
	}
    }
    if {[regexp -nocase "Valid" $Quoi]} { return $LesValides }
    return $LesInconnus
}

proc JeSuisDescendantDe {As B} {
    regsub -all {[ \,;\n\t]+} $As "," As
    set As [split [string trim $As ","] ","]
    set iB [Tax $B TaxId]
    foreach A $As {
	set iA [Tax $A TaxId]
	set iC [AncetreCommun $iA $iB]
	Espionne "$iA $iB $iC"
	if {$iC==$iA} { return 1 }
    }
    return 0
}

proc JeSuisTonAncetre {Parent Enfant} {
    #rR petite magouille car les clades excavata et archaeplastida n'existent pas
    set FichierComposition "[RepertoireDuGenome]/bilan/CompositionDuClade$Parent.txt"
    if {[file exists $FichierComposition]} {
	foreach Mot [LesMotsDuTexte [ContenuDuFichier $FichierComposition]] {
	    if {[JeSuisTonAncetre $Mot $Enfant]} { return 1 }
	}
	return 0
    }

    set ParId [Tax $Parent "TaxId"]
    set EnfId [Tax $Enfant "TaxId"]
    if {$ParId=="" || $EnfId==""} { return 0 }
    if {[TaxSystem]=="AK"} {
	#rR Fastoche avec la taxo AK de Arnaud Kress !
	return [Taxo::isAncestor $ParId $EnfId]
    }
	
    set Classe [TaxClass $EnfId "All" "Forward" "TaxId"]
    regsub -all {[ ;]+} $Classe " " Classe
    set LesAncetres [split [string trim $Classe " "]]
    if {[lsearch $LesAncetres $ParId]<0} { return 0 }
    return 1
}

proc Descendant {A B {ForceAncestorFirst ""}} {
    set ForceAncestorFirst [regexp -nocase "first" $ForceAncestorFirst]
    set iA [Tax $A TaxId]
    set iB [Tax $B TaxId]
    set iC [AncetreCommun $iA $iB]
    if {$iC==$iA} { return 1 }
    if {$ForceAncestorFirst} { return 0 }
    if {$iC==$iB} { return 1 }
    return 0
} 

proc AncetreCommunDeLaListe {Liste {Quoi ""}} {
    if {$Quoi=="" || $Quoi=="IdCommun"} { set Quoi "TaxId" }
    set A [lindex $Liste 0]
    set A [Tax $A "TaxId"]
    set LesAutres [lrange $Liste 1 end]
    while {$LesAutres!={}} {
	set B [lindex $LesAutres 0]
	set LesAutres [lrange $LesAutres 1 end]
	set A [AncetreCommun $A $B]
    }
    set R [Tax $A $Quoi]
    return $R
}

proc AncetreCommun {A B {Quoi ""}} {

    Wup "On part des feuilles et on remonte une fois l'un une fois l'autre jusqu'a trouver un commun"

    #if {$Quoi==""} { set Quoi "IdCommun" }
    if {$Quoi==""} { set Quoi "Id" }

    if {[regexp {[^0-9]} $A]} { set A [Tax $A] }
    if {[regexp {[^0-9]} $B]} { set B [Tax $B] }
    if {$A=="" || $B==""} { return "" } 


    if {[TaxSystem]=="AK"} {
	return [Taxo::lastCommonAncestor $A $B $Quoi]
    }

    set ParentsDeA [list $A]
    set ParentsDeB [list $B]

    set AuTourDeA 1
    while 1 {
	set AncetreA [lindex $ParentsDeA end]
	set AncetreB [lindex $ParentsDeB end]
	#Espionne "A=$ParentsDeA/$AncetreA/[Tax $AncetreA]/ B=$ParentsDeB/$AncetreB/[Tax $AncetreB]/"
	if {[set iA [lsearch -exact $ParentsDeA $AncetreB]]>=0} {
	    if {[string equal -nocase $Quoi "IdCommun" ]} { return $AncetreB }
	    if {[string equal -nocase $Quoi "TwoLists" ]} {
		return [list [lrange $ParentsDeA 0 $iA] $ParentsDeB]
	    }
	    return [Tax $AncetreB $Quoi]
	}
	if {[set iB [lsearch -exact $ParentsDeB $AncetreA]]>=0} {
	    if {[string equal -nocase $Quoi "IdCommun" ]} { return $AncetreA }
	    if {[string equal -nocase $Quoi "TwoLists" ]} {
		return [list $ParentsDeA [lrange $ParentsDeB 0 $iB]]
	    }
	    return [Tax $AncetreA $Quoi]
	}
	if {   $AuTourDeA && $AncetreA<=1} { set AuTourDeA 0 }
	if { ! $AuTourDeA && $AncetreB<=1} { set AuTourDeA 1 }
	
	if {$AuTourDeA} {
	    set  AncetreA [Tax $AncetreA "RankedParent"]
	    if {$AncetreA==""} { return "" } 
	    lappend ParentsDeA $AncetreA
	    set AuTourDeA 0
	} else {
	    set  AncetreB [Tax $AncetreB "RankedParent"]
	    if {$AncetreB==""} { return "" } 
	    lappend ParentsDeB $AncetreB
	    set AuTourDeA 1
	}
    }
}

proc TaxIdDuGenomeComplet Banque {
    global TaxIdDuGenomeComplet
    set Banque [string toupper $Banque]
    if {[info exists TaxIdDuGenomeComplet($Banque)]} { return [set TaxIdDuGenomeComplet($Banque)] }
    if {[info exists TaxIdDuGenomeComplet("EstCharge")]} { return "" }

    set FichierTaxIdDuGenomeComplet "[RepertoireDuGenome]/fiches/taxid_des_genomes_complets"
    if { ! [file exists $FichierTaxIdDuGenomeComplet]} {
	set FichierTaxIdDuGenomeComplet "[GscopeDatabaseDir Common]/fiches/taxid_des_genomes_complets"
    }
    if {[file exists $FichierTaxIdDuGenomeComplet]} {
	array set TaxIdDuGenomeComplet [LesLignesDuFichier $FichierTaxIdDuGenomeComplet]
    }

    set FichierTaxIdDuGenomeCompletRR "[RepertoireDuGenome]/fiches/taxid_des_genomes_complets_RR"
    if { ! [file exists $FichierTaxIdDuGenomeCompletRR]} {
	set FichierTaxIdDuGenomeCompletRR "[GscopeDatabaseDir Common]/fiches/taxid_des_genomes_complets_RR"
    }
    if {[file exists $FichierTaxIdDuGenomeCompletRR]} {
	array set TaxIdDuGenomeComplet [LesLignesDuFichier $FichierTaxIdDuGenomeCompletRR]
    }
    foreach {C V} [array get TaxIdDuGenomeComplet] {
	lappend TaxIdDuGenomeComplet(LESNOMS) $C
	lappend TaxIdDuGenomeComplet(LESTAXIDS) $V
    } 
    set TaxIdDuGenomeComplet("EstCharge") 1
    return [TaxIdDuGenomeComplet $Banque]
}

proc RefDuGenomeComplet Banque {
    global RefDuGenomeComplet
    set Banque [string toupper $Banque]
    if {[info exists RefDuGenomeComplet($Banque)]} { return [set RefDuGenomeComplet($Banque)] }
    if {[info exists RefDuGenomeComplet("EstCharge")]} { return "" }

    set FichierRefDuGenomeComplet "[RepertoireDuGenome]/fiches/ref_des_genomes_complets"
    if { ! [file exists $FichierREfDuGenomeComplet]} {
	set FichierRefDuGenomeComplet "[GscopeDatabaseDir Common]/fiches/ref_des_genomes_complets"
    }
    if {[file exists $FichierRefDuGenomeComplet]} {
	array set RefDuGenomeComplet [LesLignesDuFichier $FichierRefDuGenomeComplet]
    }
    set RefDuGenomeComplet("EstCharge") 1
    return [RefDuGenomeComplet $Banque]
}

proc TaxIdDuFichierRef Fichier {
    global TaxIdDuFichierRef
    if {[info exists TaxIdDuFichierRef($Fichier)]} { return [set TaxIdDuFichierRef($Fichier)] }
    if {[info exists TaxIdDuFichierRef("EstCharge")]} { return "" }

    set FichierTaxIdDuFichierRef "/genomics/link/Common/fiches/taxid_du_fichierref"
    array set TaxIdDuFichierRef [LesLignesDuFichier $FichierTaxIdDuFichierRef]
    set TaxIdDuFichierRef("EstCharge") 1
    return [TaxIdDuFichierRef $Fichier]
}

proc BetterTaxId TaxId {
    global BetterTaxId
    if {[info exists BetterTaxId($TaxId)]} { return [set BetterTaxId($TaxId)] }
    if {[info exists BetterTaxId("EstCharge")]} { return $TaxId }

    foreach Ligne [LesLignesDuFichier "/genomics/link/Common/fiches/TaxNCBI/merged.dmp"] {
	scan $Ligne "%s %s %s" Old Bidon New
	set BetterTaxId($Old) $New
    }
    foreach Ligne [LesLignesDuFichier "/genomics/link/Common/fiches/TaxNCBI/better_de_rr.dmp"] {
	scan $Ligne "%s %s" Old New
	set BetterTaxId($Old) $New
    }
    set BetterTaxId("EstCharge") 1
    return [BetterTaxId $TaxId]
}

proc LesTaxIdDesGenomesComplets {} {
    set LesRepAvecFichier {}
    set LesRepAvecTaxId   {}
    foreach FiGBK [concat [glob -nocomplain "/genome/*/*.ref"] [glob -nocomplain "/genome/*/*.gbk"]] {
	Espionne $FiGBK
	set Rep [file tail [file dirname $FiGBK]]
	if {$Rep=="Archaea" || $Rep=="Bacteria" || $Rep=="H.sapiens" || $Rep=="YeastGenome"} { continue }
	lappend LesRepAvecFichier $Rep
	set TaxId ""
	if { ! [info exists LesTaxIdDuRep($Rep)]} { set LesTaxIdDuRep($Rep) {} }
	foreach Ligne [LesLignesIaJDuFichier $FiGBK 1 1000] {
	    if { ! [regexp {/db_xref=\"taxon\:} $Ligne]} { continue }
	    set TaxId [IntegerApres "taxon\:" dans $Ligne]
	    if {$TaxId==""} { continue }
	    set TaxId [BetterTaxId $TaxId]
	    set Organisme [Tax $TaxId]
	    lappend LesTaxIdDuFichierRef($FiGBK) $TaxId
	    if {[info exists FichierDuRep($Rep,$TaxId)]} { lappend FichierDuRep($Rep,$TaxId) $FiGBK ; continue }
	    lappend LesRepAvecTaxId $Rep
	    lappend FichierDuRep($Rep,$TaxId) $FiGBK
	    lappend LesTaxIdDuRep($Rep) $TaxId
	    break 
	}
    }

    foreach FiGBK [array names LesTaxIdDuFichierRef] {
	set LesT [set LesTaxIdDuFichierRef($FiGBK)]
	if {[llength LesT]>1} {
	    FaireLire "I found more than 1 TaxId for $FiGBK\n[join $LesT " "]"
	}
	set LesTaxIdDuFichierRef($FiGBK) [lsort -u [set LesTaxIdDuFichierRef($FiGBK)]]
	Espionne [SauveLesLignes [array get LesTaxIdDuFichierRef] dans "/genomics/link/Common/fiches/taxid_du_fichierref"]
    }

    foreach Rep [lsort -unique $LesRepAvecFichier] {
	if {[set LesTaxIdDuRep($Rep)]=={}} {
	    lappend LesPauvres "Rep sans TaxId $Rep"
	    Espionne "Rep sans TaxId $Rep"
	}
    }
    foreach Rep [lsort -unique $LesRepAvecTaxId] {
	if {[llength [set LesTaxIdDuRep($Rep)]]==1} {
	    set TaxId [lindex [set LesTaxIdDuRep($Rep)] 0]
	    lappend LesBons "\n$Rep $TaxId [Tax $TaxId]"
	    continue
	}
	lappend LesMultis "\n$Rep [join [set LesTaxIdDuRep($Rep)] " "]" 
	foreach TaxId [set LesTaxIdDuRep($Rep)] {
	    lappend LesMultis "   $TaxId [Tax $TaxId]"
	    lappend LesMultis [join [set FichierDuRep($Rep,$TaxId)] "\n"]
	}
    }
    Espionne [SauveLesLignes $LesBons    dans "/genomics/link/Common/fiches/les_genomes_un_taxid"]
    Espionne [SauveLesLignes $LesPauvres dans "/genomics/link/Common/fiches/les_genomes_sans_taxid"]
    Espionne [SauveLesLignes $LesMultis  dans "/genomics/link/Common/fiches/les_genomes_multi_taxid"]
    exit
}

proc RecupereLesVraisEmbls {} {
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/original_description"] {
	regsub -all {[\:\|]} $Ligne " " Ligne
	scan $Ligne "%s %s %s %s %s" PAB b c d Access
	set AccessDuEmbl($PAB) $Access
    }
    foreach Nom [ListeDesPABs] {
	Espionne $Nom
	set Narcisse [Narcisse $Nom]
	set Access   [set AccessDuEmbl($Nom)]
	if { ! [string equal -nocase $Narcisse $Access]} { Espionne "$Nom $Narcisse $Access" }
	set Embl [join [LaSequenceDesBanques $Access $Access a "OnVeutEMBL"] "\n"]
	if {$Embl==""} { Espionne "$Access introuvable" ; continue }
	set Tfa [SequenceFormatTFA $Embl $Access "embl"]
	set SaSeq [QueLaSequenceDuTexteTFA $Tfa]
	set MaSeq [QueLaSequenceDuTFA "[RepertoireDuGenome]/prottfa/$Nom"]
	if {$MaSeq!=$SaSeq} { Espionne "$Nom\n$MaSeq\n$SaSeq" }
	Sauve $Embl dans "[RepertoireDuGenome]/protemblnew/$Nom"
    }
    exit
}

proc TaxIdDuTexteEmbl Embl {
    foreach Ligne [split $Embl "\n"] {
	if { ! [regexp {^OX   } $Ligne]} { continue }
	set TaxId [StringSuivant "NCBI_TaxID=" dans $Ligne]
	regsub -all {[\.\;\,]} $TaxId " " TaxId
	set TaxId [string trim $TaxId]
	if { ! [regexp {^[0-9 ]+$} $TaxId]} {
	    FaireLire "The Embl file contains following OX line\n$Ligne\n\nPlease help me ..."
	    set TaxId [Entre $TaxId]	    
	}
	while {[regexp -all "  " $TaxId]} { regsub -all "  " $TaxId " " TaxId }
	return $TaxId
    }
    return ""
}

proc TaxIdDuAccess {Access {Nom ""}} {
    if {$Nom!=""} {
	set TaxId [TaxIdDuMacsim $Access $Nom]
	if {$TaxId!=""} { return $TaxId }
	set TaxId [ChampDaedalus "OX" $Access $Nom ]
	if {$TaxId!=""} { return $TaxId }
	set Descriptif [LeDescriptif $Access $Nom]
	set TaxId [ChampDuDescriptif $Descriptif "OX"]
	if {$TaxId!=""} { return $TaxId }
	return ""
    }
    set Embl [join [LaSequenceDesBanques $Access $Access a "OnVeutEMBL"] "\n"]
    if {$Embl!=""} { return [TaxIdDuTexteEmbl $Embl] }

    Espionne "Je n'ai pas trouve LaSequenceDesBanques $Access"
    return ""
}

proc TaxIdDuPAB Nom {
    global TaxIdDuPAB
    if {[info exists TaxIdDuPAB($Nom)]} { return [set TaxIdDuPAB($Nom)] }
    if {[info exists TaxIdDuPAB("EstCharge")]} { return "" }

    set FichierTaxIdDuPAB "[RepertoireDuGenome]/fiches/taxiddespabs"
    if {[file exists $FichierTaxIdDuPAB]} {
	array set TaxIdDuPAB [LesLignesDuFichier $FichierTaxIdDuPAB]
	set TaxIdDuPAB("EstCharge") 1
	return [TaxIdDuPAB $Nom]
    }

    while { ! [OuiOuNon "Do I create TaxIdDesPABs ?"]} {
	if {[OuiOuNon "Do I create an empty file ?\n(You can delete it later and run this prog again)"]} {
	    SauveLesLignes {} dans FichierTaxIdDuPAB
	    return ""
	}
	if {[OuiOuNon "Do I cancel TaxIdDuPAB ?"]} { return "" }	
    }

    set TaxIdDuPAB("EstCharge") 1
	set Sql "insert (pk_into taxonomy values ($TaxId, DEFAULT, $Name)"
	lappend LesSql $Sql

    if {[OuiOuNon "Do I search in OX field from protembl ?"]} {
	foreach PAB [ListeDesPABs] {
	    set Embl [ContenuDuFichier "[RepertoireDuGenome]/protembl/$PAB"]
	    set TaxIdDuPAB($PAB) [TaxIdDuTexteEmbl $Embl]
	}
    }

    SauveLesLignes [array get TaxIdDuPAB] dans $FichierTaxIdDuPAB
    return [TaxIdDuPAB $Nom]
}

proc TestTaxClass {} {
    Espionne [TaxClass 9606]
    Espionne [TaxClass 9606]
    Espionne [TaxClass 9605]
    Espionne [TaxClass 9606 "" "" Name]
    Espionne [TaxClass 9606 "" "" Rank]
    Espionne [TaxClass 9606 "" "" All]
    Espionne [TaxClass 9606 "" "" Name]
    exit
}

proc TestTaxClassBis {} {
    set Ts [TaxClass 9606 TaxId]
    set Ns [TaxClass 9606 Name]
    foreach T [split $Ts ";"] {
	set T [string trim $T]
	Espionne "$T [Tax $T]"
    }
    exit
}

proc TaxClass {Query {AllOrRankOnly ""} {Reverse ""} {Quoi ""}} {
    #rR ATTENTION suivant TaxSystem on utilise TaxAK de Arnaud Kress
    global TaxClass
    #rR sauf pour AK on parcourt recursivement les classes ... mais on stocke en memoire ce qui a deja ete vu

    regsub -all "_" $Query " " Query
    if {[regexp "^ERROR" $Query]} { return $Query }
    if {$Query==""} { return "" }
    if {$Query=="IsAlreadyLoaded"} {
	if {[TaxSystem]=="TaxAK"} { return 1 }
	return [info exists TaxClass]
    }
    if {[regexp -nocase {[a-z]} $Query]} { set Query [Tax $Query TaxId] }

    #rR c'était tellement le bordel !!! là on se fout de l'ordre des arguments 
    if {[regexp -nocase "TaxId" "$AllOrRankOnly $Reverse $Quoi"]} { set Quoi "TaxId" }
    if {[regexp -nocase "Name"  "$AllOrRankOnly $Reverse $Quoi"]} { set Quoi "Name" }
    if {[regexp -nocase "Rev"   "$AllOrRankOnly $Reverse $Quoi"]} { set Reverse "Reverse" }
    if {[regexp -nocase "For"   "$AllOrRankOnly $Reverse $Quoi"]} { set Reverse "Forward" }

    #if {[regexp -nocase "Name" $AllOrRankOnly]} { set Quoi "Name"; set AllOrRankOnly "" }
    #if {[regexp -nocase "Name" $Reverse]}       { set Quoi "Name"; set Reverse "" }

    #if {$Quoi==""} { set Quoi "TaxId" }
    #if {[regexp -nocase "Name" $Quoi]} { set Quoi "Name" }

    #if {[regexp -nocase "Rev"          $Reverse]      } { set Reverse "Reverse" } else { set Reverse "Forward" }
    if {[regexp -nocase "RankOnly|Rank" $AllOrRankOnly]} { set AllOrRankOnly "RankOnly" } else { set AllOrRankOnly "All" }
    if {$AllOrRankOnly==""} { set AllOrRankOnly "All" }

    #rR Traitement spécial si on utilise le Tax de Arnaud Kress qui va très vite ...
    if {[TaxSystem]=="AK"} {
	set TaxClass("OnFaitCommeSiIlEtaitCharge") 1
	#set LaClasse [TaxAK $Query lineage $Quoi $Reverse] .......................... faudrait corriger Taxo de AK
	#set Start 1 ; set Debut "; "
	#rR je ne sais pas s'il faut mettre root en début ? ........................... 2021/03/12
	set LaClasse [TaxAK $Query lineage $Quoi]
	set Start 0 ; set Debut ""
	if {[regexp -nocase "rev" $Reverse]} { set LaClasse [lreverse $LaClasse] }
	if {[regexp -nocase "rev" $Reverse]} { set Start 0 ; set Debut "" }
	set Classe "$Debut[join [lrange $LaClasse $Start end] {; }]"
	return $Classe
    }

    if {[info exists TaxClass($Query,$AllOrRankOnly,$Reverse,$Quoi)]} {
	 return [set TaxClass($Query,$AllOrRankOnly,$Reverse,$Quoi)]
    }

    set  Moi $Query
    if {$Moi==1} { return [Tax $Moi $Quoi]}
    set  Moi [Tax $Moi $Quoi]

    set Parent [Tax $Query "Parent"]
    set Ancetres [TaxClass [Tax $Query "Parent"] $AllOrRankOnly $Reverse $Quoi]
    if {[regexp -nocase "Rank" $AllOrRankOnly] && [Tax $Query "Rank"]=="no rank"} {
	return $Ancetres
    } 
    if {[string equal -nocase $Reverse "Reverse"]} {
	set Class "$Moi; $Ancetres"
    } else {
	set Class "$Ancetres; $Moi"
    }
    set TaxClass($Query,$AllOrRankOnly,$Reverse,$Quoi) $Class
    return $Class
}

proc TaxGetz {Query {Quoi ""}} {

    regsub -all "_" $Query "" Query

    set RankOnly 0
    if {$Quoi=="RankedParent"} { set Quoi "Parent" ; set RankOnly 1 }

    if {$Quoi==""} {
	set Quoi "TaxId"
	if {[regexp -nocase {^[0-9]+$} $Query]} { set Quoi "Name" }
    }

    if {[string equal -nocase $Quoi "ID"]}   { set Quoi "TaxId" }
    if {[string equal -nocase $Quoi "Name"]} { set Quoi "Name" }

    set ChampQuery "Taxon"
    if {[regexp -nocase {^[0-9]+$} $Query]} { set ChampQuery "ID" }
Espionne "getz -e \[TAXONOMY-$ChampQuery:$Query\]"
    if {[catch {set Reponse [exec getz -e \[TAXONOMY-$ChampQuery:$Query\]]} Message]} {
	regsub -all "\n" $Message " " Message
#	return "error from getz : $Message"
    }
    foreach Ligne [split $Reponse "\n"] {
	set Var ""
	if {[regexp -nocase {^ID *\: *}              $Ligne Match]} { set Var "TaxId" } 
	if {[regexp -nocase {^PARENT ID *\: *}       $Ligne Match]} { set Var "Parent" } 
	if {[regexp -nocase {^RANK *\: *}            $Ligne Match]} { set Var "Rank" } 
	if {[regexp -nocase {^GC ID *\: *}           $Ligne Match]} { set Var "GCID" } 
	if {[regexp -nocase {^MGC ID *\: *}          $Ligne Match]} { set Var "MGCID" } 
	if {[regexp -nocase {^SCIENTIFIC NAME *\: *} $Ligne Match]} { set Var "Name" } 
	if {[regexp -nocase {^SYNONYM *\: *}         $Ligne Match]} { set Var "Synonym" } 
	if {[regexp -nocase {^EQUIVALENT NAME *\: *} $Ligne Match]} { set Var "Equiv" } 
	if {$Var==""} { continue }
	set Info [StringSuivant ":" dans $Ligne]
	set $Var [string trim $Info]
#	regsub $Match $Ligne "" $Var
#	set $Var [string trim [set $Var]]
    }
    if {[info exists $Quoi]} {
	if {$RankOnly && $Parent>1 && [TaxGetz $Parent Rank]=="no rank"} { return [TaxGetz $Parent "RankedParent"] }
	return [set $Quoi]
    }
    return "ERROR in TaxGetz $Query $Quoi I got $Reponse"
}

proc BrowseTaxNCBI {{Texte ""} {Quoi ""}} {

    if {[regexp "\n" $Texte]} {
	foreach Ligne [split $Texte "\n"] {
	    if { ! [regexp -nocase {[a-z0-9]} $Ligne]} { continue }
	    BrowseTaxNCBI $Ligne $Quoi
	}
	return
    }

    if {$Texte==""} { set Texte "AskForAction" }

    if {$Texte=="AskForAction"} {
	lappend LesActions "Ask for a node ..."
	lappend LesActions "BrowseTaxNCBI List Queries"
	lappend LesActions "BrowseTaxNCBI 1 TaxId"
	lappend LesActions "BrowseTaxNCBI 9606 Parent"
	lappend LesActions "CreateSqlTaxonomy ShowOnly"
	lappend LesActions "CreateSqlTaxonomy"
	set Action [ChoixParmi $LesActions]
	if {$Action==""} { return "" }
	if {[regexp "^Ask " $Action]} {
	    set Texte [Entre "9606"]
	    return [BrowseTaxNCBI $Texte $Quoi]
	}
	return [eval $Action]
    }

    if {$Quoi==""} {
	set Quoi [ChoixParmi [TaxNCBI List Queries]]
    }
    if {$Quoi==""} { return "" }

    scan $Texte "%s" Id
    if {[regexp {^[0-9]+$} $Id]} { set BonTexte $Id } else { set BonTexte $Texte }  
    set V [TaxNCBI $BonTexte $Quoi]
    if {[regexp "^Its" $Quoi]} {
	set LesVs $V
    } else {
	set LesVs [list $V]
    }
    set LeNouveauTexte {}
    foreach V $LesVs {
	if {[regexp {^[0-9]+$} $V]} {
	    set Noeud $V
	    set LesNoeuds [list [TaxNCBI $Noeud Name]]
	    if {[info exists DejaVu]} { unset DejaVu }
	    set DejaVu($Noeud) 1
	    while 1 {
		if {$Noeud==1} { break }
		set Parent [TaxNCBI $Noeud Parent]
		set NomDuNoeudParent [TaxNCBI $Parent Name]
		lappend LesNoeuds $NomDuNoeudParent
		set Noeud $Parent
		if {[info exists DejaVu($Noeud)]} { break }
		set DejaVu($Noeud) 1
	    }
	    set Classe [join $LesNoeuds ";"]
	    set BeauV "$V $Classe"
	} else {
	    set BeauV $V
	}
	lappend LeNouveauTexte $BeauV
    }
    if {$LeNouveauTexte=={}} { return "" }
    set NouveauTexte [join $LeNouveauTexte "\n"]
    set Fen [AfficheVariable $NouveauTexte "AvecTaxNCBI"]
    Illumine "" $Fen
    return $Fen
}

proc OsOcParTaxNCBI {{Action ""}} {
    set LeTout {}
    foreach Name [TaxNCBI "ListOf" "Names"] {
	set Class [TaxClass $Name "All" "Forward" "Name"]
	lappend LeTout $Name $Class
    }
    return [SauveLesLignes $LeTout dans "[TaxDir]/OsOcParTaxNCBI.txt"]
}

proc OCduOS {OS {OS2 ""}} {
    global OCduOS
    global OrthographeCanoniqueInverse

    if {$OS2!=""} { set OS "$OS $OS2" }

    return [TaxClass $OS "" Names]

    set OS [string toupper $OS]
    regsub -all "_" $OS " " OS

    if {[info exists OCduOS($OS)]} {
	set C [set OCduOS($OS)]
	regsub {^root; cellular organisms; } $C "" C
	return $C
    }
    if {[info exists OCduOS("EstCharge")]} {
	if {[regexp -nocase {([A-Z][a-z]+) sp\.?$} $OS Match OSwithoutSP]} { return [OCduOS $OSwithoutSP] } 
	return "ClassUnknown"
	set TaxClass [TaxClass $OS "" "" name]
	if {$TaxClass!=""} { regsub {^root; *} $TaxClass "" TaxClass ; return $TaxClass }
	return "ClassUnknown"
    }
    set OCduOS("EstCharge") 1

#    set AL "ALVINELLA POMPEJANA"
#    set OCduOS($AL) "Eukaryota; Metazoa; Annelida; Polychaeta; Palpata; Canalipalpata; Terebellida; Alvinellidae; Alvinella."


    set FichierLesOSOCsDeQuidSeq "/biolo/wscope/quidseq/lesosocs"
    Espionne $FichierLesOSOCsDeQuidSeq
    if {[file exists $FichierLesOSOCsDeQuidSeq]} {
	set n 0
	foreach Ligne [LesLignesDuFichier $FichierLesOSOCsDeQuidSeq] {
	    incr n
	    set OC "ClassUnknown"
	    ScanLaListe [split $Ligne ":"] OSlu OC
	    set OSlu [string toupper $OSlu]
	    set OCduOS($OSlu) $OC
	    lappend OCduOS("LaListeMerci") $OSlu
	}
	foreach Good [array names OrthographeCanoniqueInverse] {
	    if {[info exists OCduOS($Good)]} { Espionne [set OCduOS($Good)] ; continue }
	    foreach Bad [set OrthographeCanoniqueInverse($Good)] {
		set BAD [string toupper $Bad]
		if {[info exists OCduOS($BAD)]} {
		    set OCduOS([string toupper $Good]) [set OCduOS($BAD)]
		    continue
		}
	    }
	}
	set OCduOS(SOURCE) "gscope_glossaire.classes"
	return [OCduOS $OS]
    }

    set FichierOsOcParTaxId "/genomics/link/Common/fiches/TaxNCBI/OsOcParTaxNCBI.txt.gz"
    if {[file exists $FichierOsOcParTaxId]} {
	array set OCduOS [LesLignesDuFichier $FichierOsOcParTaxId]
	foreach {S C} [array get OCduOS] {
	    set OCduOS([string toupper $S]) $C
	}
	set OCduOS(SOURCE) "TaxNCBI"
	set OCduOS("EstCharge") 1
	return [OCduOS $OS]
    }

    foreach Ligne [LesLignesDuFichier "[GscopeEtc]/gscope_glossaire.classes"] {
	scan $Ligne "%s %s" G E
	regsub "^$G $E " $Ligne "" C
	set O [string toupper "$G $E"]
	if { ! [info exists OCduOS($O)] || $OCduOS($O)=="ClassUnknown"} {
	    set OCduOS($O) $C
	}
    }
    set OCduOS(SOURCE) "gscope_glossaire.classes"

    
    #return [OCduOS $OS]
    if {[info exists OCduOS($OS)]} {
	return [set OCduOS($OS)]
    } else {
	return "ClassUnknown"
    }
}

proc TaxDir {{system ""}} {
    if {$system==""} { set system "UniProt" }
    #rR 20191018 set TaxDir "[GscopeDatabaseDir Common]/fiches/Tax$system"
    set TaxDir "/commun/banbi/taxonomy/production"
    return $TaxDir
}

proc TaxNCBI {TaxId {Quoi ""} {Value ""}} {
    global TaxNCBI

    #rR je ne sais pas pourquoi il n'y a pas de ranked comme dans Getz
    if {$Quoi=="RankedParent"} { set Quoi "Parent" }

    set TaxId [string map [list "_" " "] $TaxId]

    if {$Quoi==""} {
	set Quoi "TaxId"
	if {[regexp -nocase {^[0-9]+$} $TaxId]} { set Quoi "Name" }
    }

    if {$Value==""} { set Value "GetValue" }
    if {[string equal -nocase $Value "GetValue"]} {
	if {[info exists TaxNCBI($TaxId,$Quoi)]} { return [set TaxNCBI($TaxId,$Quoi)] }
	if { ! [info exists TaxNCBI("EstCharge")]} {
	    LoadTaxNCBI
	    return [TaxNCBI $TaxId $Quoi $Value]
	}   
	if {$Quoi=="Deleted"} { return 0 }
	if {($Quoi=="Name" || $Quoi=="Parent" || $Quoi=="Children"  || $Quoi=="ItsNames")\
		&& ! [regexp {^[0-9]+$} $TaxId]} {
	    set TNCBI [TaxNCBI $TaxId TaxId]
	    if {$TNCBI==""} { return "" }
	    return [TaxNCBI $TNCBI $Quoi]
	}
	set MAJUSCULE [string toupper $TaxId]
	if {[info exists TaxNCBI($MAJUSCULE,OriginalCase)] \
		&& [info exists TaxNCBI($TaxNCBI($MAJUSCULE,OriginalCase),$Quoi)]} {
	    return $TaxNCBI($TaxNCBI($MAJUSCULE,OriginalCase),$Quoi)
	}
	return ""
    }
    set TaxNCBI("EstCharge") 1

    #rR ***************************************** il faut =value **************
    if { ! [regexp "^=" $Value]} { return "" } 
    set Value [string map [list "=" ""] $Value]

    if { ! [info exists TaxNCBI(Query,$Quoi)]} {
	set TaxNCBI(Query,$Quoi) 1
	lappend TaxNCBI(List,Queries) $Quoi
    }
    if {[string equal -nocase $Value "ResetValue"]} {
	if {[info exists TaxNCBI($TaxId,$Quoi)]} {
	    set V [set TaxNCBI($TaxId,$Quoi)] 
	    unset TaxNCBI($TaxId,$Quoi)
	}
	return $V
    }

    if {$TaxId=="SortUnique" && $Quoi=="ListOf" && $Value=="Names"} {
	set TaxNCBI(ListOf,Names) [lsort -unique $TaxNCBI(ListOf,Names)]
	return 1
    }

    set MAJUSCULE [string toupper $TaxId]
    set TaxNCBI($MAJUSCULE,OriginalCase) $TaxId

    if {$TaxId=="ListOf" && $Quoi=="Names"} {
	lappend TaxNCBI(ListOf,Names) $Value
	return $Value
    }

    if {$Quoi=="ItsNames" || $Quoi=="ItsTaxIds" || $Quoi=="Children"} {
	lappend TaxNCBI($TaxId,$Quoi) $Value
	return [set TaxNCBI($TaxId,$Quoi)]
    }
    set TaxNCBI($TaxId,$Quoi) $Value
    if {$Quoi=="Name"} {
	if { ! [info exists TaxNCBI($TaxId,exists)]} {
	    set TaxNCBI($TaxId,exists) 1
	    lappend TaxNCBI(List,TaxId) $TaxId
	}
    }
    return $Value
}

proc LoadTaxNCBI {} {
    #rR on lit le fichier et on stocke tout en utilisant TaxNCBI Qui Quoi =Valeur
    #rR j'ai rajoute le = obligatoire pour modifier la valeur 2012/04/10
    set TaxDir [TaxDir "NCBI"]
    set Fichier "$TaxDir/delnodes.dmp"
    set f [open $Fichier "r"]
    while {[gets $f Ligne]>=0} {
	set LesChamps [split $Ligne "\t"]
	ScanLaListe $LesChamps TaxId
	TaxNCBI $TaxId Deleted "=1"
    }
    close $f

    set Fichier "$TaxDir/merged.dmp"
    set f [open $Fichier "r"]
    while {[gets $f Ligne]>=0} {
	regsub -all "\t" $Ligne "" Ligne
	set LesChamps [split $Ligne "|"]
	ScanLaListe $LesChamps TaxId Nouveau
	TaxNCBI $TaxId Merged "=$Nouveau"
    }
    close $f

    set Fichier "$TaxDir/nodes.dmp"
    set f [open $Fichier "r"]
    while {[gets $f Ligne]>=0} {
	regsub -all "\t" $Ligne "" Ligne
	set LesChamps [split $Ligne "|"]
	ScanLaListe $LesChamps TaxId Parent Rank Embl Division
	TaxNCBI $Parent Children "=$TaxId"
	TaxNCBI $TaxId  Parent   "=$Parent"
	TaxNCBI $TaxId  Rank     "=$Rank"
#	TaxNCBI $TaxId  Embl     "=$Embl"
#	TaxNCBI $TaxId  Division "=$Division"
    }
    close $f

    Espionne "Chargement $TaxDir/names.dmp"
    set Fichier "$TaxDir/names.dmp"
    set f [open $Fichier "r"]
    set nTaxId 0
#    set iMaxPourTest 999
    set iMaxPourTest -1
    while {[gets $f Ligne]>=0} {
	if {[incr iMaxPourTest -1]%10000==0} { Espionne $Ligne }
	if {[incr iMaxPourTest -1] == 0} { break }
	regsub -all "\t" $Ligne "" Ligne
	set LesChamps [split $Ligne "|"]
	ScanLaListe $LesChamps TaxId Name UniqueName NameClass
	if {$TaxId=="1890940"} { Espionne $Ligne } 
	if {[info exists DejaVu($Name)]} { lappend LesDoublons $Name }
	set DejaVu($Name) 1
	TaxNCBI $TaxId TaxId    "=$TaxId"
	TaxNCBI $TaxId ItsNames "=$Name"
	if {$UniqueName!=""} {
	    TaxNCBI $TaxId UniqueName "=$UniqueName"
	    TaxNCBI $Name  ItsTaxIds  "=$TaxId"
	}
	TaxNCBI $Name TaxId     "=$TaxId"
	TaxNCBI $Name NameClass "=$NameClass"
	if {[string equal -nocase $NameClass "scientific name"]} {
	    incr nTaxId
	    TaxNCBI $TaxId Name "=$Name"
	}
	TaxNCBI "ListOf" "Names" "=$Name"
    }
    TaxNCBI "SortUnique" "ListOf" "=Names"   ;#rR attention il faut aussi le =
    close $f
    set LesDoublons [lsort $LesDoublons]
    
#    SauveLesLignes $LesDoublons dans "$TaxDir/DoublonsNames.txt"
    return $nTaxId
}

proc TestNCBINames {} {
    set Fichier "./names.dmp"
    set f [open $Fichier "r"]
    set nTaxId 0
#    set iMaxPourTest 999
    set iMaxPourTest -1
    while {[gets $f Ligne]>=0} {
	if {[incr iMaxPourTest -1]%1000==0} { Espionne $Ligne }
	if {[incr iMaxPourTest -1] == 0} { break }
	regsub -all "\t" $Ligne "" Ligne
	set LesChamps [split $Ligne "|"]
	ScanLaListe $LesChamps TaxId Name UniqueName NameClass
	if {$TaxId=="1890940"} { Espionne $Ligne } 
	if {[info exists DejaVu($Name)]} { lappend LesDoublons $Name }
	set DejaVu($Name) 1
	TaxNCBI $TaxId TaxId    "=$TaxId"
	TaxNCBI $TaxId ItsNames "=$Name"
	if {$UniqueName!=""} {
	    TaxNCBI $TaxId UniqueName "=$UniqueName"
	    TaxNCBI $Name  ItsTaxIds  "=$TaxId"
	}
	TaxNCBI $Name TaxId     "=$TaxId"
	TaxNCBI $Name NameClass "=$NameClass"
	if {[string equal -nocase $NameClass "scientific name"]} {
	    incr nTaxId
	    TaxNCBI $TaxId Name "=$Name"
	}
	TaxNCBI "ListOf" "Names" "=$Name"
    }
}

proc DoublonsDansTaxUniProt {} {
    #rR C'est la merde absolue ..................................
    #rR les noms des noeuds ne sont pas uniques
    #rR IL y a 2 Craniata et 2 Vertebrata

    set UrlPourLaMiseAJour "http://www.uniprot.org/taxonomy/?query=&force=yes&format=tab"

    set TaxDir [TaxDir "UniProt"]
    set Fichier "$TaxDir/taxonomy-all.tab"
    set f [open $Fichier "r"]
    set PrendPremiereLigne 0
    while {[gets $f Ligne]>=0} {
	if {! $PrendPremiereLigne} {
	    #lM premiere ligne contient les noms des champs
	    # Taxon | Mnemonic | Scientific name | Common name | Synonym | Other Names | Reviewed | Rank | Lineage | Parent
	    set PrendPremiereLigne 1
	    continue
	}
	
	set LesChamps [split $Ligne "\t"]
	lassign $LesChamps TaxId Mnemonic Name CommonName Synonym OtherNames Reviewed Rank Lineage Parent
	if {$Name==""} { continue }
	if {[string trim $Rank] eq ""} {
	    set Rank "no rank"
	}
	if {[info exists DejaVu($Name)]} {
	    lappend LesDoublons $Name
	    if { ! [regexp environment $Name]} {
		Espionne "\n[join $DejaVu($Name) \n]\n$Ligne"
	    }
	}
	lappend DejaVu($Name) $Ligne 
    }
    return 
}

proc LoadTaxUniProt {{TaxDir ""}} {
    global TaxUniProt
    #rR on lit le fichier et on stocke tout en utilisant TaxUniprot Qui Quoi =Valeur
    #rR Attention il y a des doublons pour les nom de noeud !!!!!!!!!!!
    #rR J'ai mis en dur Vertebrata et Craniata voir ci-dessous !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

    if {$TaxDir==""} { set TaxDir [TaxDir "UniProt"] }

    #rR set Fichier               "$TaxDir/taxonomy-all.tab"
    #rR set FichierTaxUniProtMemo "$TaxDir/taxonomy-all.arraytcl"
    set Fichier               "$TaxDir/taxonomy.dat"
    set FichierTaxUniProtMemo "$TaxDir/taxonomy.arraytcl"

    if {[file exists $FichierTaxUniProtMemo]} {
	if {[file mtime $Fichier] < [file mtime $FichierTaxUniProtMemo]} {
	    array set TaxUniProt [ContenuDuFichier $FichierTaxUniProtMemo]
	    return $FichierTaxUniProtMemo
	}
    }


    set UrlPourLaMiseAJour "http://www.uniprot.org/taxonomy/?query=&force=yes&format=tab"

    TaxUniProt 1       TaxId     "=1"
    TaxUniProt 1       Name      "=root"
    TaxUniProt "root"  TaxId     "=1"
    TaxUniProt "root"  Name      "=root"
    
    TaxUniProt 1       ItsTaxIds "=1"
    TaxUniProt 1       ItsNames  "=root"
    TaxUniProt "root"  ItsTaxIds "=1"
    TaxUniProt "root"  ItsNames  "=root"
    
    TaxUniProt 1       Rank      "=no rank"
    
    TaxUniProt 1       Children  "=10239"
    TaxUniProt 1       Children  "=12884"
    TaxUniProt 1       Children  "=12908"
    TaxUniProt 1       Children  "=28384"
    TaxUniProt 1       Children  "=131567"
    
    TaxUniProt  10239  Parent    "=1"
    TaxUniProt  12884  Parent    "=1"
    TaxUniProt  12908  Parent    "=1"
    TaxUniProt  28384  Parent    "=1"
    TaxUniProt 131567  Parent    "=1"

    set f [open $Fichier "r"]
    set PrendPremiereLigne 0
    while {[gets $f Ligne]>=0} {
	if {! $PrendPremiereLigne} {
	    #lM premiere ligne contient les noms des champs
	    # Taxon | Mnemonic | Scientific name | Common name | Synonym | Other Names | Reviewed | Rank | Lineage | Parent
	    set PrendPremiereLigne 1
	    continue
	}
	
	set LesChamps [split $Ligne "\t"]
	lassign $LesChamps TaxId Mnemonic Name CommonName Synonym OtherNames Reviewed Rank Lineage Parent
	if {[string trim $Rank] eq ""} {
	    set Rank "no rank"
	}
	
	if {[info exists DejaVu($Name)]} {
	    Espionne "$Name $DejaVu($Name)"
	    set DejaVu($Name) $Ligne
	}
	
	TaxUniProt $TaxId  TaxId     "=$TaxId"
	TaxUniProt $TaxId  Name      "=$Name"
	TaxUniProt $Name   TaxId     "=$TaxId"
	TaxUniProt $TaxId  ItsNames  "=$Name"
	TaxUniProt $Name   ItsTaxIds "=$TaxId"
	TaxUniProt $TaxId  Rank      "=$Rank"
	TaxUniProt $TaxId  Lineage   "=$Lineage"
	TaxUniProt $TaxId  Parent    "=$Parent"
	TaxUniProt $Parent Children  "=$TaxId"

	TaxUniProt "ListOf" "Names" "=$Name"
    }
    TaxUniProt "SortUnique" "ListOf" "=Names"   ;#rR attention il faut aussi le =

    close $f

    TaxUniProt Vertebrata   TaxId     "=7742"
    TaxUniProt Craniata     TaxId     "=89593"
    set TaxUniProt(Vertebrata,TaxId) 7742
    set TaxUniProt(Craniata,TaxId)  89593
    Sauve [array get TaxUniProt] dans $FichierTaxUniProtMemo

    return $Fichier
}

proc TaxAK {TaxId {Quoi ""} {Quid ""} {Quid2 ""}} {
    global TaxAK

    if {$Quoi=="RankedParent"} { set Quoi "Parent" }

    set Quoi [string tolower $Quoi]
    if {$Quoi=="taxid"} { set Quoi "id" }

    set TaxId [string map [list "_" " "] $TaxId]

    if {$TaxId=="ListOf"} {
	return [Taxo::request "select distinct($Quoi) from taxon order by quoi"]
    }
    if {$Quoi=="AllDescendants"} {
	return [Taxo::getAllDescendants $TaxId $Quid $Quid2]
    }
    if {$Quoi=="TaxId"} { set Quoi "" }                  ; #rR 2021/03/12 pour TaxClass ********************** 
    set Reponse [Taxo::get $TaxId $Quoi $Quid $Quid2]
    return $Reponse
}

proc TaxUniProt {TaxId {Quoi ""} {Value ""}} {
    global TaxUniProt
    #lM a repris TaxNCBI et l'a change pour faire UniProt taxonomy

    #rR je ne sais pas pourquoi il n'y a pas de ranked comme dans Getz
    if {$Quoi=="RankedParent"} { set Quoi "Parent" }

    set TaxId [string map [list "_" " "] $TaxId]

    if {$Quoi==""} {
	set Quoi "TaxId"
	if {[regexp -nocase {^[0-9]+$} $TaxId]} { set Quoi "Name" }
    }

    if {$Value==""} { set Value "GetValue" }
    if {[string equal -nocase $Value "GetValue"]} {
	if {[info exists TaxUniProt($TaxId,$Quoi)]} { return [set TaxUniProt($TaxId,$Quoi)] }
	if { ! [info exists TaxUniProt("EstCharge")]} {
	    LoadTaxUniProt
	    return [TaxUniProt $TaxId $Quoi $Value]
	}   

	if {($Quoi=="Name" || $Quoi=="Parent" || $Quoi=="Children"  || $Quoi=="ItsNames")\
		&& ! [regexp {^[0-9]+$} $TaxId]} {
	    return [TaxUniProt [TaxUniProt $TaxId TaxId] $Quoi]
	}
	set MAJUSCULE [string toupper $TaxId]
	if {[info exists TaxUniProt($MAJUSCULE,OriginalCase)] \
		&& [info exists TaxUniProt($TaxUniProt($MAJUSCULE,OriginalCase),$Quoi)]} {
	    return $TaxUniProt($TaxUniProt($MAJUSCULE,OriginalCase),$Quoi)
	}
	return ""
    }
    set TaxUniProt("EstCharge") 1

    #rR ***************************************** il faut =value **************
    if { ! [regexp "^=" $Value]} { return "" } 
    set Value [string map [list "=" ""] $Value]

    if { ! [info exists TaxUniProt(Query,$Quoi)]} {
	set TaxUniProt(Query,$Quoi) 1
	lappend TaxUniProt(List,Queries) $Quoi
    }
    if {[string equal -nocase $Value "ResetValue"]} {
	if {[info exists TaxUniProt($TaxId,$Quoi)]} {
	    set V [set TaxUniProt($TaxId,$Quoi)] 
	    unset TaxUniProt($TaxId,$Quoi)
	}
	return $V
    }

    if {$TaxId=="SortUnique" && $Quoi=="ListOf" && $Value=="Names"} {
	set TaxUniProt(ListOf,Names) [lsort -unique $TaxUniProt(ListOf,Names)]
	return 1
    }

    set MAJUSCULE [string toupper $TaxId]
    set TaxUniProt($MAJUSCULE,OriginalCase) $TaxId

    if {$TaxId=="ListOf" && $Quoi=="Names"} {
	lappend TaxUniProt(ListOf,Names) $Value
	return $Value
    }

    if {$Quoi=="ItsNames" || $Quoi=="ItsTaxIds" || $Quoi=="Children"} {
	lappend TaxUniProt($TaxId,$Quoi) $Value
	return [set TaxUniProt($TaxId,$Quoi)]
    }
    set TaxUniProt($TaxId,$Quoi) $Value
    if {$Quoi=="Name"} {
	if { ! [info exists TaxUniProt($TaxId,exists)]} {
	    set TaxUniProt($TaxId,exists) 1
	    lappend TaxUniProt(List,TaxId) $TaxId
	}
    }
    return $Value
}

proc CondenseTaxName TN {
    if {[regexp {\(} $TN]} {
	set iO [string last "(" $TN]
	set Nouveau [string trim [string range $TN 0 [incr iO -1]]]
	return $Nouveau
    }
    set G ""
    set E ""
    set R ""
    scan $TN "%s %s %s" G E R
    if {$R==""} { return "" }
    return "$G $E"
}

proc LesChampsIndividuels {Texte {Separateur ","}} {

    if { ! [regexp $Separateur $Texte] } { regsub {[\.\;]$} $Texte "" Texte ; return [list $Texte] }

    set P 0
    set Bon ""
    set LesBons {}
    foreach C [split $Texte ""] {
	if {$C=="("} { incr P  1 }
	if {$C==")"} { incr P -1 }
	if {$C==$Separateur && $P==0 } { lappend LesBons $Bon ; continue }
	append Bon $C
    }
    regsub {^ +and *}   $Bon ""     Bon
    regsub {[\.\;]$} $Bon ""     Bon
    regsub " sp$"    $Bon " sp." Bon
    
    lappend LesBons $Bon
    return $LesBons
}

proc TaxN {TaxId} {
    global TaxI
    global TaxJ
    global TaxN
    global TaxC

    if {[info exists TaxN($TaxId)]} { return [set TaxN($TaxId)] }
    if {[info exists TaxN("EstCharge")]} { return "" }
    ChargeTaxIJNC
    return [TaxN $TaxId]    
}

proc TaxC {TaxIdOuTaxName {E ""}} {
    global TaxI
    global TaxJ
    global TaxN
    global TaxC

    if {[info exists TaxC($TaxIdOuTaxName)]} { return [set TaxC($TaxIdOuTaxName)] }
    if {[regexp -nocase {[a-z]} $TaxIdOuTaxName]} {
	set TaxId [TaxI $TaxIdOuTaxName $E]
    } else {
	set TaxId $TaxIdOuTaxName
    }

    if {[info exists TaxC($TaxId)]} { return [set TaxC($TaxId)] }
    if {[info exists TaxC("EstCharge")]} { return "" }
    ChargeTaxIJNC
    return [TaxC $TaxId]    
}

proc TaxI {TaxName {E ""}} {
    global TaxI
    global TaxJ
    global TaxN
    global TaxC

    if {$E!=""} { set TaxName "$TaxName $E" }

    if {[info exists TaxI($TaxName)]} { return [set TaxI($TaxName)] }
    if {[info exists TaxI("EstCharge")]} {
	set TN $TaxName
	while {$TN!=""} {
	    if {[info exists TaxJ($TN)]} { return [set TaxJ($TN)] }
	    set TN [CondenseTaxName $TN]
	}
	return ""
    }
    ChargeTaxIJNC
    return [TaxI $TaxName]    
}

proc ChargeTaxIJNC {} {
    global TaxI
    global TaxJ
    global TaxN
    global TaxC

    set TaxI("EstCharge") 1
    set TaxJ("EstCharge") 1
    set TaxN("EstCharge") 1
    set TaxC("EstCharge") 1


    set FichierSwiss "/prot/gcgswissprot/swissprot.ref"
#    set FichierSwiss "[HomeRipp]/sw.ref"

    set FichierTaxI "[GscopeDatabaseDir Common]/fiches/taxi"
    set FichierTaxJ "[GscopeDatabaseDir Common]/fiches/taxj"
    set FichierTaxN "[GscopeDatabaseDir Common]/fiches/taxn"
    set FichierTaxC "[GscopeDatabaseDir Common]/fiches/taxc"
    set ErrorLogI   "[GscopeDatabaseDir Common]/fiches/error_taxi.log"
    set ErrorLogN   "[GscopeDatabaseDir Common]/fiches/error_taxn.log"
    set ErrorLogC   "[GscopeDatabaseDir Common]/fiches/error_taxc.log"

    if {[file exists $FichierTaxI]} {
	if {[file exists $FichierTaxI]} { array set TaxI [LesLignesDuFichier $FichierTaxI] }
	if {[file exists $FichierTaxJ]} { array set TaxJ [LesLignesDuFichier $FichierTaxJ] }
	if {[file exists $FichierTaxN]} { array set TaxN [LesLignesDuFichier $FichierTaxN] }
	if {[file exists $FichierTaxC]} { array set TaxC [LesLignesDuFichier $FichierTaxC] }
	return
    }

    catch {unset OS}
    catch {unset OX}
    catch {unset OC}
    catch {unset LOS}
    catch {unset LOX}
    catch {unset LesOS}
    catch {unset LesOX}
    set OX ""
    set OldAccess ""
    set n 9999
    set FS [open $FichierSwiss "r"]
    while {[gets $FS Ligne]>=0} {
	if {[regexp "^>" $Ligne]} {
	    if { [expr $n%100==0] } { Espionne $n }
	    if { ! [incr n -1] } { break }
	    if {[info exists DejaVu($OX)] || ! [regexp -nocase "NCBI_TaxID=" $OX]} { continue }
	    set LesS [LesChampsIndividuels $OS]
	    regsub -nocase "NCBI_TaxID=" $OX "" OX
	    set LesX [LesChampsIndividuels $OX] 
	    if {[llength $LesS]!=[llength $LesX]} {
		FaireLire "Different list length\n $OS\n$OX"
		catch {unset OS}
		catch {unset OX}
		catch {unset OC}
		catch {unset LOS}
		catch {unset LOX}
		catch {unset LOC}
		catch {unset LesOS}
		catch {unset LesOX}
		regsub {>+} $Ligne "" OldAccess
		continue
	    }
	    if {[llength $LesS]==1} {
		foreach S $LesS X $LesX {
		    if { ! [info exists TaxN($X)]} { set TaxN($X) $S }
		    if { ! [info exists TaxI($S)]} { set TaxI($S) $X }
		    if {$S!=[set TaxN($X)]} {
			AppendAuFichier $ErrorLogI \
				"\nI saw already \n[set TaxN($X)]\n instead of\n$S\n$OldAccess for $X" 
			break 
		    }
		    if {$X!=[set TaxI($S)]} {
			AppendAuFichier $ErrorLogN \
				"\nI saw already \n[set TaxI($S)]\n instead of\n$X\n$OldAccess for $X" 
			break
		    }
		    set TN $S
		    while {[set TN [CondenseTaxName $TN]]!=""} {
			set TaxJ($TN) $X
		    }
		}
		if {[info exists OC]} {
		    set X [lindex $LesX 0]
		    set Class $OC
		    if {[info exists TaxC($X)] && [set TaxC($X)]!=$Class} {
			AppendAuFichier $ErrorLogC \
				"\nI saw already \n[set TaxC($X)]\n instead of\n[set TaxC($X)]\
				\n$\n$OldAccess for $X"
			break
		    }
		    set TaxC($X) $Class
		    set S [lindex $LesS 0]
		    if {[info exists TaxC($S)] && [set TaxC($S)]!=$Class} {
			AppendAuFichier $ErrorLogClass \
				"\nI saw already \n[set TaxC($S)]\n instead of\n[set TaxC($S)]\
				\n$\n$OldAccess for $S"
			break
		    }
		    set TaxC($S) $Class
		}
	    }
	    set DejaVu($OX) 1
	    catch {unset OS}
	    catch {unset OX}
	    catch {unset OC}
	    catch {unset LOS}
	    catch {unset LOX}
	    catch {unset LOC}
	    catch {unset LesOS}
	    catch {unset LesOX}
	    regsub {>+} $Ligne "" OldAccess
	    continue
	}
	if {[regexp "^OS " $Ligne]} {
	    if { ! [info exists LOS]} { set LOS {} }
	    regsub {^OS +} $Ligne "" O
	    lappend LOS $O
	    if {[regexp {\.$} $Ligne]} {
		set OS [join $LOS " "]
	    }
	}
	if {[regexp "^OC " $Ligne]} {
	    if { ! [info exists LOC]} { set LOC {} }
	    regsub {^OC +} $Ligne "" O
	    lappend LOC $O
	    if {[regexp {\.$} $Ligne]} {
		set OC [join $LOC " "]
	    }
	}
	if {[regexp "^OX " $Ligne]} {
	    if { ! [info exists LOX]} { set LOX {} }
	    regsub {^OX +} $Ligne "" O
	    lappend LOX $O
	    if {[regexp {\;$} $Ligne]} {
		set OX [join $LOX " "]
	    }
	}
    }
    close $FS
    SauveLesLignes [array get TaxI] dans $FichierTaxI
    SauveLesLignes [array get TaxJ] dans $FichierTaxJ
    SauveLesLignes [array get TaxN] dans $FichierTaxN
    SauveLesLignes [array get TaxC] dans $FichierTaxC
    return
}