markedit / backend / internal / git / branch_manager.go

package git

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"time"

	"github.com/go-git/go-git/v5"
	"github.com/yourusername/markedit/internal/database"
)

// BranchManager handles branch lifecycle management
type BranchManager struct {
	db  *database.DB
	git *GitOperations
}

// NewBranchManager creates a new BranchManager
func NewBranchManager(db *database.DB, git *GitOperations) *BranchManager {
	return &BranchManager{
		db:  db,
		git: git,
	}
}

// GetOrCreateBranch returns an existing branch or creates a new one based on the 4-hour rule
func (bm *BranchManager) GetOrCreateBranch(
	ctx context.Context,
	userID int,
	repoFullName string,
	repo *git.Repository,
	baseBranch string,
) (string, error) {
	// Check database for existing branch state
	state, err := bm.db.GetBranchState(userID, repoFullName)
	if err != nil {
		return "", fmt.Errorf("failed to get branch state: %w", err)
	}

	// No existing branch state - create new branch
	if state == nil {
		return bm.createNewBranch(ctx, userID, repoFullName, repo, baseBranch)
	}

	// Calculate time since last push
	hoursSincePush := time.Since(state.LastPushAt).Hours()

	// If more than 4 hours have passed and no uncommitted changes, create new branch
	if hoursSincePush > 4 && !state.HasUncommittedChanges {
		log.Printf("Branch %s is older than 4 hours (%.1f hours), creating new branch", state.BranchName, hoursSincePush)

		// Delete old branch locally
		_ = bm.git.DeleteLocalBranch(repo, state.BranchName)

		// Delete old branch state
		_ = bm.db.DeleteBranchState(userID, repoFullName)

		return bm.createNewBranch(ctx, userID, repoFullName, repo, baseBranch)
	}

	// Reuse existing branch
	log.Printf("Reusing existing branch %s (%.1f hours old)", state.BranchName, hoursSincePush)

	// Checkout the existing branch
	if err := bm.git.CheckoutBranch(repo, state.BranchName); err != nil {
		// If checkout fails, create new branch
		log.Printf("Failed to checkout existing branch, creating new one: %v", err)
		return bm.createNewBranch(ctx, userID, repoFullName, repo, baseBranch)
	}

	return state.BranchName, nil
}

// createNewBranch creates a new branch and saves its state
func (bm *BranchManager) createNewBranch(
	ctx context.Context,
	userID int,
	repoFullName string,
	repo *git.Repository,
	baseBranch string,
) (string, error) {
	// Generate branch name with timestamp
	branchName := fmt.Sprintf("markedit-%d", time.Now().Unix())

	log.Printf("Creating new branch: %s", branchName)

	// Create branch in git
	if err := bm.git.CreateBranch(repo, branchName, baseBranch); err != nil {
		return "", fmt.Errorf("failed to create branch: %w", err)
	}

	// Save branch state to database
	state := &database.BranchState{
		UserID:                userID,
		RepoFullName:          repoFullName,
		BranchName:            branchName,
		BaseBranch:            baseBranch,
		LastPushAt:            time.Now(),
		HasUncommittedChanges: false,
		FilePaths:             "[]", // Empty JSON array
	}

	if err := bm.db.SaveBranchState(state); err != nil {
		return "", fmt.Errorf("failed to save branch state: %w", err)
	}

	return branchName, nil
}

// UpdateBranchState updates the branch state after changes
func (bm *BranchManager) UpdateBranchState(
	userID int,
	repoFullName string,
	branchName string,
	filePaths []string,
	hasUncommittedChanges bool,
) error {
	// Get existing state
	state, err := bm.db.GetBranchState(userID, repoFullName)
	if err != nil {
		return fmt.Errorf("failed to get branch state: %w", err)
	}

	if state == nil {
		return fmt.Errorf("branch state not found")
	}

	// Update state
	state.HasUncommittedChanges = hasUncommittedChanges
	if filePaths != nil {
		filePathsJSON, err := json.Marshal(filePaths)
		if err != nil {
			return fmt.Errorf("failed to marshal file paths: %w", err)
		}
		state.FilePaths = string(filePathsJSON)
	}

	if !hasUncommittedChanges {
		// Reset last push time if we just committed/pushed
		state.LastPushAt = time.Now()
	}

	if err := bm.db.SaveBranchState(state); err != nil {
		return fmt.Errorf("failed to update branch state: %w", err)
	}

	return nil
}

// HandleConflict handles merge conflicts by creating a new branch
func (bm *BranchManager) HandleConflict(
	ctx context.Context,
	userID int,
	repoFullName string,
	repo *git.Repository,
	baseBranch string,
) (string, error) {
	log.Printf("Handling conflict for %s, creating new branch", repoFullName)

	// Get current state
	state, _ := bm.db.GetBranchState(userID, repoFullName)

	// Delete old branch locally if it exists
	if state != nil {
		_ = bm.git.DeleteLocalBranch(repo, state.BranchName)
	}

	// Delete old state
	_ = bm.db.DeleteBranchState(userID, repoFullName)

	// Create new branch
	return bm.createNewBranch(ctx, userID, repoFullName, repo, baseBranch)
}