#rR gscope_topographe.tcl

proc BanbiDir {{NewValue ""}} {
    global BanbiDir
    if {$NewValue!=""} { set ::BanbiDir $NewValue }
    if { ! [info exists ::BanbiDir]} {
	if {[info exists env(BANBIDIR)]} {
	    set ::BanbiDir $env(BANBIDIR)
	} else {
	    set ::BanbiDir "/commun/banbi"
	}
    }
    return $::BanbiDir
}

proc VersionDeGscope {} {
    global VersionDeGscope 
    set VersionDeGscope 2021.12
    return $VersionDeGscope
}

proc VersBiolo {{Qui ""}} {
    set Date [Date]
    set LesLogin {}
    foreach Destin [glob -nocomplain -type d "/biolo/gscope_contrib/*"] {
	if {$Qui!="" && [file tail $Destin]!=$Qui} { continue }
	Espionne $Destin
	if { [file type $Destin]!="directory" } { continue }
	set Login [file tail $Destin]
	set Source "/home/$Login/gscopublic"
	if { ! [file exists $Source]} { continue }

	set DestinOld "/biolo/gscope_contrib/Poubelle/$Login.$Date"
	set DestinTmp "${Destin}_Tmp"

	file mkdir $DestinTmp
	file copy -force $Source $DestinTmp

	file rename  $Destin                $DestinOld
	file rename "$DestinTmp/gscopublic" $Destin
	exec chmod -R g+w $Destin 
	file delete  $DestinTmp
	lappend LesLogin $Login
    }
    return $LesLogin
}


proc ConfigureGscopersoGscopublic {} {
    global env

    set Login $env(LOGNAME)
    set HomeDir $env(HOME)

    if { ! [OuiOuNon "You are $Login, your home directory is $HomeDir\nOk to configure gscoperso and gscopublic ?"]} { return "" }

    set LesCrees {}

    set DirPerso  "$HomeDir/gscoperso"   ; file mkdir $DirPerso
    set SourcePerso "$DirPerso/gscope_source.tcl"
    if {[file exists $SourcePerso]} {
        FaireLire "$SourcePerso already exists. I'll do nothing new for gscoperso"
    } else {
        set PersoTest "$DirPerso/gscope_test.tcl"
        set  LaProc {} 
        lappend LaProc "# gscoperso/gscope_test.tcl to try my procedure in safe mode."
        lappend LaProc "#rR N'oubliez pas de copier les proc qui tournent et qui sont pour tout le monde dans un de vos fichiers gscope_chose.tcl de gscopublic"
        lappend LaProc "proc Test \{A \{B \"\"\}\} \{"
        lappend LaProc "    puts \"This is my first procedure\""
        lappend LaProc "    puts \"First argument A is \$A\""
        lappend LaProc "    puts \"Second argument B is \$B\""
        lappend LaProc "    return \"Hello from $::env(HOME)/gscoperso\""
        lappend LaProc "\}"
        SauveLesLignes $LaProc dans $PersoTest
        set LeSource {}
        lappend LeSource "# gscoperso/gscope_source.tcl est sourcé en dernier par gscope"
        lappend LeSource "source $DirPerso/gscope_test.tcl"
        lappend LeSource ""
        SauveLesLignes $LeSource dans $SourcePerso
        Espionne "j'ai créé $SourcePerso qui source $PersoTest"
        lappend LesCrees $SourcePerso $PersoTest
    }

    set DirPublic "$HomeDir/gscopublic"  ; file mkdir $DirPublic
    set SourcePublic "$DirPublic/gscope_$Login.tcl"
    if {[file exists $SourcePublic]} {
        FaireLire "$SourcePublic already exists. I'll do nothing new for gscopublic"
    } else {
        set PublicCooperate "$DirPublic/gscope_cooperate.tcl"
        set LaProc {}
        lappend LaProc "proc HelloFrom$Login \{\} \{"
        lappend LaProc "    return \"Hello from $Login\""
        lappend LaProc "\}"
        SauveLesLignes  $LaProc dans $PublicCooperate
        set LeSource {}
        lappend LeSource "# gscopublic/gscope_$Login.tcl est sourcé par gscope"
        lappend LeSource "source \$GscopeContrib/gscope_cooperate.tcl"
        lappend LeSource ""
        SauveLesLignes $LeSource dans $SourcePublic
        Espionne "j'ai créé $SourcePublic qui source $PublicCooperate"

        Espionne "Pour sourcer un autre fichier dans gscope_$Login.tcl"
        Espionne " ... il faut toujours utiliser source \$GscopeContrib/gscope_autre.tcl"
        Espionne "Merci"
        lappend LesCrees $SourcePublic $PublicCooperate
    }

    FaireLire "Attention pour que le gscopublc soit pris en compte \n il faut rajoute $Login dans /home/ripp/gscope/gscope_source.tcl\n(voir Arnaud, Laetitia ou Luc)"

    return $LesCrees
}

proc ProjetGscope {} {
    return [file tail [RepertoireDuGenome]]
}

proc InfoScript {} {
    global InfoScript
    if {[info exists InfoScript]} { return $InfoScript }
    return ""
}

proc SetOnTraiteLike {Quoi {RG ""}} {
    if {$RG!=""} {
	if {[FileAbsent $RG]} {
	    set RG [GscopeDatabaseDir $RG]
	}
    }
    if {$RG==""} { set RG [RepertoireDuGenome] }
    return [AppendAuFichier "$RG/beton/miniconfig" "OnTraiteLike $Quoi"]
}

proc OnTraite {Quoi {Comment ""}} {
    if {$Comment==""} { set Comment "Strict" }
    if {$Comment=="Strict"} { return [regexp "/$Quoi$" [RepertoireDuGenome]] }
    if {$Comment=="Like"  } {
	if {[FileAbsent "[RepertoireDuGenome]/beton/miniconfig"]} { return 0 }
	return [regexp "OnTraiteLike $Quoi" [ContenuDuFichier "[RepertoireDuGenome]/beton/miniconfig"]]
    }
    return [regexp $Quoi [RepertoireDuGenome]]
	
}

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

proc OnTraitePuzzleFit {} {
    return [regexp "/PFhuman" [RepertoireDuGenome]]
}

proc OnTraiteUCSCGenomes {} {
    return [regexp "UCSCGenomes" [RepertoireDuGenome]]
}

proc OnTraiteSpine {} {
    return [string equal [PreFixe] "SPINE"]
}

proc OnTraiteRetGene {} {
    return [regexp -nocase "RetGene" [RepertoireDuGenome]]
}

proc OnTraiteGGmm {} {
    return [regexp -nocase "\GGmm$" [RepertoireDuGenome]]
}

proc OnTraiteGGWmm {} {
    return [regexp -nocase "\GGWmm$" [RepertoireDuGenome]]
}

proc OnTraiteEVImm {} {
    return [regexp -nocase "EVImm" [RepertoireDuGenome]]
}

proc OnTraiteSpliRet {} {
    return [regexp -nocase "SpliRet" [RepertoireDuGenome]]
}

proc OnTraiteSpliRetMouse {} {
    return [regexp -nocase "SpliRetMouse" [RepertoireDuGenome]]
}

proc OnTraiteSpliRetRat {} {
    return [regexp -nocase "SpliRetRat" [RepertoireDuGenome]]
}

proc OnTraiteTroisPrima {} {
    return [regexp -nocase "TroisPrima" [RepertoireDuGenome]]
}

proc OnTraiteGGhs {} {
    return [regexp -nocase "\GGhs$" [RepertoireDuGenome]]
}

proc OnTraiteGGWhs {} {
    return [regexp -nocase "\GGWhs$" [RepertoireDuGenome]]
}

proc OnTraiteEVIhs {} {
    return [regexp -nocase "EVIhs" [RepertoireDuGenome]]
}

proc OnTraiteGenoretGenes {} {
    return [expr [OnTraiteGGmm] || [OnTraiteGGWmm] || [OnTraiteEVImm] || [OnTraiteGGhs] || [OnTraiteGGWhs] || [OnTraiteEVIhs]]
}

proc OnTraiteMS2PH {} {
    return [regexp -nocase "MS2PH|TriBlast|NewPDBSet" [RepertoireDuGenome]]
}

proc OnTraitePeroxisome {} {
    return [regexp -nocase "Perox" [RepertoireDuGenome]]
}

proc OnTraiteBalibase {} {
    return [regexp -nocase "Balibase" [RepertoireDuGenome]]
}

proc OnTraiteGscopeClonage {} {
    return [regexp "ProGS" [RepertoireDuGenome]]
}

proc OnTraiteDesClones {} {
    global GenomeOuCollection

    if {[regexp "Alvi50" [RepertoireDuGenome]]} { return 1 }
    if { ! [info exists GenomeOuCollection]} { return 0 } 
    return [regexp -nocase "Clones" $GenomeOuCollection]
}

proc OnTraiteDesAffymetrix {} {
    global GenomeOuCollection

    if { ! [info exists GenomeOuCollection]} { return 0 } 
    return [regexp -nocase "Affymetrix" $GenomeOuCollection]
}

proc OnTraiteDesCDNAs {} {
    global GenomeOuCollection

    if { ! [info exists GenomeOuCollection]} { return 0 } 
    return [regexp -nocase "CDNA" $GenomeOuCollection]
}

proc OnTraiteDesCDS {} {
    global GenomeOuCollection

    if { ! [info exists GenomeOuCollection]} { return 0 } 
    return [regexp -nocase "CDS" $GenomeOuCollection]
}

proc OnTraiteDesCDSProtFoF {} {
    global GenomeOuCollection

    if { ! [info exists GenomeOuCollection]} { return 0 } 
    return [regexp -nocase "CDS with protein in a FoF" $GenomeOuCollection]
}

proc OnTraiteDesNucleotides {} {
    global GenomeOuCollection

    if { ! [info exists GenomeOuCollection]} { return 0 } 
    if { [regexp -nocase "DNA" $GenomeOuCollection]} { return 1 }
    if { [regexp -nocase "Protein" $GenomeOuCollection]} { return 0 }
    if { [set R [OuiOuNonMemo "Do we handle DNA ?"]]} { return $R }
    return 0
}

proc OnTraiteDesProteines {} {
    global GenomeOuCollection

    if { ! [info exists GenomeOuCollection]} { return 0 } 
    if { [regexp -nocase "protein" $GenomeOuCollection]} { return 1 }
    if { [set R [OuiOuNonMemo "Do we handle only proteins (with no nuc seq)?"]]} { return $R }
    return 0
}

proc OnTraiteUneCollection {} {
    global GenomeOuCollection

    if { ! [info exists GenomeOuCollection]} { return 0 } 
    return [regexp -nocase "Collection" $GenomeOuCollection]
}

proc OnTraiteUnGenome {} {
    global GenomeOuCollection

    if { ! [info exists GenomeOuCollection]} { return 0 } 
    return [regexp -nocase "Genome" $GenomeOuCollection]
}

proc Moucharde {} {
	return
    set f [open "~/mouchard" w]
    puts $f [info nameofexecutable]
    puts $f [package require http]

    if {[catch {set PTcl [package require Tcl]} MTcl]} {
	puts $f "No Tcl Package : I got message\n$MTcl"
    } else {
	puts $f "Package Tcl $PTcl"
    }
#    if {[catch {set PTk [package require Tk]} MTk]} {
#	puts $f "No Tk Package : I got message\n$MTk"
#    } else {
#	puts $f "Package Tk $PTk"
#    }
    close $f
}


proc GenomicsLinks {{DoIt ""}} {
    if {$DoIt==""} { set DoIt "Ask" }
    if {[string equal -nocase $DoIt "Ask"]} {
	set DoIt [OuiOuNon "Dans /genomics/link\nj'enleve les liens inexistants, je cree les manquants. \nSi tu n'es pas sûr, on fait d'abord un tour pour rien, je te repose la question à la fin.\n Je le fais pour de bon tout de suite ?" 0]
    } else {
	set DoIt [string equal -nocase $DoIt "DoIt"]
    }
    cd /genomics
    set LesLinks [glob -type link "/genomics/link/*"]
    set LesDelete {}
    set LesNouveaux {}
    set LesExistants {}
    if { ! $DoIt} { lappend LesNouveaux "cd /genomics/link" }
    foreach Link $LesLinks {
	if {[file type $Link]!="link"} { continue }
	set File [file readlink $Link]
	if {[file exists $File]} { lappend LesExistants $File; continue }
	Espionne "file delete $Link"
	if {$DoIt} {
	    file delete $Link ; lappend LesDelete $Link
	} else {
	    lappend LesDelete "rm $Link"
	}
    }

    cd /genomics/link
    set LesRepPossible {}
    LConcat LesRepPossible [glob -nocomplain -type d "/gstock/*"]
    LConcat LesRepPossible [glob -nocomplain -type d "/gstock/ProGscope/*/*"]
    LConcat LesRepPossible [glob -nocomplain -type d "/gstock/user/*/*"]
    foreach F $LesRepPossible {
	set Queue [file tail $F]
	if {[regexp {lost\+found} $Queue]} { continue }
	if {[regexp Projets_Manu $F]} { continue }
	#rR pour ne pas relinker les /genomics/g...
	if {[info exists DejaVu($Queue)]} {
	    FaireLire "$F\n deja vu \n$DejaVu($Queue)"
	}
	set DejaVu($Queue) $F
	set Link "/genomics/link/$Queue"
	if {[file exists $Link]} { continue }
	Espionne "ln -sf $F"
	if {$DoIt} {
	    exec ln -sf $F
	    lappend LesNouveaux $Link
	    lappend LesExistants $Link
	} else {
	    lappend LesNouveaux "ln -sf $F"
	}
    }
    set Message "ToDo"
    AfficheListe $LesDelete "" "LesDelete $Message"
    AfficheListe $LesNouveaux "" "LesNouveaux $Message"
    AfficheListe $LesExistants "" "LesExistants"
    if { ! $DoIt && [OuiOuNon "Je refais un tour pour exécuter toutes les instructions ?"]} {
	return [GenomicsLinks "DoIt"]
    }
    return $LesExistants
}

proc Genomics {} {
    global Genomics
    if {[info exists Genomics]} { return $Genomics }
    set Genomics "/genomics"
    if {[file exists $Genomics]} { return $Genomics }

    global RepertoireDuGenome
    if { [info exists RepertoireDuGenome]} {
	set Genomics [file dirname $RepertoireDuGenome]
	if { ! [regexp {/g[0-9][0-9]?$} $Genomics] && [file exists $Genomics]} { return $Genomics }
    }
    set Genomics [tk_chooseDirectory \
	    -mustexist 1 \
	    -title "Please browse for the genomics directory which should contain your Gscope project"]
    return $Genomics
}

proc GenomicsPossibles {} {
    set Possible [list "[Genomics]/link"]
    return $Possible
}

proc GenomicsSubDir Dir {
    set Queue [file tail $Dir]
    foreach Possible [GenomicsPossibles] {
	if {[file isdirectory $Possible/$Queue]} { return $Possible }
    }
    if {[file exists $Dir]} { return $Dir }
    return "[Genomics]"
}

proc GscopeDatabaseDir {{Dir ""} {Ask ""} {IfExists ""}} {
    global GscopeDatabaseDir

    if {$Dir==""} { return [RepertoireDuGenome] }

    set Queue [file tail $Dir]
    if {$Queue=="fem"} { return [GscopeDatabaseDir FEM] }
    foreach Possible [GenomicsPossibles] {
	set PossibleQueue $Possible/$Queue
	if {[file exists $PossibleQueue]} { return $PossibleQueue }
    }

    if {[string equal -nocase $Ask "Ask"]} {
	set GDD [ChoixDuRepertoire [Genomics]]
	if {$GDD!=""} { return $GDD }
    }
    if {[string equal -nocase $IfExists "IfExists"]} { return "" }
    return $Queue
    return "[GenomicsSubDir $Queue]/$Queue"
}

proc HumanGenomeDir {{Repertoire ""}} {
    global env
    global HumanGenomeDir

    if {$Repertoire!=""} { set HumanGenomeDir $Repertoire }

    if { ! [info exists HumanGenomeDir]} {
	if {[info exists env(HUMANGENOMEDIR)]} {
	    set HumanGenomeDir $env(HUMANGENOMEDIR)
	} else {
	    set HumanGenomeDir "[GscopeDatabaseDir HumanGenome]"
	}
    }
    return $HumanGenomeDir
}

proc OntologyDir {{Repertoire ""}} {
    global env
    global OntologyDir

    if {$Repertoire!=""} { set OntologyDir $Repertoire }

    if { ! [info exists OntologyDir]} {
	if {[info exists env(ONTOLOGYDIR)]} {
	    set OntologyDir $env(ONTOLOGYDIR)
	} else {
	    set OntologyDir "[GscopeDatabaseDir Ontology]"
	}
    }
    return $OntologyDir
}

proc Fiches {{Fichier ""}} {
    if {$Fichier==""} { return "[RepertoireDuGenome]/fiches" }
    return "[RepertoireDuGenome]/fiches/$Fichier"
}

proc RepertoireDuGenome {{Repertoire ""}} {
    global env
    global RepertoireDuGenome
    global FichierMiniConfig
    global GscopeDir
    global argv

    if {$Repertoire!=""} {
	if { ! [regexp "^/" $Repertoire]} { set Repertoire "/genomics/link/$Repertoire" }
	set RepertoireDuGenome $Repertoire
    }
    if { ! [info exists RepertoireDuGenome]} {
	#rR 2010/08/26 pour permettre -project UnRepertoire (avec ou sans /genomics/link) 
	if {[info exists argv] && [lindex $argv 0]=="-project"} {
	    set PossibleRepertoireDuGenome [lindex $argv 1]
	    set argv [lreplace $argv 0 1]
	    if { ! [regexp "^/" $PossibleRepertoireDuGenome] && [FileAbsent $PossibleRepertoireDuGenome]} {
		set PossibleRepertoireDuGenome "/genomics/link/$PossibleRepertoireDuGenome"
	    }
	    if {[FileExists $PossibleRepertoireDuGenome]} {
		return [RepertoireDuGenome $PossibleRepertoireDuGenome]
	    }
	}
	if {[info exists env(REPERTOIREDUGENOME)]} {
	    set RepertoireDuGenome $env(REPERTOIREDUGENOME)
	} else {
	    if {1} {
		set RepertoireDuGenome "[GscopeEtc]/Zero"
		Warne "You did not define setgscoperr. I'll use $RepertoireDuGenome"
		Warne "You did not define setgscoperr. I'll use $RepertoireDuGenome"
		Warne "You did not define setgscoperr. I'll use $RepertoireDuGenome"
	    } else {
		package require Tk
		set RepertoireDuGenome [tk_chooseDirectory \
					    -mustexist 1 \
					    -title "Browse for 'REPERTOIREDUGENOME' the root directory of your data" \
					    -initialdir "$GscopeDir/.."]
	    }
	}
    }
    regsub -all {\\} $RepertoireDuGenome "/" RepertoireDuGenome
    if {[info exists RepertoireDuGenome]} {
	set FichierMiniConfig "$RepertoireDuGenome/beton/miniconfig"
	return $RepertoireDuGenome
    }
    Warne "Please use  setgscope subdirectory_of_/genomics/link"
    Warne "    or change your program to  Gscope directory_of_the_genome"
    exit
}

#rR les variables global suivantes sont normalemnt définies dans gscope_source 
proc GscopeBin {} {
    global  GscopeBin
    return $GscopeBin
}

proc GscopeEtc {} {
    global  GscopeEtc
	if {! [info exists GscopeEtc]} {
			return ""
	}
    return $GscopeEtc
}

proc GscopeDir {} {
    global  GscopeDir
    return $GscopeDir
}

proc GscopeContrib {} {
    global GscopeContrib
    if { ! [info exists GscopeContrib]}  { return "" }
    return $GscopeContrib
}

if {[info proc WaliSourceDir]==""} {
    proc WaliSourceDir {{Value ""}} {
	global WaliSourceDir
	if {$Value!=""} { set WaliSourceDir $Value }
	if { ! [info exists WaliSourceDir]} { set WaliSourceDir "[HomeRipp]/wwwLinux/wali" }
	return $WaliSourceDir
    }
}

proc HomeRipp {} {
    return "/home/ripp"
}

proc LogDir {} {
    return "[HomeRipp]/log"
}