#rR gscope_secator
#rR ce n'est pas clair ... faut-il utiliser /biolo/secator ou le secator dans cluspack ??? 
#rR car il y a /biolo/secator ou dpc ou l'un ou l'autre dans cluspack
 
proc Secator {FichierMSF {Sortie ""}} {

    if {$Sortie==""} { set Sortie "GetClusterFile" }

    set Racine [TmpFile secator "" "_"]
    file copy $FichierMSF $Racine

    global env ; set env(SECATORHOME) "/biolo/secator"

    global ExecutableSecator
#rR if { ! [info exists ExecutableSecator]} { set ExecutableSecator "secator" }
    if { ! [info exists ExecutableSecator]} { set ExecutableSecator "/biolo/cluspack/binNew/cluspack" }
    set OptionAlignment ""
    set FichierDesClusters "$Racine.sec"
    if {[regexp "cluspack" $ExecutableSecator]} {
	set OptionAlignment "-dt=alignment -cm=bionj -nbc=secator"
	set FichierDesClusters "$Racine.clu"
    }
    if {$ExecutableSecator=="dpc"} {
	set OptionAlignment "alignment"
	set FichierDesClusters "$Racine.dpc"
    }
    if {[catch {eval exec $ExecutableSecator $Racine $OptionAlignment} Message]} {
	Warne "$ExecutableSecator $Racine $OptionAlignment\n failed with \n$Message"
	return ""
    }
    if { ! [file exists $FichierDesClusters]} {
	Warne "$ExecutableSecator didn't create $FichierDesClusters for \n$FichierMSF"
	return ""
    }
    if {$Sortie=="ListAllOutputs"} {
	set LesSorties [glob -nocomplain $Racine*]
	return $LesSorties
    }
    if {$Sortie=="GetText"}        { return [ContenuDuFichier $FichierDesClusters] }
    if {$Sortie=="GetClusterFile"} { return $FichierDesClusters }
    file copy $FichierDesClusters $Sortie
    return $Sortie
}


proc LesAccessDuGroupe {NomOuMSF Query {Liste "Tous"} {Calculate ""}} {

    if {$Liste=="Tous"} { return [GroupeSecator $NomOuMSF $Query "In" $Calculate] }

    foreach Access [GroupeSecator $NomOuMSF $Query "In" $Calculate] {
	set MoiAussi([string toupper $Access]) 1
    }

    set LesBons {}
    foreach Access $Liste {
	if { ! [info exists MoiAussi([string toupper $Access])] } { continue }
	lappend LesBons $Access
    }
    Espionne $LesBons
    return $LesBons
}

proc RapportGroupeSecator Nom {
    global RepertoireDuGenome
    global RapportGroupeSecator


    if {[info exists RapportGroupeSecator($Nom)]} { return [set RapportGroupeSecator($Nom)] }
    if {[info exists RapportGroupeSecator("EstCharge")]} { return "-1 -1" }

    set FichierRapportGroupeSecator "$RepertoireDuGenome/fiches/rapportgroupesecator"
    if {[file exists $FichierRapportGroupeSecator]} {
	foreach Ligne [LesLignesDuFichier $FichierRapportGroupeSecator] {
	    scan $Ligne "%s %d %d" NomLu i n
	    set RapportGroupeSecator($NomLu) "$i $n"
	}
	set RapportGroupeSecator("EstCharge") 1
	return [RapportGroupeSecator $Nom]
    }
    foreach PAB [ListeDesPABs] {
	set MSF "$RepertoireDuGenome/msf/$PAB"
	if { ! [file exists $MSF]} {
	    set i 0
	    set n 0
	} else {	    
	    DecortiqueUnMSF $MSF LesNomsDeSequences
	    set LeGroupe [GroupeSecator $PAB $PAB "Out"]
	    set i [llength $LeGroupe]
	    set n [llength $LesNomsDeSequences]
	}
	AppendAuFichier $FichierRapportGroupeSecator "$PAB $i $n"
	set RapportGroupeSecator($PAB) "$i $n"
    }
    return [RapportGroupeSecator $Nom]    
}

proc TestRGS Nom {
    set LeGroupe [GroupeSecator $Nom $Nom "Out"]
    Espionne $LeGroupe
    Espionne [llength $LeGroupe]  
    Espionne [RapportGroupeSecator $Nom] 
    exit
    
}

proc GroupeSecator {NomOuMSFOuAutre {Query "SameAs"} {InOut "Out"} {Calculate ""} {OutFile ""}} {
    global GroupeSecator

    Wup "InOut can be In, Out or ToutLeMonde, ToutLeMondeAvecGroupe,"
    Wup "or AppendAuGroupeSecator if you want to complete the file groupesecator"
    Wup "OutFile can be a filename but it works only with ToCalculate."
  
    set OutQuery 0
    set Racine "TrululuTrala"

    if {$NomOuMSFOuAutre=="AppendAuGroupeSecator"} {
	set OnAppend 1
	set Nom "Bidon"
    } else {
	set OnAppend 0
    }
    set NomOuMSF $NomOuMSFOuAutre

    set MayBeMSF $NomOuMSF
    set Nom [file tail $NomOuMSF]
    if {[file exists $MayBeMSF] && (! [EstUnPAB $Nom] || $Query!="SameAs")} {
	set FichierMSF $MayBeMSF
	if { ! [regexp "^/" $FichierMSF]} { set FichierMSF "[pwd]/$MayBeMSF" }
	set Calculate "ToCalculate"
    }

    if {$Query=="" || $Query=="SameAs"} { set Query $Nom }
    set QueryEstNom [string equal -nocase $Query $Nom]

    set ToCalculate [string equal -nocase $Calculate "ToCalculate"]

    set OnVeutToutLeMonde 0
    set OnVeutToutLeMondeAvecGroupe 0

    set UnGroupe 1
    if {$InOut=="ToutLeMonde"} {
	set OnVeutToutLeMonde 1
	set UnGroupe 0
	set Query "CacheToiQueryQuOnNeTeTrouvePas"
	set ToCalculate 1
    } elseif {$InOut=="ToutLeMondeAvecGroupe"} {
	set OnVeutToutLeMondeAvecGroupe 1
	set UnGroupe 0
	set Query "CacheToiQueryQuOnNeTeTrouvePas"
	set ToCalculate 1
    } else {
	set OutQuery [string equal -nocase $InOut "Out"]
    }

    set QUERY [string toupper $Query]
    if { ! [info exists FichierMSF] || ! [file exists $FichierMSF]} {
	if {[info exists GroupeSecator($QUERY)]} {
	    set LeGroupe [set GroupeSecator($QUERY)]
	    if {$OutQuery} {
		return $LeGroupe
	    } else {
		return [lappend LeGroupe $Query]
	    }
	}
	if {$QueryEstNom && [info exists GroupeSecator("EstCharge")]} {
	    if {$OutQuery} {
		return {}
	    } else {
		return [list $Query]
	    }
	}
	
	set FichierGroupeSecator "[RepertoireDuGenome]/fiches/groupesecator"
	if { ! $ToCalculate && [file exists $FichierGroupeSecator]} {
	    foreach Ligne [LesLignesDuFichier $FichierGroupeSecator] {
		scan $Ligne "%s" NomLu
		set NOMLU [string toupper $NomLu]
		set GroupeSecator($NOMLU) [lrange [split [string trim $Ligne] " "] 1 end]
	    }
	    if { ! $OnAppend} {
		set GroupeSecator("EstCharge") 1
		return [GroupeSecator $Nom $Query $InOut]
	    }
	}
	
	if { $OnAppend || ! $ToCalculate && [OuiOuNonMemo "Do I create the file $FichierGroupeSecator ?" 0]} {
	    foreach PAB [ListeDesPABs] {
		
		if {[info exists GroupeSecator($PAB)]} { continue } 
		
		set FichierMSF "[RepertoireDuGenome]/msf/$PAB"
		if { ! [file exists $FichierMSF]} { continue }
		set PL [PremiereLigneDuFichier $FichierMSF]
		if {[regexp "Clustalw inutile|NoSequence" $PL]} { continue }
		
		set LeGroupe [GroupeSecator $PAB $PAB "Out" "ToCalculate"]
		set Texte "$PAB [join $LeGroupe " "]"
		AppendAuFichier $FichierGroupeSecator $Texte
		Espionne "I appended : $Texte"
	    }
	    return [GroupeSecator $Nom $Query $InOut]
	}
	
	set FichierMSF "[RepertoireDuGenome]/msf/$Nom"
	if { ! [file exists $FichierMSF]} { return {} }
    }

    set FichierSortie [Secator $FichierMSF]
    if {$FichierSortie==""} { return {} }
    regsub {\.[a-z]+$} $FichierSortie "" Racine

    set LeGroupe {}
    set OnLeTient 0
    set Numero -1
    foreach Ligne [LesLignesDuFichier $FichierSortie] {
	if { ! [regexp -nocase {[a-z]+} $Ligne] || [regexp -nocase "^Number of clusters" $Ligne]} { continue }
	if {[regexp -nocase {^Cluster [0-9]|^unclustered } $Ligne]} {
	    if { ! $OnVeutToutLeMondeAvecGroupe && ! $OnVeutToutLeMonde && $OnLeTient} { break }
	    set Numero ""
	    scan $Ligne "%s %s" Groupe Numero
	    if { ! [regexp {^[0-9]} $Numero]} { set Numero -1 }
	    set LeGroupe {}
	    continue
	}
	scan $Ligne "%s" Access
	if {[string toupper $Access]==[string toupper $Query]} {
	    set OnLeTient 1
	    if {$OutQuery} { continue }
	}
	lappend ToutLeMondeAvecGroupe "$Access $Numero" 
	lappend ToutLeMonde $Access
	lappend LeGroupe $Access
    }
    if {[regexp "tmp" $Racine]} {
	foreach Fichier [glob -nocomplain "$Racine*"] {
	    file delete $Fichier
	}
    }

    set Resultat $LeGroupe

    if {$OnVeutToutLeMonde}                  { set Resultat $ToutLeMonde }
    if {$OnVeutToutLeMondeAvecGroupe}        { set Resultat $ToutLeMondeAvecGroupe }
    if {$UnGroupe && $Groupe=="unclustered"} { set Resultat $ToutLeMonde }

    if {$OutFile==""} { return $Resultat }
    return [SauveLesLignes $Resultat dans $OutFile]
}

proc LesClustersDeCluspack {TexteOuFichier {GetIt ""}} {

    if {$GetIt==""} { set GetIt "GetGroupsAndMembers" }

    if {[regexp "\n" TexteOuFichier]} {
	set Texte $TexteOuFichier
    } else {
	set Texte [ContenuDuFichier $TexteOuFichier]
    }

    Espionne $Texte

    set ToutLeMondeAvecGroupe {}
    set LesGroupesEtLeursMembres {}

    set LesGroupes {}
    set LesMembres {}
    set OnLeTient 0
    append Texte "\nThatsAllFolks"
    foreach Ligne [split $Texte "\n"] {
	if { ! [regexp -nocase {[a-z]+} $Ligne] || [regexp -nocase "^Number of clusters" $Ligne]} {
	    continue
	}
	if {[regexp -nocase {^Cluster [0-9]|^unclustered seq} $Ligne] | $Ligne=="ThatsAllFolks"} {
	    set Numero ""
	    scan $Ligne "%s %s" Groupe Numero
	    if { ! [regexp {^[0-9]} $Numero]} { set Numero -1 }
	    if {[info exists NumeroCourant]} {
		lappend LesGroupesEtLeursMembres [list $NumeroCourant $LesMembres] 
		if {$Ligne=="ThatsAllFolks"} { break }
		set LesMembres {}
	    }
	    set NumeroCourant $Numero
	    continue
	}
	scan $Ligne "%s" Access
	lappend ToutLeMondeAvecGroupe "$Access $Numero" 
	lappend LesMembres $Access
    }
    if {$GetIt=="GetGroupsAndMembers"} { return $LesGroupesEtLeursMembres }
    if {$GetIt=="GetAllWithGroup"}     { return $ToutLeMondeAvecGroupe }
    return [list $ToutLeMondeAvecGroupe $LesGroupesEtLeursMembres]
}

proc Cluspack {ListeOuTexteOuFichier {FichierSortie ""}} {
    #rR j'ail'impression que ce n'est pas pour un alignement ... mais pour un fichier de coordonnees.

    if {$FichierSortie==""} { set FichierSortie "GetGroupsAndMembers" }

    if {[regexp "\n" $ListeOuTexteOuFichier]} {
	set Liste [split $ListeOuTexteOuFichier "\n"]
    } elseif { ! [regexp " " $ListeOuTexteOuFichier]} {
	set Liste [LesLignesDuFichier $ListeOuTexteOuFichier]
    } else {
	set Liste $ListeOuTexteOuFichier
    }

    set nL 0
    set nCOld -1
    foreach Ligne $Liste {
	incr nL
	set nC [expr [llength $Ligne] - 1]
	if {$nCOld==-1} { set nCOld $nC }
	if {$nC!=$nCOld} { FaireLire "Missing values in line $Ligne for Cluspack" }
    }
    set LeTexte {}
    lappend LeTexte "$nL $nC"
    lappend LeTexte ""
    LConcat LeTexte $Liste
    NousAllonsAuBoulot
    set Racine "[TmpFile Cluspack]"
    regsub -all {\.} $Racine "_" Racine
    set FichierSecatorIn [SauveLesLignes $LeTexte dans "$Racine.in"]
#   set ExecutableCluspack "/biolo/secator/cluspack"
    set ExecutableCluspack "/biolo/cluspack/binNew/cluspack"
    if {[catch {exec $ExecutableCluspack $FichierSecatorIn \
		    -data_type=coordinates -clustering_method=ward -nb_clusters=secator} Message]} {
	FaireLire "cluspack failed with message\n $Message"
	return ""
    }
    set FichierSecatorOut "$Racine.clu"
    if { ! [file exists $FichierSecatorOut]} { return "" }
    if {$FichierSortie=="GetAsIs"} {
	set Sortie [ContenuDuFichier $FichierSecatorOut]
    } elseif {$FichierSortie=="GetGroupsAndMembers"} {
	set Sortie [LesClustersDeCluspack $FichierSecatorOut "GetGroupsAndMembers"]
    } elseif {$FichierSortie=="GetAllWithGroup"} {
	set Sortie [LesClustersDeCluspack $FichierSecatorOut "GetAllWithGroup"]
    } else {
	file copy $FichierSecatorOut $FichierSortie
	set Sortie $FichierSortie
    }
    if {[file exists "$Racine.in"]}  { file delete "$Racine.in" }
    if {[file exists "$Racine.clu"]} { file delete "$Racine.clu" }
    OnRevientDuBoulot
    return $Sortie
}

proc GroupeDpc {Nom {Query "SameAs"} {InOut "Out"}} {
    global GroupeDpc

    Wup "Attention GroupeDpc ne calcule pas il ne donne que la valeur"
    Wup "il faut avoir fait GroupeSecator en positionnant ExecutableSecator a dpc"
    Wup "Ca devrait marcher si il y a le FichierSortieDpc"

    set OnAppend 0

    if {$Query=="" || $Query=="SameAs"} { set Query $Nom }
    set QueryEstNom [string equal -nocase $Query $Nom]

    set OnVeutToutLeMonde 0
    set OnVeutToutLeMondeAvecGroupe 0

    if {$InOut=="ToutLeMonde"} {
	set OnVeutToutLeMonde 1
	set Query "CacheToiQueryQuOnNeTeTrouvePas"
    } elseif {$InOut=="ToutLeMondeAvecGroupe"} {
	set OnVeutToutLeMondeAvecGroupe 1
	set Query "CacheToiQueryQuOnNeTeTrouvePas"
    } else {
	set OutQuery [string equal -nocase $InOut "Out"]
    }

    set QUERY [string toupper $Query]
    if {[info exists GroupeDpc($QUERY)]} {
	set LeGroupe [set GroupeDpc($QUERY)]
	if {$OutQuery} {
	    return $LeGroupe
	} else {
	    return [lappend LeGroupe $Query]
	}
    }
    if {$QueryEstNom && [info exists GroupeDpc("EstCharge")]} {
	if {$OutQuery} {
	    return {}
	} else {
	    return [list $Query]
	}
    }
    
    set FichierGroupeDpc "[RepertoireDuGenome]/fiches/groupedpc"
    if {[file exists $FichierGroupeDpc]} {
	foreach Ligne [LesLignesDuFichier $FichierGroupeDpc] {
	    scan $Ligne "%s" NomLu
	    set NomLu [string toupper $NomLu]
	    set GroupeDpc($NomLu) [lrange [split [string trim $Ligne] " "] 1 end]
	}
	if { ! $OnAppend} {
	    set GroupeDpc("EstCharge") 1
	    return [GroupeDpc $Nom $Query $InOut]
	}
    }
    
    set LeGroupe {}
    set OnLeTient 0
    set FichierSortieDpc "[RepertoireDuGenome]/dpc/$Nom"
    if { [FileAbsent $FichierSortieDpc] } {
	foreach Ext [list ".dpc" ".clu"] {
	    set Possible $FichierSortieDpc$Ext
	    if {[FileExists $Possible]} { set FichierSortieDpc $Possible ; break }
	}
	append FichierSortieDpc ".dpc"
    }
    if { [FileAbsent $FichierSortieDpc] } { return {} }
    foreach Ligne [LesLignesDuFichier $FichierSortieDpc] {
	if { ! [regexp -nocase {[a-z]+} $Ligne] || [regexp -nocase "^Number of clusters" $Ligne]} { continue }
	if {[regexp -nocase {^Cluster [0-9]|^unclustered seq} $Ligne]} {
	    if {$OnLeTient} { break }
	    set Numero ""
	    scan $Ligne "%s %s" Groupe Numero
	    if { ! [regexp {^[0-9]} $Numero]} { set Numero -1 }
	    set LeGroupe {}
	    continue
	}
	scan $Ligne "%s" Access
	if {[string toupper $Access]==[string toupper $Query]} {
	    set OnLeTient 1
	    if {$OutQuery} { continue }
	}
	lappend ToutLeMondeAvecGroupe "$Access $Numero" 
	lappend ToutLeMonde $Access
	lappend LeGroupe $Access
    }

    if {$OnVeutToutLeMonde} { return $ToutLeMonde }
    if {$OnVeutToutLeMondeAvecGroupe} { return $ToutLeMondeAvecGroupe }
    if {$Groupe=="unclustered"} {
	return $ToutLeMonde
    } else {
	return $LeGroupe
    }
}

proc GroupeOumy {Nom {Query "SameAs"} {InOut "Out"}} {
    global GroupeOumy

    Wup "Attention GroupeOumy ne calcule pas il ne donne que la valeur"
    Wup "il faut avoir fait GroupeSecator en positionnant ExecutableSecator a Oumy"
    Wup "Ca devrait marcher si il y a le FichierSortieOumy"

    set OnAppend 0

    if {$Query=="" || $Query=="SameAs"} { set Query $Nom }
    set QueryEstNom [string equal -nocase $Query $Nom]

    set OnVeutToutLeMonde 0
    set OnVeutToutLeMondeAvecGroupe 0

    if {$InOut=="ToutLeMonde"} {
	set OnVeutToutLeMonde 1
	set Query "CacheToiQueryQuOnNeTeTrouvePas"
    } elseif {$InOut=="ToutLeMondeAvecGroupe"} {
	set OnVeutToutLeMondeAvecGroupe 1
	set Query "CacheToiQueryQuOnNeTeTrouvePas"
    } else {
	set OutQuery [string equal -nocase $InOut "Out"]
    }

    set QUERY [string toupper $Query]
    if {[info exists GroupeOumy($QUERY)]} {
	set LeGroupe [set GroupeOumy($QUERY)]
	if {$OutQuery} {
	    return $LeGroupe
	} else {
	    return [lappend LeGroupe $Query]
	}
    }
    if {$QueryEstNom && [info exists GroupeOumy("EstCharge")]} {
	if {$OutQuery} {
	    return {}
	} else {
	    return [list $Query]
	}
    }
    
    set FichierGroupeOumy "[RepertoireDuGenome]/fiches/groupeoumy"
    if {[file exists $FichierGroupeOumy]} {
	foreach Ligne [LesLignesDuFichier $FichierGroupeOumy] {
	    scan $Ligne "%s" NomLu
	    set NomLu [string toupper $NomLu]
	    set GroupeOumy($NomLu) [lrange [split [string trim $Ligne] " "] 1 end]
	}
	if { ! $OnAppend} {
	    set GroupeOumy("EstCharge") 1
	    return [GroupeOumy $Nom $Query $InOut]
	}
    }
    
    set LeGroupe {}
    set OnLeTient 0
    set FichierSortieOumy "[RepertoireDuGenome]/Oumy/$Nom"
    if { ! [file exists $FichierSortieOumy]} { append FichierSortieOumy ".Oumy" }
    if { ! [file exists $FichierSortieOumy]} { return {} }
    foreach Ligne [LesLignesDuFichier $FichierSortieOumy] {
	if { ! [regexp -nocase {[a-z]+} $Ligne] || [regexp -nocase "^Number of clusters" $Ligne]} { continue }
	if {[regexp -nocase {^Cluster [0-9]|^unclustered seq} $Ligne]} {
	    if {$OnLeTient} { break }
	    set Numero ""
	    scan $Ligne "%s %s" Groupe Numero
	    if { ! [regexp {^[0-9]} $Numero]} { set Numero -1 }
	    set LeGroupe {}
	    continue
	}
	scan $Ligne "%s" Access
	if {[string toupper $Access]==[string toupper $Query]} {
	    set OnLeTient 1
	    if {$OutQuery} { continue }
	}
	lappend ToutLeMondeAvecGroupe "$Access $Numero" 
	lappend ToutLeMonde $Access
	lappend LeGroupe $Access
    }

    if {$OnVeutToutLeMonde} { return $ToutLeMonde }
    if {$OnVeutToutLeMondeAvecGroupe} { return $ToutLeMondeAvecGroupe }
    if {$Groupe=="unclustered"} {
	return $ToutLeMonde
    } else {
	return $LeGroupe
    }
}