main.go

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"sort"
	"strconv"
	"time"
)

type GitHubRepo struct {
	Name        string    `json:"name"`
	FullName    string    `json:"full_name"`
	Description string    `json:"description"`
	HTMLURL     string    `json:"html_url"`
	Language    string    `json:"language"`
	CreatedAt   time.Time `json:"created_at"`
	UpdatedAt   time.Time `json:"updated_at"`
	PushedAt    time.Time `json:"pushed_at"`
	StarCount   int       `json:"stargazers_count"`
	ForkCount   int       `json:"forks_count"`
	Private     bool      `json:"private"`
	Fork        bool      `json:"fork"`
	Archived    bool      `json:"archived"`
}

type RepoResponse struct {
	Repos []GitHubRepo `json:"repos"`
	Total int          `json:"total"`
}

type ErrorResponse struct {
	Error string `json:"error"`
}

func fetchRepos(username, token string) ([]GitHubRepo, error) {
	var allRepos []GitHubRepo
	page := 1

	client := &http.Client{Timeout: 15 * time.Second}

	for {
		url := fmt.Sprintf("https://api.github.com/users/%s/repos?per_page=100&page=%d&type=all", username, page)

		if token != "" {
			url = fmt.Sprintf("https://api.github.com/user/repos?per_page=100&page=%d&affiliation=owner", page)
		}

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

		req.Header.Set("Accept", "application/vnd.github.v3+json")
		req.Header.Set("User-Agent", "github-timeline-app")

		if token != "" {
			req.Header.Set("Authorization", "Bearer "+token)
		}

		resp, err := client.Do(req)
		if err != nil {
			return nil, fmt.Errorf("failed to fetch repos: %w", err)
		}

		if resp.StatusCode == http.StatusUnauthorized {
			resp.Body.Close()
			return nil, fmt.Errorf("invalid token or unauthorized access")
		}

		if resp.StatusCode == http.StatusForbidden {
			resp.Body.Close()
			return nil, fmt.Errorf("rate limit exceeded or access forbidden")
		}

		if resp.StatusCode == http.StatusNotFound {
			resp.Body.Close()
			return nil, fmt.Errorf("user '%s' not found", username)
		}

		if resp.StatusCode != http.StatusOK {
			resp.Body.Close()
			return nil, fmt.Errorf("GitHub API returned status %d", resp.StatusCode)
		}

		body, err := io.ReadAll(resp.Body)
		resp.Body.Close()
		if err != nil {
			return nil, fmt.Errorf("failed to read response: %w", err)
		}

		var repos []GitHubRepo
		if err := json.Unmarshal(body, &repos); err != nil {
			return nil, fmt.Errorf("failed to parse response: %w", err)
		}

		if len(repos) == 0 {
			break
		}

		allRepos = append(allRepos, repos...)

		remaining := resp.Header.Get("X-RateLimit-Remaining")
		if remaining == "0" {
			resetStr := resp.Header.Get("X-RateLimit-Reset")
			resetUnix, _ := strconv.ParseInt(resetStr, 10, 64)
			resetTime := time.Unix(resetUnix, 0)
			return nil, fmt.Errorf("rate limit exceeded, resets at %s", resetTime.Format("15:04:05"))
		}

		if len(repos) < 100 {
			break
		}

		page++
	}

	sort.Slice(allRepos, func(i, j int) bool {
		return allRepos[i].CreatedAt.Before(allRepos[j].CreatedAt)
	})

	return allRepos, nil
}

func handleRepos(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")

	if r.Method != http.MethodGet {
		w.WriteHeader(http.StatusMethodNotAllowed)
		json.NewEncoder(w).Encode(ErrorResponse{Error: "Method not allowed"})
		return
	}

	username := r.URL.Query().Get("username")
	token := r.URL.Query().Get("token")

	if username == "" && token == "" {
		w.WriteHeader(http.StatusBadRequest)
		json.NewEncoder(w).Encode(ErrorResponse{Error: "Username is required"})
		return
	}

	repos, err := fetchRepos(username, token)
	if err != nil {
		w.WriteHeader(http.StatusBadGateway)
		json.NewEncoder(w).Encode(ErrorResponse{Error: err.Error()})
		return
	}

	json.NewEncoder(w).Encode(RepoResponse{
		Repos: repos,
		Total: len(repos),
	})
}

func main() {
	fs := http.FileServer(http.Dir("static"))
	http.Handle("/", fs)
	http.HandleFunc("/api/repos", handleRepos)

	port := ":3000"
	log.Printf("Server starting on http://localhost%s", port)
	log.Fatal(http.ListenAndServe(port, nil))
}