#rR gscope_bird.tcl

proc BirdEstDisponible {{Value ""}} {
    global BirdEstDisponible
    if {$Value!=""} { set BirdEstDisponible $Value }
    if { ! [info exists BirdEstDisponible]} { set BirdEstDisponible 0 }
    return $BirdEstDisponible
}

proc TestPost {} {
    set query [::http::formatQuery "ka" "va" "kb" "vb\navecNL" "kc" "vc"]
    set token [::http::geturl "http://ena/wscoperr?Zero&CaVa" -query $query]
    upvar #0 $token state
    set body $state(body)
    ::http::cleanup $token

    return $body
}

proc DbFetchForMacsim {{Quoi ""}} {
    regsub -all "aLaLiGnE" $Quoi "\n" Quoi
    set LesId {}
    foreach Ligne [split $Quoi "\n"] {
	if { ! [regexp "ID   (.+)" $Ligne Match Id]} { continue }
	regsub "\;.*" $Id "" Id
	lappend LesId $Id
    }
    set Uniprot  [DbFetchGET uniprot $LesId]
#    return $Uniprot
    set Interpro [DbFetchGET interpro $LesId]
    return $Interpro
}

proc TestBirdFromTheBlast {} {
    BirdFromTheBlast EF001

    return [BirdWeb "uniprot" "UniRef50_Q057N6"]
}

proc BirdFromTheBlast {Nom {DB ""} {Qui ""}} {

    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    global BirdFromTheBlast
    if {$Nom=="Reset"} { 
	if {[info exists BirdFromTheBlast]} { unset BirdFromTheBlast }
	return ""
    }
    if {[info exists BirdFromTheBlast($Nom)]} { return $BirdFromTheBlast($Nom) }
    if {$DB==""} { set DB "uniprot" }
    set FichierBlast [GscopeFile $Nom "blastp"]
    if { ! [file exists $FichierBlast]} { return "" }
    DecortiqueBlast $FichierBlast "" "" Query lBanqueId lAccess
    set Query {}
    foreach BanqueId $lBanqueId {
	set BanqueIdOrigine $BanqueId
	regsub -nocase {^Uniref[^\_]+_} $BanqueId "" BanqueId
	#rR a rajouté 2014/11/25
	if {[regexp "\|" $BanqueId]} {
	    set BanqueId [lindex [split $BanqueId "|"] 2]
	}
	set Origine($BanqueId) $BanqueIdOrigine
	lappend LesBanqueId $BanqueId
	lappend Query "ID $BanqueId DB $DB"
	lappend Query "FM FLAT"
    }
    set Query [join $Query "\n"]
    set R [BirdFromQueryText $Query]
    set Id ""
    set LesAc {}
    set LaSeq {}
    foreach Ligne [split $R "\n"] {
	if {[string trim $Ligne]==""} { continue }
	if {[regexp "^//" $Ligne]} {
	    lappend LaSeq $Ligne
	    set Seq [join $LaSeq "\n"]
	    lappend LesSeqDe($Id) $Seq
	    foreach Ac $LesAc {
		lappend LesSeqDe($Ac) $Seq
	    }
	    set Id ""
	    set LesAc {}
	    set LaSeq {}
	    continue
	}
	lappend LaSeq $Ligne
	set IdLu ""
	set LesAcLu ""
	if {[regexp {^ID   ([^ ]+)} $Ligne Match IdLu]} { set Id $IdLu }
	if {[regexp {^AC   (.*)}    $Ligne Match AcLu]} {
	    regsub -all {[ \;]+} $AcLu " " AcLu
	    set LesAc [split [string trim $AcLu " "] " "]
	}
    }
    foreach BanqueId $LesBanqueId {
	if { ! [info exists LesSeqDe($BanqueId)]} {
	    lappend LeResultat [list $BanqueId "NotFound"]
	    continue
	}
	if {[llength $LesSeqDe($BanqueId)]>1} { FaireLire "$BanqueId has more than 1 hits" }
	lappend LeResultat [list $BanqueId [lindex $LesSeqDe($BanqueId) 0]]
    }
    foreach R $LeResultat {
	lassign $R K V
	set BirdFromTheBlast($K) $V 
	set BirdFromTheBlast($Origine($K)) $V 
	
    }
    if {$Qui!=""} { return [BirdFromTheBlast $Qui] }
    return $LeResultat
}

proc BirdQL {query {BirdUrl ""}} {

    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    #rR ce BirdQL est de pris Nicolas Gagniere avec mes modifs
    #rR j'y ai rajoute BirdEntry et BirdFasta pris aussi dans gagniere/gscopublic au cas ou ...    package require http
    if {$BirdUrl==""} { set BirdUrl [BirdUrl] }
    set BirdBsearchUrl $BirdUrl
    if { ! [regexp "bsearch" $BirdUrl]} { set BirdBsearchUrl "$BirdUrl/bsearch" }
    set query [::http::formatQuery "service" "birdql" "query" $query]
    set token [::http::geturl $BirdBsearchUrl -query $query]
    upvar #0 $token state
    set body $state(body)
    ::http::cleanup $token

    return $body
}


proc TestBirdQL {} {
    set LaQuery {}
    lappend LaQuery "ID CO8B_HUMAN DB Uniprot"
    lappend LaQuery "FD AC,ID,DR,GN"
    lappend LaQuery "FM FLAT"
    lappend LaQuery "AC P12345 DB Uniprot"
    lappend LaQuery "FD AC,ID,DR,GN"
    lappend LaQuery "FM FLAT"
    set Query [join $LaQuery "\n"]
    return [BirdFromQueryText $Query]
    return [BirdQL $Query]
}


proc BirdEntry {ListeAcOuIds {ListeDBs "UNIPROT"}} {

    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    if {$ListeAcOuIds eq "" || $ListeDBs eq ""} {return ""}
    package require http

    set url [BirdUrl]
    #rR set url "http://bird.u-strasbg.fr:8080/bird/bsearch"
    #set url "http://d1.crihan.fr:8080/bird/bsearch"
    set query [::http::formatQuery "service" "birdql" "query" "ID [join $ListeAcOuIds ","] DB [join $ListeDBs ","]"]
    
    set token [::http::geturl $url -query $query]
    upvar #0 $token state
    set body $state(body)
    ::http::cleanup $token

    set entries {}
    set entryStart 0
    foreach location [regexp -inline -all -indices -line {^//$} $body] {
	foreach {start stop} $location {}
	lappend entries "[string trim [string range $body $entryStart [expr $start - 1]]]\n//\n"
	set entryStart [expr $stop + 1]
    }

    return $entries
}

proc BirdFastaOldDeRaymond {ListeAcOuIds {ListeDBs "UNIPROT"}} {
    if {$ListeAcOuIds eq "" || $ListeDBs eq ""} {return ""}
    package require http

    set url [BirdUrl]
    #set url "http://bird.u-strasbg.fr:8080/bird/bsearch"
    #rR set url "http://d1.crihan.fr:8080/bird/bsearch"
    
    set query ""
    foreach acOuId $ListeAcOuIds {
	append query "ID $acOuId DB [join $ListeDBs ", "]\nFM FASTA\n//\n"
    }

    #set query [::http::formatQuery "service" "birdql" "query" "ID [join $ListeAcOuIds ","] DB [join $ListeDBs ", "]\nFM FASTA"]
    set query [::http::formatQuery "service" "birdql" "query" $query]
    
    set token [::http::geturl $url -query $query]
    upvar #0 $token state
    set body $state(body)
    ::http::cleanup $token

    set entries {}
    set entryStart 0
    foreach location [regexp -inline -all -indices -line {^\s*$} $body] {
	foreach {start stop} $location {}
	set entry "[string trim [string range $body $entryStart [expr $start - 1]]]\n"
	if {[string trim $entry] ne ""} {
	    lappend entries $entry
	}
	set entryStart [expr $stop + 1]
    }

    return $entries
}

proc BirdShowTable {Schema Table} {
    set ShowTable [HttpGetTextFromUrl "[BirdUrl]/detail?metadata=$Schema.$Table"]
    return $ShowTable
}

proc BirdMetadata {{Qui ""} {Quoi ""}} {
    global BirdMetadata

    if {$Qui==""} {
	set Qui "ListOf"
	set Quoi "BankType"
    }

    if {[info exists BirdMetadata($Qui,$Quoi)]} { return $BirdMetadata($Qui,$Quoi) }
    if {[info exists BirdMetadata("EstCharge")]} { return "" }
    set BirdMetadata("EstCharge") 1
#    set MetadataUrl "[BirdUrl]/bsearch?service=metadata&db=all"
#    set MetadataUrl "http://bird.u-strasbg.fr:8080/bird/temp/metadata.xml"
    set MetadataUrl "[BirdUrl]/temp/metadata.xml"
    set Metadata [HttpGetTextFromUrl $MetadataUrl]
    set XML $Metadata
    set Id  [dom parse $XML]
    set Root [$Id documentElement]


    set BirdMetadata(ListOf,BankType) {}
    set BirdMetadata(ListOf,BankName) {}
    set LesBankList [$Root selectNodes "bird-bank-meta"]
    foreach BankElement $LesBankList {
	set BankType     [$BankElement getAttribute "type"]
	set BankSchemas  [$BankElement getAttribute "schema"]
	set BankMetadata [$BankElement getAttribute "metadata"]
	set BankFormats  [$BankElement getAttribute "format_out"]
	regsub -all "," $BankFormats " " BankFormats
	set LesBankFormat [LesMotsDeLaLigne $BankFormats]	

	set BirdMetadata($BankType,BankMetadata) $BankMetadata
	set BirdMetadata($BankType,BankFormats)  $LesBankFormat

	regsub -all "," $BankSchemas " " BankSchemas
	set LesBankSchemas [LesMotsDeLaLigne $BankSchemas]
	lappend BirdMetadata(ListOf,BankType) $BankType
	set BirdMetadata($BankType,BankSchemas) {}
	foreach BankSchema $LesBankSchemas {
	    regsub {\(.*} $BankSchema "" BankSchema
	    if {[string trim $BankSchema]==""} { continue }
	    lappend BirdMetadata(ListOf,BankSchema) $BankSchema
	    lappend BirdMetadata($BankType,BankSchemas) $BankSchema
	    set BirdMetadata($BankSchema,BankType) $BankType
	}
	
	set LesKeys [$BankElement selectNodes "key"]
	set BirdMetadata($BankType,KeyDisplays)  {}
	set BirdMetadata($BankType,AliasBirdqls) {}
	set BirdMetadata($BankType,Comments)     {}
	foreach Key $LesKeys {
	    set KeyDisplay  [$Key getAttribute "keyDisplay"] 
	    set AliasBirdql [$Key getAttribute "alias_birdql"] 
	    set Comment     [$Key getAttribute "comment"]
	    lappend BirdMetadata(ListOf,KeyDisplay)  $KeyDisplay
	    lappend BirdMetadata(ListOf,AliasBirdql) $AliasBirdql
	    lappend BirdMetadata(ListOf,Comment)     $Comment
	    lappend BirdMetadata($BankType,KeyDisplays)  $KeyDisplay
	    lappend BirdMetadata($BankType,AliasBirdqls) $AliasBirdql
	    lappend BirdMetadata($BankType,Comments)     $Comment
	    set BirdMetadata($BankType:K:$KeyDisplay,KeyDisplay)   $KeyDisplay
	    set BirdMetadata($BankType:K:$KeyDisplay,AliasBirdql)  $AliasBirdql
	    set BirdMetadata($BankType:K:$KeyDisplay,Comment)      $Comment
	    set BirdMetadata($BankType:A:$AliasBirdql,KeyDisplay)  $KeyDisplay
	    set BirdMetadata($BankType:A:$AliasBirdql,AliasBirdql) $AliasBirdql
	    set BirdMetadata($BankType:A:$AliasBirdql,Comment)     $Comment
	}
    }
    set BirdMetadata(ListOf,KeyDisplay)  [lsort -unique $BirdMetadata(ListOf,KeyDisplay)]
    set BirdMetadata(ListOf,AliasBirdql) [lsort -unique $BirdMetadata(ListOf,AliasBirdql)]
    set BirdMetadata(ListOf,Comment)     [lsort -unique $BirdMetadata(ListOf,Comment)]
    foreach K [array names BirdMetadata] {
	regsub "," $K " " K
	scan $K "%s %s" I O
	lappend BirdMetadata(ListOf,Quoi) $O
	lappend BirdMetadata(ListOf,QuiQuoi) "$I $O"
	if {$I=="ListOf"} { lappend BirdMetadata(ListOf,ListOf) $O }
    }
    lappend lappend BirdMetadata(ListOf,Quoi) "ListOf"
    set BirdMetadata(ListOf,Quoi) [lsort -unique $BirdMetadata(ListOf,Quoi)]
    return [BirdMetadata $Qui $Quoi]
}

proc TestBirdFromQueryText {} {
    set Query {}
#    foreach Access [list NP_000035 NP_001009012 NP_001028083 XP_001504915 NP_001003053 NP_038504 NP_036634 NP_999479 XP_001376683] {}
    foreach Access [list P12345999 PAX2_HUMAN] {
	lappend Query "ID $Access DB uniprot"
	lappend Query "FM FLAT"
    }
    set Query [join $Query "\n"]
    Espionne $Query
    set R [BirdFromQueryText $Query]
    return $R
}

proc BirdGscopeQueries {} {
    set FichierBirdGscopeQueries [Fiches "BirdGscopeQueries.ql"]
    if {[FileAbsent $FichierBirdGscopeQueries]} {
	set BaseGscope [file tail [RepertoireDuGenome]]
	set LaReq {}
	lappend LaReq "ID * DB $BaseGscope"
	lappend LaReq "LM 1"
	lappend LaReq "FM XML"
	set Req [join $LaReq "\n"]
	return $Req
    }
    return [ContenuDuFichier $FichierBirdGscopeQueries]
}

proc BirdGscopeSearch {} {
    set K [AfficheListe [BirdGscopeKeywords] "SetWidth9" "Possible_Keywords"]
    set Queries [BirdGscopeQueries]
    set Req [EntreTexte $Queries]
    if {$Req==""} { return "" }
    set Retour [BirdFromQueryText $Req]
    set Sep [string repeat "*" 80]
    set Texte "Result of following BirdQuery\n$Sep\n$Req\n$Sep\nIf you want to know more, select a Nom:... and press SearchOnBoard\n$Sep\n$Retour"
    set F [AfficheVariable $Texte "AvecBird" "Result_of_BirdGscopeSearch"]
    BoutonneLaFenetre $F "New Bird Search" "BirdGscopeSearch"
    return $F
}

proc BirdGscopeKeywords {{BaseGscope ""} {Format ""}} {
    if {$BaseGscope==""} { set BaseGscope [file tail [RepertoireDuGenome]] }
    return [BirdKeywords $BaseGscope $Format]

}

proc BirdKeywords {{BaseBird ""} {Format ""}} {

    if {$Format==""} { set Format "FLAT" }

    set LaReq {}
    lappend LaReq "ID * DB $BaseBird"
    lappend LaReq "LM 1"
    lappend LaReq "FM $Format"
    set Req [join $LaReq "\n"]

    set Tout [BirdFromQueryText $Req]

    set LesClefs {}
    if {$Format == "XML"} {
	set Entry "[string tolower $BaseBird].entry"
	set Avant 1
	foreach Ligne [split $Tout "\n"] {
	    if {$Avant} {
		if { [regexp "<$Entry.*>" $Ligne]} { set Avant 0 }
		continue
	    }
	    if { [regexp {</?resultset>} $Ligne]} { continue }
	    if { [regexp "</$Entry.*>" $Ligne]} { continue }
	    regsub {>.*} $Ligne "" Clef
	    regsub {<} $Clef "" Clef
	    lappend LesClefs $Clef
	}
    } else {
	foreach Ligne [split $Tout "\n"] {
	    if { ! [regexp -nocase {^[a-z0-9_\-]+} $Ligne Clef]} { continue }
	    lappend LesClefs $Clef
	}
    }
    set LesClefs [lsort -unique $LesClefs]
    return $LesClefs
}

proc BirdFromQueryText {Texte {OutFile ""} {BirdUrl ""}} {

    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    set Retour [BirdQL $Texte $BirdUrl]
    if {$OutFile==""} { return $Retour }
    return [Sauve $Retour dans $OutFile]
}

proc BirdFromQueryFile {Fichier {OutFile ""} {BirdUrl ""}} {

    return [BirdFromQueryText [ContenuDuFichier $Fichier] $OutFile $BirdUrl]
#rR reste est obsolete mais marche quand meme On utilise curl
    if {$BirdUrl==""} { set BirdUrl [BirdUrl] }
    set Retour [eval exec curl -stderr /dev/null -F upload=@$Fichier "$BirdUrl/bsearch?service=birdql"]
    if {$OutFile==""} { return $Retour }
    return [Sauve $Retour dans $OutFile] 
}

proc BirdStar4FromQueryFile {Fichier {Options ""} {Racine ""} {KeepZip ""} {TarFile ""}} {

    set Options [string trim $Options " \t\n"]
    if {$Options!="" && ! [regexp {^\&} $Options]} { set Options "&$Options" }

    set KeepZip [string equal -nocase $KeepZip "KeepZip"]
    if {$Racine==""} { set Racine "BirdResult" }
    set Delete 0
    if {$TarFile==""} {
	set Delete 1
	set TarFile "[TmpFile].bird.tar.gz"
    }

    set CommandeBird "curl -s -F upload=@$Fichier \
	    \"http://star4:8080/mybiodb/bsearch?service=bird_explorer&out_file=${Racine}${Options}\" \
	    -o $TarFile"
    Espionne $CommandeBird
    if {[catch {eval exec $CommandeBird} Message]} {Espionne "Error from curl : START of message\n$Message\nEND of message"}	

    if {$KeepZip} { return $TarFile }
    set Retour [exec zcat $TarFile]
    if {$Delete} { file delete $TarFile }
    return $Retour
}

proc LesDefinitionsDuMsf FichierMsf {
    set NombreDeSequences [DecortiqueUnMSF $FichierMSF LesSequencesDansLOrdre]
    foreach NomSeq $LesSequencesDansLOrdre {
	regsub "spt_" $NomSeq "" Access
	set DE [BirdWeb UNIPROT $Access]
	Espionne "$Access $DE"
    }
    return 
}

proc BirdWebFromTFAs {Database Accession {Fields ""}} {
    if {$Fields==""} { set Fields "all" }

    set FieldAuto(DBXREF) 1

    set LesFieldsDemandes {}
    foreach FieldDemande [split $Fields ","] {
	if {$FieldDemande==""} { continue }
	if { ! [info exists FieldAuto([string toupper $FieldDemande])]} {
	    lappend LesFieldsDemandes $FieldDemande
	}
	set AAfficher([string toupper $FieldDemande]) 1
	lappend LesFieldsAAfficher $FieldDemande
    }
    set Param "&field=[join $LesFieldsDemandes ","]"
    set Url "[BirdUrl]/bsearch?db=$Database&accession=$Accession&format=flat$Param"
    set Tout [HttpGetTextFromUrl $Url]
    return $Tout
}

proc BirdWeb {Database Accession {Fields ""}} {

    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    if {$Fields==""} { set Fields "all" }

    #rR on peut deja avoir cherche et memorise tous les access d'un blast   (rajout du 2014/03/11)
    if {$Fields=="all" && [string equal -nocase "uniprot" $Database]} {
#	Espionne "I'll try BirdFromTheBlast $Accession"
	if {[set Info [BirdFromTheBlast $Accession]]!=""} {
	    if {$Info=="NotFound"} { return "" }
	    return $Info
	}
    }

    set FieldAuto(DBXREF) 1

    set LesFieldsDemandes {}
    foreach FieldDemande [split $Fields ","] {
	if {$FieldDemande=="all"} { continue }
	if {$FieldDemande==""} { continue }
	if { ! [info exists FieldAuto([string toupper $FieldDemande])]} {
	    lappend LesFieldsDemandes $FieldDemande
	}
	set AAfficher([string toupper $FieldDemande]) 1
	lappend LesFieldsAAfficher $FieldDemande
    }
    set Param ""
    if {$LesFieldsDemandes!={} || $Fields!="all"} {
	set LesKeysDemandes {}
	foreach F $LesFieldsDemandes {
	    set K $F
#	    if {[set K [BirdMetadata "$Database:K:$F AliasBirdql"]]==""} { set K $F } 
	    lappend LesKeysDemandes $K
	} 
	set Param "&field=[join $LesKeysDemandes ","]"
    }
    set Url "[BirdUrl]/bsearch?db=$Database&accession=$Accession$Param"
    if {[catch {set Tout [string trim [HttpGetTextFromUrl $Url]]} Message] } {
	Warne "Error from Bird with message : $Message"
	return ""
    }
    if {[string equal -nocase $Fields "all"]} { return $Tout }
    set LaSortie {}
    set YaEuSQ 0
    foreach Ligne [split $Tout "\n"] {
	if {[regexp "^SQ   " $Ligne]} {
	    set YaEuSQ 1
	    set Seq ""
	    continue
	}
	if {$YaEuSQ} {
	    if {[regexp "     " $Ligne]} { append Seq [string trim $Ligne] ; continue }
	    lappend LaSortie "$Seq"
	    set $YaEuSQ 0
	    continue 
	}
	if {[regexp "^//" $Ligne]} { continue }
	if {[regexp -nocase {[a-z_0-9]+([= ])} $Ligne Match PremierSeparateur]} {
	    set F [lindex [split $Ligne $PremierSeparateur] 0]
#	    set K [BirdMetadata $F "Key"]
	    set K $F
	    if { ! [info exists AAfficher([string toupper $F])] && ! [info exists AAfficher([string toupper $K])]} { continue }
	    set Valeur [string trim [StringSuivant $PremierSeparateur dans $Ligne]]
#	    set Valeur $Ligne
#	    regsub {[^=]*=} $Valeur "" Valeur
	    lappend LaSortie $Valeur
	} else {
	    set F [lindex [split $Ligne " "] 0]
#	    set K [BirdMetadata $F "Key"]
	    set K $F
	    if { ! [info exists AAfficher([string toupper $F])] && ! [info exists AAfficher([string toupper $K])]} { continue }
	    set Valeur $Ligne
	    regsub {[^ ]* +} $Valeur "" Valeur
	    lappend LaSortie $Valeur
	}
    }
    return [join $LaSortie "\n"]
}

proc BirdGet {NM {Field ""}} {
    if {$Field==""} { set Field "accession" }
    return [BirdGetFields $NM $Field "WithoutField"]
}

proc BirdGetFields {NM {Fields ""} {WithoutField ""}} {

    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    set WithoutField [string equal -nocase $WithoutField "WithoutField"]
    set LesFieldsAAfficher {}
    if {$Fields==""} {
	set Param ""
    } else {
	set FIELDS [string toupper $Fields]
	set LesFieldsDemandes {}
	foreach FieldDemande [split $FIELDS ","] {
	    if {$FieldDemande==""} { continue }
	    if { ! [regexp {^(DBXREF|GO_COMPONENT|GO_FUNCTION|GO_PROCESS)$} $FieldDemande]} {
		lappend LesFieldsDemandes $FieldDemande
	    }
	    set AAfficher($FieldDemande) 1
	    lappend LesFieldsAAfficher $FieldDemande
	}	    
	set Param "&field=[join $LesFieldsDemandes ","]"
    }
    set Tout [HttpGetTextFromUrl "[BirdUrl]/getprotein?db=REFSEQRNA&accession=$NM"]
    set Tout [string trim $Tout " \n\t"]
    set LesBons {}
    set LesClefs {}
    foreach Ligne [split $Tout "\n"] {
	if { ! [regexp {^[^=]+} $Ligne Clef]} {
	    lappend LesBons $Ligne
	    continue
	}
	set CLEF [string toupper $Clef]
	set Valeur [StringSuivant "=" dans $Ligne]
	if { ! [info exists DejaVu($CLEF)]} { lappend LesCLEFS $CLEF ; set DejaVu($CLEF) 1}
	lappend LesValeurs($CLEF) $Valeur
    }
    foreach CLEF $LesFieldsAAfficher {
	set TexteClef "$CLEF="
	if {$WithoutField} { set TexteClef "" }
	if { ! [info exists LesValeurs($CLEF)]} {
	    if {[info exists  AAfficher($CLEF)]} { lappend LesBons "$TexteClef" }
	    continue
	}
	if {[llength $LesValeurs($CLEF)]==1} {
	    if {[info exists  AAfficher($CLEF)]} { lappend LesBons "$TexteClef[string trim [lindex $LesValeurs($CLEF) 0] ";"]" }
	    continue
	}
	set LesBonnesValeurs {}
	foreach Valeur $LesValeurs($CLEF) {
	    regsub -all ";" $Valeur ",," Valeur
	    lappend LesBonnesValeurs $Valeur
	}
	if {[info exists AAfficher($CLEF)]} {
	    lappend LesBons "$TexteClef[join $LesBonnesValeurs ";"]"
	}
    }
    set Bon [join $LesBons "\n"]
    return $Bon
}

proc NPduNM NM {
#    set NP [HttpGetTextFromUrl "[BirdUrl]/getprotein?db=REFSEQRNA&accession=$NM"]
#    set NP [string trim $NP " \n\t"]
    set NP [BirdGet $NM "accession"]
    regsub {\..*} $NP "" NP
    return $NP
#    set Query "select cds.protein_id from refseqRNA.ft_cds as cds,refseqRNA.entry as entry where entry.accession='$NM' and cds.key_fk=entry.oid"
#    set NP [Bird $Query "flat"]
#    return $NP
}

proc BirdSendQueryAndGetFromUrl {Query {Url ""} {Options ""}} {

    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    package require http

    if {$Url==""} { set Url "[BirdUrl]/bsearch" }

    set QueryEncode [::http::formatQuery querytext $Query]
#    Espionne $QueryEncode
    if {$Options!=""} { append QueryEncode "&$Options" } 
    set Token [eval ::http::geturl $Url -query $QueryEncode]
    return [::http::data $Token]
}

proc BirdSendQueryUrlAndGetFromUrl {QueryUrl {Url ""} {Options ""}} {

    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    package require http

    if {$Url==""} { set Url "[BirdUrl]/bsearch" }

    set QueryUrlEncode [eval ::http::formatQuery querytext "\"$QueryUrl\""]
#    regsub -all {\+} $QueryUrlEncode {%20} QueryUrlEncode
    if {$Options!=""} { append QueryUrlEncode "&$Options" } 
    set Token [::http::geturl $Url -query $QueryUrlEncode]
    return [::http::data $Token]
}

proc BirdPostFileAndGetFromUrl {Filename {Url ""} {Options ""}} {

    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    package require http

    if {$Url==""} { set Url "[BirdUrl]/bsearch" }

    set f [open $Filename r]
    set Query [read -nonewline $f]
    close $f

    set PostEncode [eval ::http::formatQuery querytext $Query]
    if {$Options!=""} { append PostEncode "&$Options" } 

    set Token [::http::geturl $Url -query $PostEncode]
    return [::http::data $Token]
}

proc TestBird {} {
    set Query "select * from ucschuman.refgene where  txend < 990000 and txstart >= 924207 and chrom='chr1'"
    Espionne [Bird $Query xml]
}

proc Bird {Query {Format ""} {Out ""}} {

    if { ! [BirdEstDisponible]} { Warne "Attention Bird n'est pas disponible" ; return "" }

    #nG if {$Out==""} { set Out "GetResult" }BirdSendQueryUrlAndGetFromUrl
    if {$Out==""} { set Out "GetResult" }
    if {[string equal -nocase $Out "GetResult"]} {
	set OutFile "/dev/null"
    } else {
	set OutFile $$Out
    }
    if {$Format==""} { set Format "xml" }
    set GetRootNode 0
    if {[string equal -nocase $Format "documentElement"]} {
	set Format "xml"
	set GetRootNode 1
    }
    set FichierQueryTmp "[TmpFile].sql"
    Sauve $Query dans $FichierQueryTmp
    set FichierQuery $FichierQueryTmp
#rR AFAIRE
#    set Q "http://star4:8080/mybiodb/bsearch?querytext=select%20NAME,%20TXSTART,%20TXEND,%20STRAND%20from%20ucscmouse.refgene%20where%20chrom='chr1'%20and%20txStart%3C=95452457&format=xml"
#rR
    set RetourBird [exec bird_explorer_ucsc $FichierQuery $OutFile format=$Format display=yes]
    if {[info exists FichierQueryTmp] && [file exists $FichierQueryTmp]} {file delete $FichierQueryTmp}

    if {$Format=="xml" && $GetRootNode} {
	package require tdom 
	set RootNode [[dom parse $RetourBird] "documentElement"]
	return $RootNode
    }
    if {$Out=="GetResult"} { return $RetourBird }
    return $OutFile
}

proc BirdUrl {} {
#   set Url "http://decrypthon.u-strasbg.fr:8080/bird"
#   set Url "http://star4:8080/bird"
#   set Url "http://bird.u-strasbg.fr:8080/bird"
#   set Url "http://bird.igbmc.fr:8080/bird"
   set Url "http://kbm.u-strasbg.fr:8080/birdsnp"
#   set Url "http://d1.crihan.fr:8080/bird"
#   set Url "http://195.221.22.98:8080/bird"
    return $Url
}