#rR gscope_outsiders.tcl  lesproc qui ne servent qu'une fois

proc RhIcube {} {
    set Warne 0
    NousAllonsAuBoulot "/home/ripp/rh"
    set FicIcube "TabIcube_utf8.csv"
    set FicUnist "TabUnist_utf8.csv"
    
    LoadTxl $FicIcube Icube -1 ";"
    LoadTxl $FicUnist Unist -1 ";"
    
    foreach I $Icube(ListOf,Index) {
	set Icube($I,Prenom)    [string totitle $Icube($I,Prenom)]
	set Icube($I,Nom)       [string totitle $Icube($I,Nom)]
	set Icube($I,MailIcube) [string tolower $Icube($I,Mail)]
	regsub {@icube\.} $Icube($I,MailIcube) "@" Icube($I,Mail)     ; #rR LMailIcube est machin.chose@icube.unistra.fr mais on vire icube.	
    }
    
    foreach I $Unist(ListOf,Index) {
	set Unist($I,ActionOriginal) $Unist($I,Action)
	set Unist($I,PrenomOriginal) $Unist($I,Prenom)
	set Unist($I,NomOriginal)    $Unist($I,Nom)
	set Unist($I,MailOriginal)   $Unist($I,Mail)
	set Unist($I,Prenom) [string totitle $Unist($I,Prenom)]
	set Unist($I,Nom)    [string totitle $Unist($I,Nom)]
	set Unist($I,Mail)   [string tolower $Unist($I,Mail)]
    }
    
    foreach I $Icube(ListOf,Index) {
	set Prenom    $Icube($I,Prenom)
	set Nom       $Icube($I,Nom)
	set PN        "$Prenom-$Nom"
	set Mail      $Icube($I,Mail)
	set MailIcube $Icube($I,MailIcube)
	set All "$I/$Prenom/$Nom/$Mail/$MailIcube"
	set Icube($I,PN)  $PN
	set Icube($I,All) $All
	
	if {[info exists Icube($Mail,All)]} { FaireLire "Deja vu $Mail \n $Icube($Mail,All)" ; continue }
	lappend LesMailsIcube $Mail
	set Icube($Mail,Prenom)    $Prenom
	set Icube($Mail,Nom)       $Nom
	set Icube($Mail,PN)        $PN
	set Icube($Mail,Mail)      $Mail
	set Icube($Mail,MailIcube) $MailIcube
	set Icube($Mail,All)       $All
	
	if {[info exists Icube($PN,All)]} { FaireLire "Dejavu Icube $PN $Mail $Icube($PN,All)" }
	lappend Icube($PN,Prenom)    $Prenom
	lappend Icube($PN,Nom)       $Nom
	lappend Icube($PN,PN)        $PN
	lappend Icube($PN,Mail)      $Mail
	lappend Icube($PN,MailIcube) $MailIcube
	lappend Icube($PN,All)       "$I/$Prenom/$Nom/$Mail/$MailIcube"
	lappend LesPnIcube $PN
    }
    
    foreach I $Unist(ListOf,Index) {
	set Prenom    $Unist($I,Prenom)
	set Nom       $Unist($I,Nom)
	set PN        "$Prenom-$Nom"
	set Mail      $Unist($I,Mail)
	set All       "$I/$Prenom/$Nom/$Mail"
	set Unist($I,PN)  $PN
	set Unist($I,All) $All

	if {[info exists Unist($Mail,All)]} { if {$Warne} { FaireLire "Deja vu $Mail \n $Unist($Mail,All)" } ; continue }
	lappend LesMailsUnist $Mail
	set Unist($Mail,Prenom)    $Prenom
	set Unist($Mail,Nom)       $Nom
	set Unist($Mail,PN)        $PN
	set Unist($Mail,Mail)      $Mail
	set Unist($Mail,All)       $All
	
	if {[info exists Unist($PN,All)]} { if {$Warne} { FaireLire "Dejavu Unist $PN $Mail $Unist($PN,All)" } }
	lappend Unist($PN,Prenom)    $Prenom
	lappend Unist($PN,Nom)       $Nom
	lappend Unist($PN,PN)        $PN
	lappend Unist($PN,Mail)      $Mail
	lappend Unist($PN,All)       $All
	lappend LesPnUnist $PN
    }
    
    set LeCsv {}
    foreach I $Unist(ListOf,Index) {
	set Mail $Unist($I,Mail)
	set All  $Unist($I,All)
	set PN   $Unist($I,PN)
	set Unist($I,MailFromIcube) ""
	set Unist($I,IsIcube) "....."
	if {[info exists Icube($Mail,All)]} {
	    set Unist($I,IsIcube) "ICube"
	    set MailFromIcube $Icube($Mail,Mail)
	    if {$MailFromIcube==$Mail} {
		set Unist($I,MailFromIcube) "idem avec icube."
	    } else {
		set Unist($I,MailFromIcube) $MailFromIcube
	    }
	} else {
	    if {[info exists Icube($PN,All)]} {
		set Unist($I,IsIcube) "ICube"
		set MailFromIcube $Icube($PN,Mail)
		if {$MailFromIcube==$Mail} {
		    set Unist($I,MailFromIcube) "idem avec icube."
		} else {
		    set Unist($I,MailFromIcube) $MailFromIcube
		}
	    }
	}
	set Affectation $Unist($I,ActionOriginal)
	if {$Unist($I,IsIcube)=="ICube"} { set Affectation "Icube" }
	set Prenom $Unist($I,PrenomOriginal)
	set Nom    $Unist($I,NomOriginal)
	set Mail   $Unist($I,MailOriginal)
	set MailFromIcube $Unist($I,MailFromIcube)
	set Ligne "$Affectation;$Prenom;$Nom;$Mail;$MailFromIcube"
	Espionne $Ligne
	lappend LeCsv "$Affectation;$Prenom;$Nom;$Mail;$MailFromIcube"
    }
    set FicNew [SauveLesLignes $LeCsv dans UNISTRA_new.csv]
    OnRevientDuBoulot
    return $FicNew
    exit
    
    foreach Mail $LesMailsUnist {
	if { ! [info exists ICube($Mail,Mail)]} { continue }
	#Espionne $Mail $Unist($Mail,Prenom) $Unist($Mail,Nom) ==== $Icube($Mail,Prenom) $Icube($Mail,Nom)  
    }
    
    foreach Mail $LesMailsIcube {
	if { ! [info exists DejaVuUnist($Mail)]} {
	    set Prenom $Icube($Mail,Prenom)
	    set Nom    $Icube($Mail,Nom)
	    set PN "$Prenom-$Nom"
	    set Plus ""
	    if {[info exists Unist($PN,All)]} { 
		set Plus "ou alors [join $Unist($PN,All) /]"
		regsub unistra $Mail icube.unistra MailIcube
		Espionne Dans Icube $Prenom $Nom $MailIcube  mais Manque Unistra $Plus
		set ManqueMailIcubeDansUnist($Mail) 1
	    } else {
		continue
	    }
	    Espionne $Mail $Icube($Mail,Prenom) $Icube($Mail,Nom) 
	}
	
    }
    exit
    foreach PN $LesPnIcube {
	if {[info exists Unist($PN,All)]} {
	    Espionne $Icube($PN,All) ==================== $Icube($PN,Mail) $Unist($PN,All) $Icube($PN,Mail)
	} else {
	    Espionne $Icube($PN,All)
	}
    }
    
    #Espionne $LesMailsIcube
    #Espionne $LesMailsUnist
    OnRevientDuBoulot
}

proc VerifieBlastProGS {} {
    #rR il manquait les PGSxxx en debut de ces fichiers
    set LesBad {}
    foreach Nom [ListeDesPABs] {
	set Fichier [GscopeFile $Nom "blastp"]
	if {[FileAbsent $Fichier]} { lappend LesBad "$Nom absent"; continue }
	set Blast [ContenuDuFichier $Fichier]
	set Q [StringApres "Query=" dans $Blast]
	if {$Q==$Nom} { continue }
	lappend LesBad "$Nom $Q"
	regsub "Query= " $Blast "Query= $Nom " NewBlast
	Espionne [string range $NewBlast 0 400]
	Sauve $NewBlast dans $Fichier
    }
    AfficheListe $LesBad
}

proc VerifieTfaProGS {} {
    #rR il manquait les PGSxxx en debut de ces fichiers
    set LesBad {}
    foreach Nom [ListeDesPABs] {
	set Fichier [GscopeFile $Nom "prottfa"]
	if {[FileAbsent $Fichier]} { lappend LesBad "$Nom absent"; continue }
	set TFA [ContenuDuFichier $Fichier]
	if {[regexp ">$Nom" $TFA]} { continue }
	scan $TFA "%s" A
	set A [string range $A 1 end]
	regsub ">" $TFA ">$Nom " NewTFA
	Espionne $NewTFA
#	Sauve $NewTFA dans $Fichier
    }
    AfficheListe $LesBad
}

proc VerifieGscopeGagniere {} {
    set LesManquants {}
    foreach F [glob "/home/gagniere/gscoperso/*.tcl"] {
	Espionne $F
	foreach Ligne [LesLignesDuFichier $F] {
	    if { ! [regexp {^proc ([^ \{]+)} $Ligne Match P]} { continue }
	    if {[info procs $P]!=""} { break }
	    lappend LesManquants $P
	}
    }
    AfficheListe $LesManquants
}


proc Frechin {} {
    foreach Ligne [LesLignesVitales AllGat.txt] {
	if {[regexp ".txt" $Ligne]} {
	    set Ftxt $Ligne
	    continue
	}
	scan $Ligne "%s" Access
	set Seq [QueLaSequenceDuFichierTFA $Ftxt]
	set TFA [SequenceFormatTFA $Seq $Ligne "nucbrut"]
	Espionne $TFA
	Sauve $TFA dasn "$Access.tfa"
	lappend LesNouveaux "$Access /genomics/link/ProGS/atelier/Frechin/$Access.tfa"
    }
    return $LesNouveaux
}

proc DmelTransMem {} {
    foreach Fichier [glob "/home/poch/transmbn/AE*"] {
	set OnAttendGi 1
	set OnAttendHP 0
	set Descript ""
	set HP ""
	set PNT -1
	set LaSeq ""
	set L 9999
	foreach Ligne [LesLignesDuFichier $Fichier] {
	    Espionne $Ligne
	    if { ! [regexp -nocase {[A-Z0-9]} $Ligne]} { continue }
	    if {[regexp "Helices Position" $Ligne]} {
		set OnAttendHP 1
		continue
	    }
	    if {[regexp "Predicted Number" $Ligne]} {
		set PNT [IntegerApres ":" dans $Ligne]
		continue
	    }
	    if {$OnAttendHP} {
		if { ! [regexp {^[0-9\,\-]+$} $Ligne]} {
		    FaireLire "$Ligne\nis not a helix position line in\n$Fichier"
		    set HP ""
		} else { 
		    set HP $Ligne
		}
		set OnAttendHP 0
		continue
	    }
	    if {[regexp {^gi\|} $Ligne]} {
		if {$OnAttendGi} { set OnAttendGi 0 ; continue }
		set Sequence [join $LaSeq ""]
		if {[string length $Sequence]!=$L} {
		    FaireLire "$Sequence \nis not ok. != $L"
		}
		CreeTfaDmelTransMem $Descript $Sequence $HP $PNT
		set Descript ""
		set HP ""
		set PNT -1
		set LaSeq ""

		regsub {gi\|} $Ligne "gi:" Ligne
		regsub {\|gb\|} $Ligne " gb:" Ligne
		regsub -all {\|} $Ligne "" Ligne
		set Descript $Ligne
		continue
	    }
	    if {$OnAttendGi} { continue }
	    if {[regexp {Sequence Length\:} $Ligne]} {
		set L [IntegerApres ":" dans $Ligne ]
		continue
	    }
	    if {[regexp -nocase {[^A-Z]} $Ligne]} {
		if { ! [regexp -nocase {[a-z]*\]} $Ligne]} {
		    FaireLire "$Ligne\n is not a sequence\n ... see $Fichier"
		}
		append Descript $Ligne
		continue
	    }
	    lappend LaSeq $Ligne
	}
	CreeTfaDmelTransMem $Descript $Sequence $HP $PNT
     }
}

proc GeneNameDeLaListe Fichier {
    set LesAccessAliasDefinition {} 
    foreach Ligne [LesLignesDuFichier $Fichier] {
	if { ! [regexp -nocase {[a-z]} $Ligne]} {continue}
	scan $Ligne "%s" Access
	set LesLignesEMBL [LaSequenceDesBanques $Access "OnVeutEMBL"]
	set EMBL [join $LesLignesEMBL "\n"]
	set ChampsInteressants [ChampsInteressantsDansTexteEMBL $EMBL]
	set GN ""
	set DE ""
	set LaDE {}
	foreach Champ [split $ChampsInteressants "\n"] {
	    if {[regexp "^GN  " $Champ]} {
		set GN [VraiGNDeLaLigneGN $Champ]
	    }
	    if {[regexp "^DE  " $Champ]} {
		regsub "^DE *" $Champ "" DE
		lappend LaDE $DE
	    }
	}
	set DE [join $LaDE " "]
	Espionne "$Access $GN $DE"
	lappend LesAccessAliasDefinition "$Access $GN $DE"
    }
    Espionne [SauveLesLignes $LesAccessAliasDefinition dans "[HomeRipp]/MS2PH.txt"]
}

proc SupprimeLesFantomesDuTBlastN {} {
    foreach Nom [ListeDesPABs] {
	if { ! [Fantome $Nom]} {continue}
	set Fichier "[RepertoireDuGenome]/tblastnmyself/$Nom"
	if { ! [file exists $Fichier]} {continue}
	file rename $Fichier "[RepertoireDuGenome]/tblastnmyselffantomes/$Nom"
    }
    exit
}

proc SupprimeLesFantomesDeOuATapeTBN {} {
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/ouatapetbn.myself"] {
	scan $Ligne "%s" Nom
	if {[Fantome $Nom]} {
	    lappend LesFantomes $Ligne
	    continue
	}
	lappend LesBons $Ligne
    }
    SauveLesLignes $LesBons dans "[RepertoireDuGenome]/fiches/ouatapetbn.myself"
    SauveLesLignes $LesFantomes dans "[RepertoireDuGenome]/fiches/ouatapetbn.myselffantomes"
    exit
}

proc CorrigeOuATapeTBlastN {} {
    foreach Ligne [LesLignesDuFichier "[RepertoireDuGenome]/fiches/ouatapetbn.myself"] {
	if { ! [regexp ">" $Ligne]} {continue}
	lappend LeNeuf $Ligne
    }
    SauveLesLignes $LeNeuf dans "[RepertoireDuGenome]/fiches/ouatapetbn.myself"
    exit
}