// cmdRunHook runs the checks in a git repository.
//
// Use a precise "stash, run checks, unstash" to ensure that the check is
// properly run on the data in the index.
func (a *application) cmdRunHook(repo scm.Repo, mode string, noUpdate bool) error {
	switch checks.Mode(mode) {
	case checks.PreCommit:
		return a.runPreCommit(repo)

	case checks.PrePush:
		return a.runPrePush(repo)

	case checks.ContinuousIntegration:
		// Always runs all tests on CI.
		change, err := repo.Between(scm.Current, scm.Initial, a.config.IgnorePatterns)
		if err != nil {
			return err
		}
		mode := []checks.Mode{checks.ContinuousIntegration}

		// This is a special case, some users want reproducible builds and in this
		// case they do not want any external reference and want to enforce
		// noUpdate, but many people may not care (yet). So default to fetching but
		// it can be overriden.
		var prereqReady sync.WaitGroup
		errCh := make(chan error, 1)
		prereqReady.Add(1)
		go func() {
			defer prereqReady.Done()
			errCh <- a.cmdInstallPrereq(repo, mode, noUpdate)
		}()
		err = a.runChecks(change, mode, &prereqReady)
		if err2 := <-errCh; err2 != nil {
			return err2
		}
		return err

	default:
		return errors.New("unsupported hook type for run-hook")
	}
}

func runPreCommit(repo scm.Repo, config *checks.Config) error {
	// First, stash index and work dir, keeping only the to-be-committed changes
	// in the working directory.
	stashed, err := repo.Stash()
	if err != nil {
		return err
	}
	// Run the checks.
	var change scm.Change
	change, err = repo.Between(scm.Current, repo.HEAD(), config.IgnorePatterns)
	if change != nil {
		err = runChecks(config, change, []checks.Mode{checks.PreCommit}, &sync.WaitGroup{})
	}
	// If stashed is false, everything was in the index so no stashing was needed.
	if stashed {
		if err2 := repo.Restore(); err == nil {
			err = err2
		}
	}
	return err
}

func (a *application) runPreCommit(repo scm.Repo) error {
	// First, stash index and work dir, keeping only the to-be-committed changes
	// in the working directory.
	// TODO(maruel): When running for an git commit --amend run, use HEAD~1.
	stashed, err := repo.Stash()
	if err != nil {
		return err
	}
	// Run the checks.
	var change scm.Change
	change, err = repo.Between(scm.Current, scm.Head, a.config.IgnorePatterns)
	if change != nil {
		err = a.runChecks(change, []checks.Mode{checks.PreCommit}, &sync.WaitGroup{})
	}
	// If stashed is false, everything was in the index so no stashing was needed.
	if stashed {
		if err2 := repo.Restore(); err == nil {
			err = err2
		}
	}
	return err
}

func (a *application) runPrePush(repo scm.Repo) (err error) {
	previous := scm.Head
	// Will be "" if the current checkout was detached.
	previousRef := repo.Ref(scm.Head)
	curr := previous
	stashed := false
	defer func() {
		if curr != previous {
			p := previousRef
			if p == "" {
				p = string(previous)
			}
			if err2 := repo.Checkout(p); err == nil {
				err = err2
			}
		}
		if stashed {
			if err2 := repo.Restore(); err == nil {
				err = err2
			}
		}
	}()

	bio := bufio.NewReader(os.Stdin)
	line := ""
	triedToStash := false
	for {
		if line, err = bio.ReadString('\n'); err != nil {
			break
		}
		matches := rePrePush.FindStringSubmatch(line[:len(line)-1])
		if len(matches) != 5 {
			return fmt.Errorf("unexpected stdin for pre-push: %q", line)
		}
		from := scm.Commit(matches[4])
		to := scm.Commit(matches[2])
		if to == gitNilCommit {
			// It's being deleted.
			continue
		}
		if to != curr {
			// Stash, checkout, run tests.
			if !triedToStash {
				// Only try to stash once.
				triedToStash = true
				if stashed, err = repo.Stash(); err != nil {
					return
				}
			}
			curr = to
			if err = repo.Checkout(string(to)); err != nil {
				return
			}
		}
		if from == gitNilCommit {
			from = scm.Initial
		}
		change, err := repo.Between(to, from, a.config.IgnorePatterns)
		if err != nil {
			return err
		}
		if err = a.runChecks(change, []checks.Mode{checks.PrePush}, &sync.WaitGroup{}); err != nil {
			return err
		}
	}
	if err == io.EOF {
		err = nil
	}
	return
}