# git-gui misc. commit reading/writing support
# Copyright (C) 2006, 2007 Shawn Pearce

proc load_last_commit {} {
        global HEAD PARENT MERGE_HEAD commit_type ui_comm commit_author
        global repo_config

        if {[llength $PARENT] == 0} {
                error_popup [mc "There is nothing to amend.

You are about to create the initial commit.  There is no commit before this to amend.
"]
                return
        }

        repository_state curType curHEAD curMERGE_HEAD
        if {$curType eq {merge}} {
                error_popup [mc "Cannot amend while merging.

You are currently in the middle of a merge that has not been fully completed.  You cannot amend the prior commit unless you first abort the current merge activity.
"]
                return
        }

        set msg {}
        set parents [list]
        if {[catch {
                        set name ""
                        set email ""
                        set fd [git_read cat-file commit $curHEAD]
                        fconfigure $fd -encoding binary -translation lf
                        # By default commits are assumed to be in utf-8
                        set enc utf-8
                        while {[gets $fd line] > 0} {
                                if {[string match {parent *} $line]} {
                                        lappend parents [string range $line 7 end]
                                } elseif {[string match {encoding *} $line]} {
                                        set enc [string tolower [string range $line 9 end]]
                                } elseif {[regexp "author (.*)\\s<(.*)>\\s(\\d.*$)" $line all name email time]} { }
                        }
                        set msg [read $fd]
                        close $fd

                        set enc [tcl_encoding $enc]
                        if {$enc ne {}} {
                                set msg [encoding convertfrom $enc $msg]
                                set name [encoding convertfrom $enc $name]
                                set email [encoding convertfrom $enc $email]
                        }
                        if {$name ne {} && $email ne {}} {
                                set commit_author [list name $name email $email date $time]
                        }

                        set msg [string trim $msg]
                } err]} {
                error_popup [strcat [mc "Error loading commit data for amend:"] "\n\n$err"]
                return
        }

        set HEAD $curHEAD
        set PARENT $parents
        set MERGE_HEAD [list]
        switch -- [llength $parents] {
        0       {set commit_type amend-initial}
        1       {set commit_type amend}
        default {set commit_type amend-merge}
        }

        $ui_comm delete 0.0 end
        $ui_comm insert end $msg
        $ui_comm edit reset
        $ui_comm edit modified false
        rescan ui_ready
}

set GIT_COMMITTER_IDENT {}

proc committer_ident {} {
        global GIT_COMMITTER_IDENT

        if {$GIT_COMMITTER_IDENT eq {}} {
                if {[catch {set me [git var GIT_COMMITTER_IDENT]} err]} {
                        error_popup [strcat [mc "Unable to obtain your identity:"] "\n\n$err"]
                        return {}
                }
                if {![regexp {^(.*) [0-9]+ [-+0-9]+$} \
                        $me me GIT_COMMITTER_IDENT]} {
                        error_popup [strcat [mc "Invalid GIT_COMMITTER_IDENT:"] "\n\n$me"]
                        return {}
                }
        }

        return $GIT_COMMITTER_IDENT
}

proc do_signoff {} {
        global ui_comm

        set me [committer_ident]
        if {$me eq {}} return

        set sob "Signed-off-by: $me"
        set last [$ui_comm get {end -1c linestart} {end -1c}]
        if {$last ne $sob} {
                $ui_comm edit separator
                if {$last ne {}
                        && ![regexp {^[A-Z][A-Za-z]*-[A-Za-z-]+: *} $last]} {
                        $ui_comm insert end "\n"
                }
                $ui_comm insert end "\n$sob"
                $ui_comm edit separator
                $ui_comm see end
        }
}

proc create_new_commit {} {
        global commit_type ui_comm commit_author

        set commit_type normal
        unset -nocomplain commit_author
        $ui_comm delete 0.0 end
        $ui_comm edit reset
        $ui_comm edit modified false
        rescan ui_ready
}

proc setup_commit_encoding {msg_wt {quiet 0}} {
        global repo_config

        if {[catch {set enc $repo_config(i18n.commitencoding)}]} {
                set enc utf-8
        }
        set use_enc [tcl_encoding $enc]
        if {$use_enc ne {}} {
                fconfigure $msg_wt -encoding $use_enc
        } else {
                if {!$quiet} {
                        error_popup [mc "warning: Tcl does not support encoding '%s'." $enc]
                }
                fconfigure $msg_wt -encoding utf-8
        }
}

proc commit_tree {} {
        global HEAD commit_type file_states ui_comm repo_config
        global pch_error

        if {[committer_ident] eq {}} return
        if {![lock_index update]} return

        # -- Our in memory state should match the repository.
        #
        repository_state curType curHEAD curMERGE_HEAD
        if {[string match amend* $commit_type]
                && $curType eq {normal}
                && $curHEAD eq $HEAD} {
        } elseif {$commit_type ne $curType || $HEAD ne $curHEAD} {
                info_popup [mc "Last scanned state does not match repository state.

Another Git program has modified this repository since the last scan.  A rescan must be performed before another commit can be created.

The rescan will be automatically started now.
"]
                unlock_index
                rescan ui_ready
                return
        }

        # -- At least one file should differ in the index.
        #
        set files_ready 0
        foreach path [array names file_states] {
                set s $file_states($path)
                switch -glob -- [lindex $s 0] {
                _? {continue}
                A? -
                D? -
                T? -
                M? {set files_ready 1}
                _U -
                U? {
                        error_popup [mc "Unmerged files cannot be committed.

File %s has merge conflicts.  You must resolve them and stage the file before committing.
" [short_path $path]]
                        unlock_index
                        return
                }
                default {
                        error_popup [mc "Unknown file state %s detected.

File %s cannot be committed by this program.
" [lindex $s 0] [short_path $path]]
                }
                }
        }
        if {!$files_ready && ![string match *merge $curType] && ![is_enabled nocommit]} {
                info_popup [mc "No changes to commit.

You must stage at least 1 file before you can commit.
"]
                unlock_index
                return
        }

        if {[is_enabled nocommitmsg]} { do_quit 0 }

        # -- A message is required.
        #
        set msg [string trim [$ui_comm get 1.0 end]]
        regsub -all -line {[ \t\r]+$} $msg {} msg
        if {$msg eq {}} {
                error_popup [mc "Please supply a commit message.

A good commit message has the following format:

- First line: Describe in one sentence what you did.
- Second line: Blank
- Remaining lines: Describe why this change is good.
"]
                unlock_index
                return
        }

        # -- Build the message file.
        #
        set msg_p [gitdir GITGUI_EDITMSG]
        set msg_wt [open $msg_p w]
        fconfigure $msg_wt -translation lf
        setup_commit_encoding $msg_wt
        puts $msg_wt $msg
        close $msg_wt

        if {[is_enabled nocommit]} { do_quit 0 }

        # -- Run the pre-commit hook.
        #
        set fd_ph [githook_read pre-commit]
        if {$fd_ph eq {}} {
                commit_commitmsg $curHEAD $msg_p
                return
        }

        ui_status [mc "Calling pre-commit hook..."]
        set pch_error {}
        fconfigure $fd_ph -blocking 0 -translation binary -eofchar {}
        fileevent $fd_ph readable \
                [list commit_prehook_wait $fd_ph $curHEAD $msg_p]
}

proc commit_prehook_wait {fd_ph curHEAD msg_p} {
        global pch_error

        append pch_error [read $fd_ph]
        fconfigure $fd_ph -blocking 1
        if {[eof $fd_ph]} {
                if {[catch {close $fd_ph}]} {
                        catch {file delete $msg_p}
                        ui_status [mc "Commit declined by pre-commit hook."]
                        hook_failed_popup pre-commit $pch_error
                        unlock_index
                } else {
                        commit_commitmsg $curHEAD $msg_p
                }
                set pch_error {}
                return
        }
        fconfigure $fd_ph -blocking 0
}

proc commit_commitmsg {curHEAD msg_p} {
        global is_detached repo_config
        global pch_error

        if {$is_detached
            && ![file exists [gitdir rebase-merge head-name]]
            &&  [is_config_true gui.warndetachedcommit]} {
                set msg [mc "You are about to commit on a detached head.\
This is a potentially dangerous thing to do because if you switch\
to another branch you will lose your changes and it can be difficult\
to retrieve them later from the reflog. You should probably cancel this\
commit and create a new branch to continue.\n\
\n\
Do you really want to proceed with your Commit?"]
                if {[ask_popup $msg] ne yes} {
                        unlock_index
                        return
                }
        }

        # -- Run the commit-msg hook.
        #
        set fd_ph [githook_read commit-msg $msg_p]
        if {$fd_ph eq {}} {
                commit_writetree $curHEAD $msg_p
                return
        }

        ui_status [mc "Calling commit-msg hook..."]
        set pch_error {}
        fconfigure $fd_ph -blocking 0 -translation binary -eofchar {}
        fileevent $fd_ph readable \
                [list commit_commitmsg_wait $fd_ph $curHEAD $msg_p]
}

proc commit_commitmsg_wait {fd_ph curHEAD msg_p} {
        global pch_error

        append pch_error [read $fd_ph]
        fconfigure $fd_ph -blocking 1
        if {[eof $fd_ph]} {
                if {[catch {close $fd_ph}]} {
                        catch {file delete $msg_p}
                        ui_status [mc "Commit declined by commit-msg hook."]
                        hook_failed_popup commit-msg $pch_error
                        unlock_index
                } else {
                        commit_writetree $curHEAD $msg_p
                }
                set pch_error {}
                return
        }
        fconfigure $fd_ph -blocking 0
}

proc commit_writetree {curHEAD msg_p} {
        ui_status [mc "Committing changes..."]
        set fd_wt [git_read write-tree]
        fileevent $fd_wt readable \
                [list commit_committree $fd_wt $curHEAD $msg_p]
}

proc commit_committree {fd_wt curHEAD msg_p} {
        global HEAD PARENT MERGE_HEAD commit_type commit_author
        global current_branch
        global ui_comm selected_commit_type
        global file_states selected_paths rescan_active
        global repo_config
        global env

        gets $fd_wt tree_id
        if {[catch {close $fd_wt} err]} {
                catch {file delete $msg_p}
                error_popup [strcat [mc "write-tree failed:"] "\n\n$err"]
                ui_status [mc "Commit failed."]
                unlock_index
                return
        }

        # -- Verify this wasn't an empty change.
        #
        if {$commit_type eq {normal}} {
                set fd_ot [git_read cat-file commit $PARENT]
                fconfigure $fd_ot -encoding binary -translation lf
                set old_tree [gets $fd_ot]
                close $fd_ot

                if {[string equal -length 5 {tree } $old_tree]
                        && [string length $old_tree] == 45} {
                        set old_tree [string range $old_tree 5 end]
                } else {
                        error [mc "Commit %s appears to be corrupt" $PARENT]
                }

                if {$tree_id eq $old_tree} {
                        catch {file delete $msg_p}
                        info_popup [mc "No changes to commit.

No files were modified by this commit and it was not a merge commit.

A rescan will be automatically started now.
"]
                        unlock_index
                        rescan {ui_status [mc "No changes to commit."]}
                        return
                }
        }

        if {[info exists commit_author]} {
                set old_author [commit_author_ident $commit_author]
        }
        # -- Create the commit.
        #
        set cmd [list commit-tree $tree_id]
        if {[is_config_true commit.gpgsign]} {
                lappend cmd -S
        }
        foreach p [concat $PARENT $MERGE_HEAD] {
                lappend cmd -p $p
        }
        lappend cmd <$msg_p
        if {[catch {set cmt_id [eval git $cmd]} err]} {
                catch {file delete $msg_p}
                error_popup [strcat [mc "commit-tree failed:"] "\n\n$err"]
                ui_status [mc "Commit failed."]
                unlock_index
                unset -nocomplain commit_author
                commit_author_reset $old_author
                return
        }
        if {[info exists commit_author]} {
                unset -nocomplain commit_author
                commit_author_reset $old_author
        }

        # -- Update the HEAD ref.
        #
        set reflogm commit
        if {$commit_type ne {normal}} {
                append reflogm " ($commit_type)"
        }
        set msg_fd [open $msg_p r]
        setup_commit_encoding $msg_fd 1
        gets $msg_fd subject
        close $msg_fd
        append reflogm {: } $subject
        if {[catch {
                        git update-ref -m $reflogm HEAD $cmt_id $curHEAD
                } err]} {
                catch {file delete $msg_p}
                error_popup [strcat [mc "update-ref failed:"] "\n\n$err"]
                ui_status [mc "Commit failed."]
                unlock_index
                return
        }

        # -- Cleanup after ourselves.
        #
        catch {file delete $msg_p}
        catch {file delete [gitdir MERGE_HEAD]}
        catch {file delete [gitdir MERGE_MSG]}
        catch {file delete [gitdir SQUASH_MSG]}
        catch {file delete [gitdir GITGUI_MSG]}
        catch {file delete [gitdir CHERRY_PICK_HEAD]}

        # -- Let rerere do its thing.
        #
        if {[get_config rerere.enabled] eq {}} {
                set rerere [file isdirectory [gitdir rr-cache]]
        } else {
                set rerere [is_config_true rerere.enabled]
        }
        if {$rerere} {
                catch {git rerere}
        }

        # -- Run the post-commit hook.
        #
        set fd_ph [githook_read post-commit]
        if {$fd_ph ne {}} {
                global pch_error
                set pch_error {}
                fconfigure $fd_ph -blocking 0 -translation binary -eofchar {}
                fileevent $fd_ph readable \
                        [list commit_postcommit_wait $fd_ph $cmt_id]
        }

        $ui_comm delete 0.0 end
        $ui_comm edit reset
        $ui_comm edit modified false
        if {$::GITGUI_BCK_exists} {
                catch {file delete [gitdir GITGUI_BCK]}
                set ::GITGUI_BCK_exists 0
        }

        if {[is_enabled singlecommit]} { do_quit 0 }

        # -- Update in memory status
        #
        set selected_commit_type new
        set commit_type normal
        set HEAD $cmt_id
        set PARENT $cmt_id
        set MERGE_HEAD [list]

        foreach path [array names file_states] {
                set s $file_states($path)
                set m [lindex $s 0]
                switch -glob -- $m {
                _O -
                _M -
                _D {continue}
                __ -
                A_ -
                M_ -
                T_ -
                D_ {
                        unset file_states($path)
                        catch {unset selected_paths($path)}
                }
                DO {
                        set file_states($path) [list _O [lindex $s 1] {} {}]
                }
                AM -
                AD -
                AT -
                TM -
                TD -
                MM -
                MT -
                MD {
                        set file_states($path) [list \
                                _[string index $m 1] \
                                [lindex $s 1] \
                                [lindex $s 3] \
                                {}]
                }
                }
        }

        display_all_files
        unlock_index
        reshow_diff
        ui_status [mc "Created commit %s: %s" [string range $cmt_id 0 7] $subject]
}

proc commit_postcommit_wait {fd_ph cmt_id} {
        global pch_error

        append pch_error [read $fd_ph]
        fconfigure $fd_ph -blocking 1
        if {[eof $fd_ph]} {
                if {[catch {close $fd_ph}]} {
                        hook_failed_popup post-commit $pch_error 0
                }
                unset pch_error
                return
        }
        fconfigure $fd_ph -blocking 0
}

proc commit_author_ident {details} {
        global env
        array set author $details
        set old [array get env GIT_AUTHOR_*]
        set env(GIT_AUTHOR_NAME) $author(name)
        set env(GIT_AUTHOR_EMAIL) $author(email)
        set env(GIT_AUTHOR_DATE) $author(date)
        return $old
}
proc commit_author_reset {details} {
        global env
        unset env(GIT_AUTHOR_NAME) env(GIT_AUTHOR_EMAIL) env(GIT_AUTHOR_DATE)
        if {$details ne {}} {
                array set env $details
        }
}