main.go

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"

	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/widget"

	"crypto/sha1"
	"encoding/hex"
	"encoding/json"
	"path"
)

// Types
type Settings struct {
	RepoURL     string `json:"repoURL"`
	GithubToken string `json:"githubToken"`
}

type UpdateInfo struct {
	Path string
	SHA  string
}

type GitHubContent struct {
	Type    string `json:"type"`
	Path    string `json:"path"`
	SHA     string `json:"sha"`
	Content string `json:"content"`
}

// Settings functions
func loadSettings() (*Settings, error) {
	data, err := os.ReadFile("gitfetch.settings.json")
	if err != nil {
		return nil, err
	}

	var settings Settings
	if err := json.Unmarshal(data, &settings); err != nil {
		return nil, err
	}

	return &settings, nil
}

// GitHub API functions
func checkForUpdates(url, targetDir string) ([]UpdateInfo, error) {
	apiURL := strings.Replace(url, "github.com", "api.github.com/repos", 1) + "/contents"

	req, err := http.NewRequest("GET", apiURL, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create API request: %w", err)
	}

	if settings, err := loadSettings(); err == nil && settings.GithubToken != "" {
		req.Header.Add("Authorization", "token "+settings.GithubToken)
	}
	req.Header.Add("Accept", "application/vnd.github.v3+json")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("failed to fetch repository contents: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		return nil, fmt.Errorf("failed to fetch repository contents: status code %d, response: %s", resp.StatusCode, string(body))
	}

	var contents []GitHubContent
	if err := json.NewDecoder(resp.Body).Decode(&contents); err != nil {
		return nil, fmt.Errorf("failed to parse repository contents: %w", err)
	}

	var updates []UpdateInfo
	for _, content := range contents {
		localPath := path.Join(targetDir, content.Path)
		if localHash, err := getFileHash(localPath); err != nil || localHash != content.SHA {
			updates = append(updates, UpdateInfo{Path: content.Path, SHA: content.SHA})
		}
	}

	return updates, nil
}

func syncRepository(url, targetDir string, updates []UpdateInfo, progress chan<- string) error {
	apiURL := strings.Replace(url, "github.com", "api.github.com/repos", 1) + "/contents"

	for _, update := range updates {
		fileURL := strings.Replace(apiURL, "/contents", "/contents/"+update.Path, 1)
		if err := fetchFileContent(fileURL, path.Join(targetDir, update.Path)); err != nil {
			return fmt.Errorf("failed to download %s: %w", update.Path, err)
		}
		progress <- update.Path
	}

	return nil
}

func fetchFileContent(url, targetPath string) error {
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return err
	}

	if settings, err := loadSettings(); err == nil && settings.GithubToken != "" {
		req.Header.Add("Authorization", "token "+settings.GithubToken)
	}
	req.Header.Add("Accept", "application/vnd.github.v3.raw")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return fmt.Errorf("HTTP %d", resp.StatusCode)
	}

	if err := os.MkdirAll(path.Dir(targetPath), 0755); err != nil {
		return err
	}

	out, err := os.Create(targetPath)
	if err != nil {
		return err
	}
	defer out.Close()

	_, err = io.Copy(out, resp.Body)
	return err
}

func getFileHash(path string) (string, error) {
	file, err := os.Open(path)
	if err != nil {
		return "", err
	}
	defer file.Close()

	content, err := io.ReadAll(file)
	if err != nil {
		return "", err
	}

	hash := sha1.New()
	header := fmt.Sprintf("blob %d\x00", len(content))
	hash.Write([]byte(header))
	hash.Write(content)

	return hex.EncodeToString(hash.Sum(nil)), nil
}

// UI functions
func main() {
	settings, err := loadSettings()
	if err != nil {
		fmt.Printf("Error loading settings: %v\n", err)
		os.Exit(1)
	}

	myApp := app.New()
	window := myApp.NewWindow("GitHub Repository Downloader")

	filesList := widget.NewMultiLineEntry()
	filesList.Wrapping = fyne.TextWrapBreak
	filesList.SetMinRowsVisible(10)
	filesList.TextStyle = fyne.TextStyle{Monospace: true}

	var storedText string
	setFilesListText := func(text string) {
		storedText = text
		filesList.SetText(text)
	}
	filesList.OnChanged = func(s string) {
		filesList.SetText(storedText)
	}

	progress := widget.NewProgressBar()
	updateProgress := func(value float64, message string) {
		progress.SetValue(value)
		if message != "" {
			setFilesListText(message)
		}
	}

	downloadBtn := widget.NewButton("Checking...", nil)
	downloadBtn.Disable()

	content := container.NewVBox(
		progress,
		filesList,
		downloadBtn,
	)

	window.SetContent(content)

	// Check for updates on launch
	go func() {
		updates, err := checkForUpdates(settings.RepoURL, ".")
		if err != nil {
			setFilesListText("Error: " + err.Error())
			downloadBtn.SetText("Retry")
			downloadBtn.OnTapped = func() {
				downloadBtn.Disable()
				setFilesListText("Checking for updates...")
				downloadBtn.SetText("Checking...")
				filesList.SetText("")
			}
			downloadBtn.Enable()
			return
		}

		if len(updates) > 0 {
			setFilesListText(fmt.Sprintf("Update available (%d files)", len(updates)))
			var filesText strings.Builder
			filesText.WriteString("Files to update:\n\n")
			for _, update := range updates {
				filesText.WriteString("• " + update.Path + "\n")
			}
			setFilesListText(filesText.String())

			downloadBtn.SetText("Download")
			downloadBtn.OnTapped = func() {
				downloadBtn.Disable()
				updateProgress(0, "Starting download...")

				totalFiles := len(updates)
				progressChan := make(chan string)

				go func() {
					defer close(progressChan)
					if err := syncRepository(settings.RepoURL, ".", updates, progressChan); err != nil {
						updateProgress(0, "Error: "+err.Error())
						downloadBtn.SetText("Retry")
						downloadBtn.Enable()
						return
					}
				}()

				go func() {
					var count int
					for file := range progressChan {
						count++
						if count == totalFiles {
							updateProgress(1.0, "Update complete!")
							downloadBtn.SetText("Up to date")
							downloadBtn.Disable()
						} else {
							updateProgress(
								float64(count)/float64(totalFiles),
								fmt.Sprintf("Downloading... (%d/%d)\n%s", count, totalFiles, file),
							)
						}
					}
				}()
			}
			downloadBtn.Enable()
		} else {
			updateProgress(1.0, "Already up to date")
			downloadBtn.SetText("Up to date")
			downloadBtn.Disable()
		}
	}()

	window.Resize(fyne.NewSize(400, 250))
	window.ShowAndRun()
}