branch

var Create = app.Register(&app.Command[gitops.CreateFlags, app.Empty]{
	Use:    "branch {name}",
	Desc:   "Create a branch",
	Action: "Create",

	Prepare: gitops.PrepareCreate,

	Run: func(ctx *app.Context[gitops.CreateFlags, app.Empty]) error {
		name := ctx.Arg(0)
		err := git.Checkout(name, true, git.Default)
		if err != nil {
			return err
		}
		if !ctx.Flags.NoPush {
			err = git.Exec([]string{"push", "--set-upstream", ctx.Flags.Remote, name}, git.Default)
			if err != nil {
				return err
			}
		}
		return nil
	},
})

var Switch = app.Register(&app.Command[app.Empty, app.Empty]{
	Use:    "branch [branch]",
	Desc:   "Switch to a local branch",
	Action: "Switch",

	PrepareNoFlag: func(cmd *cobra.Command) {
		cmd.Args = cobra.MaximumNArgs(1)
		cmd.ValidArgsFunction = app.Comp(app.CompGitLocalBranch(false))
	},

	Run: func(ctx *app.Context[app.Empty, app.Empty]) error {
		branch := ctx.Arg(0)
		if branch == "" {
			names, err := git.ListLocalBranchNames(false, git.Default)
			if err != nil {
				return err
			}
			if len(names) == 0 {
				return errors.New("no branch to search")
			}
			idx, err := term.FuzzySearch("branch", names)
			if err != nil {
				return err
			}
			branch = names[idx]
		}
		return git.Checkout(branch, false, git.Default)
	},
})

var SwitchRemote = app.Register(&app.Command[SwitchRemoteFlags, app.Empty]{
	Use:    "remote [-r remote] [--no-fetch] [--local {local}] {remote}",
	Desc:   "Switch to a remote branch",
	Action: "Switch",

	Prepare: func(cmd *cobra.Command, flags *SwitchRemoteFlags) {
		gitops.PreapreRemoteFlags(cmd, &flags.RemoteFlags)
		gitops.PreapreFetchFlags(cmd, &flags.FetchFlags)
		cmd.Args = cobra.MaximumNArgs(1)
		cmd.ValidArgsFunction = app.Comp(app.CompGitRemoteBranch)
		cmd.Flags().StringVarP(&flags.Local, "local", "", "", "local branch name")
	},

	Run: func(ctx *app.Context[SwitchRemoteFlags, app.Empty]) error {
		branch := ctx.Arg(0)
		if branch == "" {
			if !ctx.Flags.NoFetch {
				err := git.Fetch(ctx.Flags.Remote, true, false, git.Default)
				if err != nil {
					return err
				}
			}
			branches, err := git.ListLocalBranches(git.Default)
			if err != nil {
				return err
			}
			names, err := git.ListRemoteBranches(ctx.Flags.Remote, branches, git.Default)
			if err != nil {
				return err
			}
			if len(names) == 0 {
				return errors.New("no remote branch")
			}
			idx, err := term.FuzzySearch("remote branch", names)
			if err != nil {
				return err
			}
			branch = names[idx]
		}

		local := ctx.Flags.Local
		if local == "" {
			local = branch
		}

		target := fmt.Sprintf("%s/%s", ctx.Flags.Remote, branch)
		return git.Switch(local, target, git.Default)
	},
})

var Sync = app.Register(&app.Command[SyncFlags, SyncData]{
	Use:    "branch",
	Desc:   "Sync branch with remote",
	Action: "Sync",

	Prepare: func(cmd *cobra.Command, flags *SyncFlags) {
		cmd.Flags().BoolVarP(&flags.NoDelete, "no-delete", "", false, "donot delete any branch")
		cmd.Flags().StringVarP(&flags.Remote, "remote", "r", "origin", "remote name")
		cmd.RegisterFlagCompletionFunc("remote", app.Comp(app.CompGitRemote))
	},

	Init: func(ctx *app.Context[SyncFlags, SyncData]) error {
		ctx.Data = new(SyncData)
		err := git.EnsureNoUncommitted(git.Default)
		if err != nil {
			return err
		}
		err = git.Fetch(ctx.Flags.Remote, true, false, git.Default)
		if err != nil {
			return err
		}
		branches, err := git.ListLocalBranches(git.Default)
		if err != nil {
			return err
		}
		ctx.Data.Branches = branches

		branchWord := english.Plural(len(branches), "branch", "branches")
		term.Println("found", term.Style(branchWord, "magenta"))

		mainBranch, err := git.GetDefaultBranch(ctx.Flags.Remote, git.Default)
		if err != nil {
			return err
		}
		ctx.Data.MainBranch = mainBranch
		term.Println("main branch is", term.Style(mainBranch, "magenta"))

		ctx.Data.BackupBranch = mainBranch
		err = syncCreateTasks(ctx)
		if err != nil {
			return err
		}
		if ctx.Data.CurrentBranch == "" {
			ctx.Data.CurrentBranch, err = git.GetCurrentBranch(git.Default)
			if err != nil {
				return err
			}
		}
		back := ctx.Data.BackupBranch
		term.Println("backup branch is", term.Style(back, "magenta"))
		term.Println()
		return nil
	},

	Run: func(ctx *app.Context[SyncFlags, SyncData]) error {
		if len(ctx.Data.Tasks) == 0 {
			term.Println("nothing to do")
			return nil
		}

		taskWord := english.Plural(len(ctx.Data.Tasks), "task", "")
		term.Printf("we have %s to run:", taskWord)
		for _, task := range ctx.Data.Tasks {
			term.Println(task.desc)
		}
		term.ConfirmExit("continue")

		for _, task := range ctx.Data.Tasks {
			if ctx.Data.CurrentBranch != task.branch {
				git.Checkout(task.branch, false, git.QuietOutput)
				ctx.Data.CurrentBranch = task.branch
			}
			err := git.Exec(task.cmd, git.Default)
			if err != nil {
				return err
			}
		}

		if ctx.Data.CurrentBranch != ctx.Data.BackupBranch {
			return git.Checkout(ctx.Data.BackupBranch, false, git.QuietOutput)
		}
		return nil
	},
})