#rR gscope_vrp.tcl
#rR 20201207 repris du gscoperso de Claudine ...

proc RepEDD_AFaire {} {
    FaireLire "Attention il faut définir RepEDD"
    return [Entre "/home/mayer/EDDtest"]
}

proc ScopeLaTotale {} {
    # si rien n'est fait sauf le FicFastaBuzon
    # si nouveau fichier modifier la procedure FicFastaBuzon
    # modifier la procédure RepEDD pour éventuellement touranger dans un nouveau répertoire
    # setgscoperr
    # gscope ScopeLaTotale

    if { ! [OuiOuNon "[RepEDD] ok?"]}  { return "merci de modifer RedpEDD" }
    if { ! [OuiOuNon "[FicFastaBuzon] ok?"]}  { return "merci de modifer FicFastaBuzon" }
    ScopeCreateTFAs
    ScopeCreateVrp
    return "Bravo"
}

proc FicFastaBuzon {} {
    return "/home/buzon/Stage/Benchmarks/EDD/EDD.fasta"
}

proc ScopeVerif {} {
    FarieLire "Ne pas relancer merci"
    return "Ne pas relancer merci"
    #rR on avait mis le dernier de chaque FOLD dans le FOlD suivant ... :-(
    
    NousAllonsAuBoulot [RepEDD]
    set DoIt 1
    set TexteOriginal [ContenuDuFichier [FicFastaBuzon]]
    foreach Fold [lsort [glob -nocomplain -type d *]] {
	foreach FicFasta [lsort [glob -nocomplain "$Fold/*.tfa"]] {
	    set Queue [file tail $FicFasta]
	    regsub "_.+$" $Queue "" Access
	    regsub ".tfa$" $Queue "" Queue
	    if {[info exists DejaVu($Queue)]} {
		Espionne $Access
		if { ! [regexp "\n(>d$Access\[^\n\]+)\n" $TexteOriginal Match Ligne]} {
		    FaireLire "trouve pas la ligne de $Access"
		    continue
		}
		scan $Ligne "%s %s" A F
		lassign [split $F "."] a b
		set FoldLu "$a$b"
		Espionne [string equal $Fold $FoldLu] $Fold $FoldLu $FicFasta $DejaVu($Queue) $Ligne
		if { ! [string equal $Fold $FoldLu]} {
		    Espionne je garde $FoldLu je vire dans $Fold
		    if {$DoIt} { file delete $Fold/$Queue.tfa $Fold/$Queue.gif $Fold/$Queue.txt }
		} else {
		    set Dir [file dirname $DejaVu($Queue)]
		    Espionne je vire dans $Dir je garde dans $Fold
		    if {$DoIt} { file delete $Dir/$Queue.tfa  $Dir/$Queue.gif $Dir/$Queue.txt }
		}
	    }
	    set DejaVu($Queue) $FicFasta
	}
    }
    return salut
}

proc ScopeCreateTFAs {{FicFasta ""}} {
    #rR on lit le fichier de Buzon qui contient les FOLD suivis des fasta
    #rR on cree un repertore par FOLD et on y met les TFA créés à la volée.
    if {$FicFasta==""} { set FicFasta [FicFastaBuzon] }
    file mkdir [RepEDD]
    set Access ""
    set LesCrees {}
    set LesLignes [LesLignesDuFichier $FicFasta]
    lappend LesLignes ">CEstFini"
    foreach Ligne $LesLignes {
	if {[regexp {^FOLD} $Ligne] || [regexp {^>} $Ligne]} {
	    if {$Access!=""} {
		# on a déjà lu toute la sequence il faut la ranger
		set Sequence $SequenceDe($Access)
		set TFA [SequenceFormatTFA $Sequence "$Access $Info" "protbrut"]
		set FicCree "$RepFoldCourant/$Access.tfa"
		Sauve $TFA dans $FicCree
		set Access ""
		lappend LesCrees $FicCree
		if {$Ligne==">CEstFini"} { break }
	    }
	    if { ! [regexp {^FOLD} $Ligne]} {
		# on traite les infos de la premiere ligne du fasta. Si c'est pas FOLD
		set Info ""
		scan $Ligne "%s" Access
		regsub "$Access *" $Ligne "" Info   ; # on enleve l'access suivi de blancs
		
		set CodePDB [string range $Access 2 5]
		set Extension [string range $Access 6 end]
		set Access "${CodePDB}_$Extension"
		set Access [string trimright $Access "_"]
		Espionne access $Access
	    }
	}
	if {[regexp {^FOLD} $Ligne]} {
	    # on traite le FOLD
	    lassign [split $Ligne "\t"] F N T Name
	    Espionne $F $N $T = $Name
	    regsub -all {\.} $N "" N
	    set RepFoldCourant "[RepEDD]/$N"
	    file mkdir $RepFoldCourant
	    continue
	}
	if {[regexp -nocase {[^a-z ]} $Ligne]} { continue }
	regsub -all " " $Ligne "" Seq
	append SequenceDe($Access) $Seq
    }
    return $LesCrees
}

proc ScopeCreateVrp {} {

    set Recuperation 0 ; #rR ne pas relancer la recuperation!!!
    
    NousAllonsAuBoulot [RepEDD]
    foreach Fold [lsort [glob -nocomplain -type d *]] {
	if {$Fold=="obsolete"} { continue }
	NousAllonsAuBoulot $Fold
	foreach FicFasta [lsort [glob -nocomplain "*.tfa"]] {
	    Espionne $FicFasta
	    set Queue [file tail $FicFasta]

	    regsub ".tfa$" $Queue "" FicTexte
	    append FicTexte ".txt"
	    if {$Recuperation} { file copy "../GIF/$FicTexte" $FicTexte }
	    
	    regsub ".tfa" $Queue "" FicGif
	    append FicGif ".gif"
	    #rR attention les gif ont disparu de EDD
	    if {$Recuperation} { file copy ../$FicGif $FicGif }
	    
	    exec vrpshow -tfa $FicFasta -gif -exit > $FicTexte
	    lappend LesCrees $FicTexte
	}
	OnRevientDuBoulot
    }
    OnRevientDuBoulot
    return $LesCrees
}

proc VrpValue {{Qui ""} {Quoi ""}} {
    global VrpValue

    if {$Qui=="" && $Quoi==""} { set Qui "ListOf" ; set Quoi "All" }
    set Qui  [string toupper $Qui]
    set Quoi [string toupper $Quoi]
    if {[info exists VrpValue($Qui,$Quoi)]} { return $VrpValue($Qui,$Quoi) }
    if {[info exists VrpValue("EstCharge")]} { return "" }
    set VrpValue("EstCharge") 1
    set MinX  99999
    set MaxX -99999
    set MinY $MinX
    set MaxY $MaxX
    set MinM $MinX
    set MaxM $MaxX
    set LeTout {}
    foreach Ligne [LesLignesDuFichier "/biolo/Vrp/AAtab.dat"] {
        lassign [split $Ligne " "] A X Y
        if {$A=="*"} { set A "." }
	set M      [expr sqrt($X*$X+$Y*$Y)]
	set Angle  [expr atan2($Y,$X)]
	set Degres [expr ($Angle*180.)/3.1415926]
        set VrpValue($A,POSX) $X
        set VrpValue($A,POSY) $Y
        set VrpValue($A,) "$X $Y"
        set VrpValue($X,$Y) $A
        set VrpValue($A,ANGLE)  $Angle
        set VrpValue($A,DEGRES) $Degres
	set VrpValue($A,MODULE) $M
        lappend VrpValue(LISTOF,A) $A
	if {$A!="."} {
	    set MinX [Mini $MinX $X]
	    set MaxX [Maxi $MaxX $X]
	    set MinY [Mini $MinY $Y]
	    set MaxY [Maxi $MaxY $Y]
	    set MinM [Mini $MinM $M]
	    set MaxM [Maxi $MaxM $M]
	}
	set All "$A $X $Y $M $Angle $Degres"
	regsub -all " " $All "\t" All
	lappend LeTout $All
    }
    set MinMax "Z $MinX $MaxX $MinY $MaxY $MinM $MaxM 0 0 1"
    regsub -all " " $MinMax "\t" MinMax
    lappend LeTout $MinMax
    
    set VrpValue(LISTOF,ALL) $LeTout
    set VrpValue(TEXTOF,ALL) [join $LeTout "\n"]
    set VrpValue(MIN,X) $MinX
    set VrpValue(MIN,Y) $MinY
    set VrpValue(MIN,M) $MinM
    set VrpValue(MAX,X) $MaxX
    set VrpValue(MAX,Y) $MaxY
    set VrpValue(MAX,M) $MaxM
    set VrpValue(MIN,MODULE) $MinM
    set VrpValue(MAX,MODULE) $MaxM
    foreach A $VrpValue(LISTOF,A) {
        foreach B $VrpValue(LISTOF,A) {
            set D [expr sqrt(($VrpValue($A,POSX)-$VrpValue($B,POSX))**2 + ($VrpValue($A,POSY)-$VrpValue($B,POSY))**2)]
            set VrpValue($A,$B) $D
            lappend VrpValue(LISTOF,DISTANCES) "$A $B $D"
        }
    }
    return [VrpValue $Qui $Quoi]
}

proc VispValue {{Qui ""} {Quoi ""}} {
    #rR C'est comme Vrp mais on ne veut que des angles qui vont vers l'avant
    #rR    donc on fait un décalage et une compression de l'angle
    #rR    attention quand on demande VispValue 45 0.3 on réinitialise tout avec ce décalage et compression
    #rR                                                et on renvoie TextOf All
    global VispValue

    set Pi 3.1415926

    if {[regexp {^[0-9\.\-]+$} $Qui] && [regexp {^[0-9\.\-]+$} $Quoi]} {
	if {[info exists VispValue]} { unset VispValue }
	set VispValue(DECALAGEDEGRES,) $Qui
	set VispValue(COMPRESSION,)    $Quoi
	set Qui  "TextOf"
	set Quoi "All"
    }
    if { ! [info exists VispValue(DECALAGEDEGRES,)]} { set VispValue(DECALAGEDEGRES,) 45 }
    if { ! [info exists VispValue(COMPRESSION,)]}    { set VispValue(COMPRESSION,) 0.4 }
    
    if {$Qui=="" && $Quoi==""} { set Qui "ListOf" ; set Quoi "All" }
    set Qui  [string toupper $Qui]
    set Quoi [string toupper $Quoi]
    if {[info exists VispValue($Qui,$Quoi)]} { return $VispValue($Qui,$Quoi) }
    if {[info exists VispValue("EstCharge")]} { return "" }
    set VispValue("EstCharge") 1

    set DecalageDegres $VispValue(DECALAGEDEGRES,)
    set DecalageAngle  [expr ($DecalageDegres*$Pi)/180.]
    set Compression    $VispValue(COMPRESSION,)

    set MinX  99999
    set MaxX -99999
    set MinY $MinX
    set MaxY $MaxX
    set MinM $MinX
    set MaxM $MaxX
    set LeTout {}
    foreach Ligne [VrpValue ListOf All] {
	if {[regexp "^Z" $Ligne] } { continue }
        lassign [split $Ligne " \t"] A X Y M Angle Degres
	set Angle  [expr $Angle + $DecalageAngle]
	if {$Angle < -2*$Pi} { set Angle [expr $Angle+2*$Pi] }
	if {$Angle >  2*$Pi} { set Angle [expr $Angle-2*$Pi] }
	set Angle  [expr $Angle*$Compression]
	set Degres [expr ($Angle*180.)/$Pi]
	set X [expr $M*cos($Angle)]
	set Y [expr $M*sin($Angle)]
        set VispValue($A,POSX) $X
        set VispValue($A,POSY) $Y
        set VispValue($A,) "$X $Y"
        set VispValue($X,$Y) $A
        set VispValue($A,ANGLE)  $Angle
        set VispValue($A,DEGRES) $Degres
	set VispValue($A,MODULE) $M
        lappend VispValue(LISTOF,A) $A
	if {$A!="."} {
	    set MinX [Mini $MinX $X]
	    set MaxX [Maxi $MaxX $X]
	    set MinY [Mini $MinY $Y]
	    set MaxY [Maxi $MaxY $Y]
	    set MinM [Mini $MinM $M]
	    set MaxM [Maxi $MaxM $M]
	}
	set All "$A $X $Y $M $Angle $Degres"
	regsub -all " " $All "\t" All
	lappend LeTout $All
    }
    set MinMax "Z $MinX $MaxX $MinY $MaxY $MinM $MaxM $DecalageAngle $DecalageDegres $Compression"
    regsub -all " " $MinMax "\t" MinMax
    lappend LeTout $MinMax

    set VispValue(LISTOF,ALL) $LeTout
    set VispValue(TEXTOF,ALL) [join $LeTout "\n"]
    set VispValue(MIN,X) $MinX
    set VispValue(MIN,Y) $MinY
    set VispValue(MIN,M) $MinM
    set VispValue(MAX,X) $MaxX
    set VispValue(MAX,Y) $MaxY
    set VispValue(MAX,M) $MaxM
    set VispValue(MIN,MODULE) $MinM
    set VispValue(MAX,MODULE) $MaxM
    foreach A $VispValue(LISTOF,A) {
        foreach B $VispValue(LISTOF,A) {
            set D [expr sqrt(($VispValue($A,POSX)-$VispValue($B,POSX))**2 + ($VispValue($A,POSY)-$VispValue($B,POSY))**2)]
            set VispValue($A,$B) $D
            lappend VispValue(LISTOF,DISTANCES) "$A $B $D"
        }
    }
    return [VispValue $Qui $Quoi]
}
    
#rR EDD Claudine veut étudier les folds
#rR Au commencement chaque Residu r est a droite de son voisin de gauche pos(i,r)=d(i,g)
#rR Apres le premier alignement 
#rR si pas d'insertion dans la query pos(2,k)=pos(1,k) si hit et on garde ce qu'il y avait.
#rR si insertion de N dans la query apres f, pos(1,f+1)=pos(2,f)

proc RepEDD {} {
    return "/genomics/link/EDD"
}

proc UrlEDD {} {
    return "/EDD"
}

proc EDD {{Qui ""} {Quoi ""}} {
    global EDD
    if {[info exists EDD($Qui,$Quoi)]} { return $EDD($Qui,$Quoi) }
    if {[info exists EDD("EstCharge")]} { return "" }
    set EDD("EstCharge") 1

    set EDD(ListOf,Fold) {}
    NousAllonsAuBoulot "[RepEDD]/Folds"
    set LesFold [lsort -dictionary [glob -nocomplain -type d "*"]]
    set EDD(ListOf,Tfa) {}
    set EDD(ListOf,TfaEntete) {}
    foreach Fold $LesFold {
        lappend EDD(ListOf,Fold) $Fold
        set EDD($Fold,ListOfGif) {} 
        set EDD($Fold,ListOfTfa) {} 
        set EDD($Fold,ListOfTxt) {} 
        set EDD($Fold,ListOfJpg) {} 
        foreach Gif [lsort [glob -nocomplain "$Fold/*.gif"]] {
            regsub ".gif$" $Gif ".tfa" Tfa
            regsub ".gif$" $Gif ".txt" Txt
            regsub ".gif$" $Gif ".jpg" Jpg
            lappend EDD($Fold,ListOfGif) $Gif
            lappend EDD($Fold,ListOfTfa) $Tfa
            lappend EDD($Fold,ListOfTxt) $Txt
            lappend EDD($Fold,ListOfJpg) $Jpg
            if {[FileAbsent $Jpg]} {
                Espionne $Jpg
                exec convert -resize 25% $Gif $Jpg
            }
	    set Entete [PremiereLigneDuFichier $Tfa]
	    regsub ">" $Entete "" Entete
	    scan $Entete "%s %s %s" Access Scope Limit
	    set EDD($Access,Access) $Access
	    set EDD($Access,Entete) $Entete
	    set EDD($Access,Scope)  $Scope
	    set EDD($Access,Limit)  $Scope
	    lappend EDD(ListOf,Access) $Access
	    lappend EDD(ListOf,Scope)  $Scope
	    lappend EDD($Fold,ListOfAccess) $Access
	    lappend EDD($Fold,ListOfScope)  $Scope
	    lappend EDD($Scope,ListOfJpg)   $Jpg
	    lappend EDD(ListOf,Tfa)         $Tfa
	    lappend EDD(ListOf,TfaEntete)   "$Tfa $Entete"
        }
    }
    set EDD(ListOfAsText,Tfa)       [join $EDD(ListOf,Tfa) "\n"]
    set EDD(ListOfAsText,TfaEntete) [join $EDD(ListOf,TfaEntete) "\n"]
    set EDD(ListOf,Scope) [lsort -unique -command CompareLesScopes $EDD(ListOf,Scope)]
    foreach Fold $LesFold {
	set EDD($Fold,ListOfScope) [lsort -unique -command CompareLesScopes $EDD($Fold,ListOfScope)]
    }
    OnRevientDuBoulot
    return [EDD $Qui $Quoi]
}

proc CompareLesScopes {a b} {
    foreach ai [split $a "."] bi [split $b "."] {
	if {$ai<$bi} { return -1 }
	if {$ai>$bi} { return  1 }
    }
    return 0
}

proc EddHtml {{LesFold ""}} {
    if {$LesFold==""} { set LesFold [EDD ListOf Fold] }
    set LesDivDesFolds {}
    set LeH {}
    foreach Fold $LesFold {
	lappend LeH "<hr>"
	lappend LeH "<h1>Fold $Fold</h1>"
	foreach Scope [EDD $Fold ListOfScope] {
	    lappend LeH "<h3>Fold $Fold Scope $Scope</h3>"
	    set LesImgDuScope {}
	    foreach Jpg [EDD $Scope ListOfJpg] {
		set Queue [file tail $Jpg]
		regsub {\.[^\.]+$} $Queue "" Access
		lassign [split $Access "_"] Pdb S
		set Scope  [EDD $Access Scope]
		set Entete [EDD $Access Entete]
		set Entete [string map [list "'" " "  "<" " "  ">" " "  "\"" " "  "\[" " "  "\]" " "] $Entete]
		set Img "<img src='[UrlEDD]/Folds/$Jpg' title='Fold $Fold $Entete' onclick='link(event, \"$Access\", \"$Pdb\", \"$Scope\", \"$Entete\");'/>"
		lappend LesImgDuScope $Img
	    }
	    set ImgDuScope [join $LesImgDuScope "\n"]
	    lappend LeH $ImgDuScope
	}
    }
    set H [join $LeH "\n"]
    set Html [Html_Chabada "[RepEDD]/html/edd_template.html" "ImagesDiv=$H"] 
    return $Html
}