main.go

package main

import (
	"bytes"
	"errors"
	"fmt"
	"io"
	"log"
	"os"
	"os/exec"
	"strings"

	"github.com/FreePeak/commitgen/pkg/commitrules"
	"github.com/FreePeak/commitgen/pkg/providers"
	"github.com/urfave/cli/v2"
)

// Version information (set by GoReleaser).
var (
	version = "v0.1.5"
	commit  = "none"
	date    = "unknown"
	builtBy = "local"
)

// Error definitions.
var (
	ErrNotGitRepo          = errors.New("not in a git repository")
	ErrNoChangesFound      = errors.New("no changes found to analyze")
	ErrNoStagedFiles       = errors.New("no staged files found")
	ErrNoUntrackedFiles    = errors.New("no untracked files found")
	ErrUnsupportedProvider = errors.New("unsupported provider")
	ErrPermissionDenied    = errors.New("permission denied. Try: sudo commitgen install")
	ErrProviderName        = errors.New("provider name required")
)

func main() {
	app := createApp()
	if err := app.Run(os.Args); err != nil {
		log.Fatal(err)
	}
}

func createApp() *cli.App {
	return &cli.App{
		Name:    "commitgen",
		Version: version,
		Usage:   "AI-powered git commit message generator",
		Flags: []cli.Flag{
			&cli.StringFlag{
				Name:  "provider",
				Usage: "AI provider to use (claude*, gemini, copilot, opencode)",
				Value: "claude",
			},
			&cli.BoolFlag{
				Name:    "yes",
				Aliases: []string{"y"},
				Usage:   "Auto-confirm the generated commit message",
			},
		},
		Commands: []*cli.Command{
			createCommitCommand(),
			createProvidersCommand(),
			{
				Name:   "install",
				Usage:  "Install commitgen to /usr/local/bin",
				Action: installBinary,
			},
			createVersionCommand(),
		},
		Action: func(c *cli.Context) error {
			return generateCommitMessage("staged")(c)
		},
	}
}

func createCommitCommand() *cli.Command {
	return &cli.Command{
		Name:    "commit",
		Aliases: []string{"c"},
		Usage:   "Generate commit message from changes",
		Subcommands: []*cli.Command{
			createStagedCommand(),
			createAllCommand(),
			createUntrackedCommand(),
		},
	}
}

func createProvidersCommand() *cli.Command {
	return &cli.Command{
		Name:    "provider",
		Aliases: []string{"providers"},
		Usage:   "Manage AI providers",
		Subcommands: []*cli.Command{
			{
				Name:    "list",
				Aliases: []string{"ls"},
				Usage:   "List available providers",
				Action:  listProviders,
			},
			{
				Name:    "default",
				Aliases: []string{"d"},
				Usage:   "Set default provider",
				Action:  setDefaultProvider,
			},
			{
				Name:   "add",
				Usage:  "Add a custom provider",
				Action: addProvider,
				Flags: []cli.Flag{
					&cli.StringFlag{
						Name:     "command",
						Usage:    "Command to run",
						Required: true,
					},
					&cli.StringSliceFlag{
						Name:  "args",
						Usage: "Arguments for the command",
					},
				},
			},
			{
				Name:   "remove",
				Usage:  "Remove a custom provider",
				Action: removeProvider,
			},
		},
	}
}

func createStagedCommand() *cli.Command {
	return &cli.Command{
		Name:    "staged",
		Aliases: []string{"s"},
		Usage:   "Generate from staged files",
		Flags: []cli.Flag{
			&cli.StringFlag{
				Name:  "provider",
				Usage: "AI provider to use (claude*, gemini, copilot, opencode)",
				Value: "claude",
			},
			&cli.BoolFlag{
				Name:    "yes",
				Aliases: []string{"y"},
				Usage:   "Auto-confirm the generated commit message",
			},
		},
		Action: generateCommitMessage("staged"),
	}
}

func createAllCommand() *cli.Command {
	return &cli.Command{
		Name:    "all",
		Aliases: []string{"a"},
		Usage:   "Generate from all changes",
		Flags: []cli.Flag{
			&cli.StringFlag{
				Name:  "provider",
				Usage: "AI provider to use (claude*, gemini, copilot, opencode)",
				Value: "claude",
			},
			&cli.BoolFlag{
				Name:    "yes",
				Aliases: []string{"y"},
				Usage:   "Auto-confirm the generated commit message",
			},
		},
		Action: generateCommitMessage("all"),
	}
}

func createUntrackedCommand() *cli.Command {
	return &cli.Command{
		Name:    "untracked",
		Aliases: []string{"u"},
		Usage:   "Generate from untracked files",
		Flags: []cli.Flag{
			&cli.StringFlag{
				Name:  "provider",
				Usage: "AI provider to use (claude*, gemini, copilot, opencode)",
				Value: "claude",
			},
			&cli.BoolFlag{
				Name:    "yes",
				Aliases: []string{"y"},
				Usage:   "Auto-confirm the generated commit message",
			},
		},
		Action: generateCommitMessage("untracked"),
	}
}

func createVersionCommand() *cli.Command {
	return &cli.Command{
		Name:    "version",
		Aliases: []string{"v"},
		Usage:   "Show version information",
		Action: func(c *cli.Context) error {
			fmt.Printf("Commitgen %s\n", version)
			fmt.Printf("Commit: %s\n", commit)
			fmt.Printf("Built: %s\n", date)
			fmt.Printf("Built by: %s\n", builtBy)
			return nil
		},
	}
}

func generateCommitMessage(mode string) cli.ActionFunc {
	return func(cliContext *cli.Context) error {
		if !isGitRepo() {
			return ErrNotGitRepo
		}

		analysisInput, err := getAnalysisInput(mode)
		if err != nil {
			return err
		}

		provider := getProvider(cliContext)
		commitMessage, err := callAIAPI(analysisInput, provider)
		if err != nil {
			return fmt.Errorf("failed to generate commit message: %w", err)
		}

		commitMessage = commitrules.CleanCommitMessage(commitMessage)
		validateAndShowWarning(commitMessage)

		autoConfirm := cliContext.Bool("yes")
		if confirmCommit(commitMessage, autoConfirm) {
			return executeCommit(mode, commitMessage)
		}
		fmt.Println("Commit cancelled.")
		return nil
	}
}

func getAnalysisInput(mode string) (string, error) {
	switch mode {
	case "staged":
		return analyzeStagedChanges()
	case "all":
		return analyzeAllChanges()
	case "untracked":
		return analyzeUntrackedFiles()
	default:
		return "", fmt.Errorf("%w: unknown mode: %s", ErrNoChangesFound, mode)
	}
}

func getProvider(cliContext *cli.Context) string {
	provider := cliContext.String("provider")
	if provider == "" {
		provider = providers.GetDefaultProvider()
	}
	return provider
}

func validateAndShowWarning(commitMessage string) {
	if err := commitrules.ValidateCommitMessage(commitMessage); err != nil {
		fmt.Printf("Warning: %s\n", err)
	}
}

func confirmCommit(commitMessage string, autoConfirm bool) bool {
	if autoConfirm {
		fmt.Printf("Generated commit message:\n\"%s\"\n\n", commitMessage)
		fmt.Println("Auto-confirming commit message...")
		return true
	}

	fmt.Printf("Generated commit message:\n\"%s\"\n\n", commitMessage)
	fmt.Print("Do you want to use this commit message? [y/N] ")

	var response string
	_, err := fmt.Scanln(&response)
	if err != nil {
		response = ""
	}

	confirmed := strings.ToLower(response) == "y" || strings.ToLower(response) == "yes"
	if confirmed {
		fmt.Println("Committed successfully!")
	}
	return confirmed
}

func isGitRepo() bool {
	_, err := exec.Command("git", "rev-parse", "--git-dir").CombinedOutput()
	return err == nil
}

// validateFilePath validates that a file path is safe to use.
func validateFilePath(path string) bool {
	// Check for path traversal attempts
	if strings.Contains(path, "..") {
		return false
	}
	// Check for dangerous characters
	if strings.ContainsAny(path, "&|;<>()$`\"'") {
		return false
	}
	// Check for empty path
	if path == "" {
		return false
	}
	return true
}

func analyzeStagedChanges() (string, error) {
	// Get staged files
	cmd := exec.Command("git", "diff", "--cached", "--name-only")
	output, err := cmd.Output()
	if err != nil {
		return "", fmt.Errorf("failed to get staged files: %w", err)
	}

	stagedFiles := strings.TrimSpace(string(output))
	if stagedFiles == "" {
		return "", ErrNoStagedFiles
	}

	var analysisInput strings.Builder
	analysisInput.WriteString("=== STAGED CHANGES ANALYSIS ===\n")
	files := strings.Split(stagedFiles, "\n")
	analysisInput.WriteString(fmt.Sprintf("Files changed: %d\n", len(files)))
	analysisInput.WriteString(fmt.Sprintf("Files: %s\n\n", strings.Join(files, " ")))

	// Get diff stats
	cmd = exec.Command("git", "diff", "--cached", "--stat")
	output, _ = cmd.Output()
	analysisInput.WriteString("=== DIFF ===\n")
	analysisInput.Write(output)
	analysisInput.WriteString("\n=== DETAILED CHANGES ===\n")

	// Get detailed diff for each file
	for _, file := range files {
		if !validateFilePath(file) {
			continue
		}
		if _, err := os.Stat(file); err == nil {
			analysisInput.WriteString(fmt.Sprintf("\n--- %s ---\n", file))
			//nolint:gosec // G204: file path is validated by validateFilePath()
			cmd = exec.Command("git", "diff", "--cached", "--unified=3", "--", file)
			output, _ := cmd.Output()
			if len(output) > 2000 {
				output = output[:2000]
			}
			analysisInput.Write(output)
		}
	}

	return analysisInput.String(), nil
}

func analyzeAllChanges() (string, error) {
	modifiedFiles, untrackedFiles, err := getModifiedAndUntrackedFiles()
	if err != nil {
		return "", err
	}

	if modifiedFiles == "" && untrackedFiles == "" {
		return "", ErrNoChangesFound
	}

	var analysisInput strings.Builder
	analysisInput.WriteString("=== ALL CHANGES ANALYSIS ===\n")

	if modifiedFiles != "" {
		addModifiedFilesToAnalysis(&analysisInput, modifiedFiles)
	}

	if untrackedFiles != "" {
		addUntrackedFilesToAnalysis(&analysisInput, untrackedFiles)
	}

	return analysisInput.String(), nil
}

func getModifiedAndUntrackedFiles() (string, string, error) {
	cmd := exec.Command("git", "diff", "--name-only")
	modifiedOutput, err := cmd.Output()
	if err != nil {
		return "", "", fmt.Errorf("failed to get modified files: %w", err)
	}

	cmd = exec.Command("git", "ls-files", "--others", "--exclude-standard")
	untrackedOutput, err := cmd.Output()
	if err != nil {
		return "", "", fmt.Errorf("failed to get untracked files: %w", err)
	}

	return strings.TrimSpace(string(modifiedOutput)), strings.TrimSpace(string(untrackedOutput)), nil
}

func addModifiedFilesToAnalysis(analysisInput *strings.Builder, modifiedFiles string) {
	files := strings.Split(modifiedFiles, "\n")
	fmt.Fprintf(analysisInput, "Modified files: %d\n", len(files))
	analysisInput.WriteString("=== MODIFIED FILES ===\n")
	fmt.Fprintf(analysisInput, "%s\n\n", strings.Join(files, " "))
	analysisInput.WriteString("=== MODIFICATIONS ===\n")

	for _, file := range files {
		if !validateFilePath(file) {
			continue
		}
		if _, err := os.Stat(file); err == nil {
			addFileDiffToAnalysis(analysisInput, file)
		}
	}
}

func addUntrackedFilesToAnalysis(analysisInput *strings.Builder, untrackedFiles string) {
	files := strings.Split(untrackedFiles, "\n")
	analysisInput.WriteString("\n=== UNTRACKED FILES ===\n")
	fmt.Fprintf(analysisInput, "%s\n\n", strings.Join(files, " "))
	analysisInput.WriteString("=== FILE CONTENTS ===\n")

	for _, file := range files {
		if !validateFilePath(file) {
			continue
		}
		if _, err := os.Stat(file); err == nil {
			addFileContentToAnalysis(analysisInput, file)
		}
	}
}

func addFileDiffToAnalysis(analysisInput *strings.Builder, file string) {
	fmt.Fprintf(analysisInput, "\n--- %s ---\n", file)
	cmd := exec.Command("git", "diff", "--unified=3", file)
	output, _ := cmd.Output()
	if len(output) > 2000 {
		output = output[:2000]
	}
	analysisInput.Write(output)
}

func addFileContentToAnalysis(analysisInput *strings.Builder, file string) {
	fmt.Fprintf(analysisInput, "\n--- %s (new) ---\n", file)
	//nolint:gosec // G304: file path is validated by validateFilePath()
	content, _ := os.ReadFile(file)
	if len(content) > 2000 {
		content = content[:2000]
	}
	analysisInput.Write(content)
}

func analyzeUntrackedFiles() (string, error) {
	cmd := exec.Command("git", "ls-files", "--others", "--exclude-standard")
	output, err := cmd.Output()
	if err != nil {
		return "", fmt.Errorf("failed to get untracked files: %w", err)
	}

	untrackedFiles := strings.TrimSpace(string(output))
	if untrackedFiles == "" {
		return "", ErrNoUntrackedFiles
	}

	var analysisInput strings.Builder
	analysisInput.WriteString("=== UNTRACKED FILES ANALYSIS ===\n")
	files := strings.Split(untrackedFiles, "\n")
	analysisInput.WriteString(fmt.Sprintf("Files: %d\n", len(files)))
	analysisInput.WriteString(fmt.Sprintf("%s\n\n", strings.Join(files, " ")))
	analysisInput.WriteString("=== FILE CONTENTS ===\n")

	for _, file := range files {
		if !validateFilePath(file) {
			continue
		}
		if _, err := os.Stat(file); err == nil {
			analysisInput.WriteString(fmt.Sprintf("\n--- %s ---\n", file))
			//nolint:gosec // G304: file path is validated by validateFilePath()
			content, _ := os.ReadFile(file)
			if len(content) > 2000 {
				content = content[:2000]
			}
			analysisInput.Write(content)
		}
	}

	return analysisInput.String(), nil
}

func callAIAPI(analysisInput, provider string) (string, error) {
	prompt := commitrules.GetPrompt(analysisInput)

	// Get provider command and arguments
	cmdName, cmdArgs := getProviderCmd(provider)
	//nolint:gosec // G204: cmdName is from trusted provider configuration
	cmd := exec.Command(cmdName, cmdArgs...)

	cmd.Stdin = strings.NewReader(prompt)

	var stderr bytes.Buffer
	cmd.Stderr = &stderr

	output, err := cmd.Output()
	if err != nil {
		return "", fmt.Errorf("failed to call %s API: %w\nStderr: %s", provider, err, stderr.String())
	}

	result := strings.TrimSpace(string(output))
	if result == "" && stderr.Len() > 0 {
		// If stdout is empty but we have stderr content, treat it as an error
		// This handles cases where tools exit with code 0 but fail (like opencode)
		return "", fmt.Errorf("provider returned empty output: %w: %s", ErrNoChangesFound, stderr.String())
	}

	return result, nil
}

func getProviderCmd(provider string) (string, []string) {
	cmdName, cmdArgs, err := providers.GetProvider(provider)
	if err != nil {
		return provider, []string{}
	}
	return cmdName, cmdArgs
}

func executeCommit(mode, commitMessage string) error {
	var cmd *exec.Cmd

	switch mode {
	case "staged":
		cmd = exec.Command("git", "commit", "-m", commitMessage)
	case "all", "untracked":
		// First stage all changes
		if err := exec.Command("git", "add", ".").Run(); err != nil {
			return fmt.Errorf("failed to stage changes: %w", err)
		}
		cmd = exec.Command("git", "commit", "-m", commitMessage)
	}

	if err := cmd.Run(); err != nil {
		return fmt.Errorf("failed to commit: %w", err)
	}
	return nil
}

func listProviders(c *cli.Context) error {
	providerList, err := providers.ListProviders()
	if err != nil {
		return fmt.Errorf("failed to list providers: %w", err)
	}

	defaultProvider := providers.GetDefaultProvider()
	fmt.Println("Available providers:")
	for _, name := range providerList {
		details, exists := providers.GetProviderDetails(name)
		if !exists {
			continue
		}
		marker := " "
		if name == defaultProvider {
			marker = "*"
		}
		argsStr := ""
		if len(details.Args) > 0 {
			argsStr = fmt.Sprintf(" %s", strings.Join(details.Args, " "))
		}
		fmt.Printf("  %s %s: %s%s\n", marker, name, details.Command, argsStr)
	}
	fmt.Printf("\n  * = default provider\n")
	fmt.Printf("\nConfig file: ~/.commitgen/config.json\n")
	return nil
}

func setDefaultProvider(c *cli.Context) error {
	if c.Args().Len() == 0 {
		return ErrProviderName
	}
	name := c.Args().First()
	if err := providers.SetDefaultProvider(name); err != nil {
		return fmt.Errorf("failed to set default provider: %w", err)
	}
	fmt.Printf("Default provider set to: %s\n", name)
	return nil
}

func addProvider(ctx *cli.Context) error {
	if ctx.Args().Len() == 0 {
		return ErrProviderName
	}
	name := ctx.Args().First()
	command := ctx.String("command")
	args := ctx.StringSlice("args")

	provider := providers.Provider{
		Command: command,
		Args:    args,
	}

	if err := providers.AddProvider(name, provider); err != nil {
		return fmt.Errorf("failed to add provider: %w", err)
	}
	fmt.Printf("Provider '%s' added: %s %s\n", name, command, strings.Join(args, " "))
	return nil
}

func removeProvider(ctx *cli.Context) error {
	if ctx.Args().Len() == 0 {
		return ErrProviderName
	}
	name := ctx.Args().First()
	if err := providers.RemoveProvider(name); err != nil {
		return fmt.Errorf("failed to remove provider: %w", err)
	}
	fmt.Printf("Provider '%s' removed\n", name)
	return nil
}

func installBinary(c *cli.Context) error {
	exePath, err := os.Executable()
	if err != nil {
		return fmt.Errorf("failed to get executable path: %w", err)
	}

	installPath := "/usr/local/bin/commitgen"

	// Check if we have permission to write to /usr/local/bin
	if _, err := os.Stat("/usr/local/bin"); os.IsPermission(err) {
		return ErrPermissionDenied
	}

	// Copy binary to install path
	if !validateFilePath(exePath) {
		return fmt.Errorf("%w: invalid executable path: %s", ErrPermissionDenied, exePath)
	}
	//nolint:gosec // G304: exePath is validated by validateFilePath()
	source, err := os.Open(exePath)
	if err != nil {
		return fmt.Errorf("failed to open source file: %w", err)
	}
	defer func() {
		if closeErr := source.Close(); closeErr != nil {
			fmt.Printf("Warning: failed to close source file: %v\n", closeErr)
		}
	}()

	destination, err := os.Create(installPath)
	if err != nil {
		return fmt.Errorf("failed to create destination file: %w", err)
	}
	defer func() {
		if closeErr := destination.Close(); closeErr != nil {
			fmt.Printf("Warning: failed to close destination file: %v\n", closeErr)
		}
	}()

	_, err = io.Copy(destination, source)
	if err != nil {
		return fmt.Errorf("failed to copy file content: %w", err)
	}

	// Make it executable (0755 is appropriate for system binaries in /usr/local/bin)
	// This allows read and execute by all users, but write only by owner
	//nolint:gosec // G302: 0755 is appropriate for system binaries
	err = os.Chmod(installPath, 0o755)
	if err != nil {
		return fmt.Errorf("failed to set file permissions: %w", err)
	}

	fmt.Printf("Commitgen installed successfully to %s\n", installPath)
	fmt.Println("You can now use 'commitgen' from anywhere!")
	return nil
}