Goit

// Copyright (C) 2023, Jakob Wakeling

// All rights reserved.

package goit

import (

	"database/sql"

	"errors"

	"log"

	"os"

	"path/filepath"

	"strings"

	"github.com/Jamozed/Goit/src/util"

	"github.com/go-git/go-git/v5"

	gitconfig "github.com/go-git/go-git/v5/config"

	"github.com/go-git/go-git/v5/plumbing"

)

type Repo struct {

	Id            int64      `json:"id"`

	OwnerId       int64      `json:"owner_id"`

	Name          string     `json:"name"`

	Description   string     `json:"description"`

	DefaultBranch string     `json:"default_branch"`

	Upstream      string     `json:"upstream"`

	Visibility    Visibility `json:"visibility"`

	IsMirror      bool       `json:"is_mirror"`

}

type Visibility int32

const (

	Public  Visibility = 0

	Private Visibility = 1

	Limited Visibility = 2

)

func VisibilityFromString(s string) Visibility {

	switch strings.ToLower(s) {

	case "public":

		return Public

	case "private":

		return Private

	case "limited":

		return Limited

	default:

		return -1

	}

}

func (v Visibility) String() string {

	return [...]string{"public", "private", "limited"}[v]

}

func GetRepos() ([]Repo, error) {

	repos := []Repo{}

	rows, err := db.Query(

		"SELECT id, owner_id, name, description, default_branch, upstream, visibility, is_mirror FROM repos",

	)

	if err != nil {

		return nil, err

	}

	defer rows.Close()

	for rows.Next() {

		r := Repo{}

		if err := rows.Scan(

			&r.Id, &r.OwnerId, &r.Name, &r.Description, &r.DefaultBranch, &r.Upstream, &r.Visibility, &r.IsMirror,

		); err != nil {

			return nil, err

		}

		repos = append(repos, r)

	}

	if rows.Err() != nil {

		return nil, err

	}

	return repos, nil

}

func GetRepo(rid int64) (*Repo, error) {

	r := &Repo{}

	if err := db.QueryRow(

		`SELECT id, owner_id, name, description, default_branch, upstream, visibility, is_mirror FROM repos

		WHERE id = ?`, rid,

	).Scan(

		&r.Id, &r.OwnerId, &r.Name, &r.Description, &r.DefaultBranch, &r.Upstream, &r.Visibility, &r.IsMirror,

	); err != nil {

		if !errors.Is(err, sql.ErrNoRows) {

			return nil, err

		}

		return nil, nil

	} else {

		return r, nil

	}

}

func GetRepoByName(name string) (*Repo, error) {

	r := &Repo{}

	if err := db.QueryRow(

		`SELECT id, owner_id, name, description, default_branch, upstream, visibility, is_mirror FROM repos

		WHERE name = ?`, name,

	).Scan(

		&r.Id, &r.OwnerId, &r.Name, &r.Description, &r.DefaultBranch, &r.Upstream, &r.Visibility, &r.IsMirror,

	); err != nil {

		if !errors.Is(err, sql.ErrNoRows) {

			return nil, err

		}

		return nil, nil

	}

	return r, nil

}

func CreateRepo(repo Repo) (int64, error) {

	tx, err := db.Begin()

	if err != nil {

		return -1, err

	}

	defer tx.Rollback()

	res, err := tx.Exec(

		`INSERT INTO repos (owner_id, name, name_lower, description, default_branch, upstream, visibility, is_mirror)

		VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, repo.OwnerId, repo.Name, strings.ToLower(repo.Name), repo.Description,

		repo.DefaultBranch, repo.Upstream, repo.Visibility, repo.IsMirror,

	)

	if err != nil {

		return -1, err

	}

	r, err := git.PlainInit(RepoPath(repo.Name, true), true)

	if err != nil {

		return -1, err

	}

	ref := plumbing.NewSymbolicReference(plumbing.HEAD, plumbing.NewBranchReferenceName(repo.DefaultBranch))

	if err := r.Storer.SetReference(ref); err != nil {

		os.RemoveAll(RepoPath(repo.Name, true))

		return -1, err

	}

	if repo.Upstream != "" {

		if _, err := r.CreateRemote(&gitconfig.RemoteConfig{

			Name:   "origin",

			URLs:   []string{repo.Upstream},

			Mirror: util.If(repo.IsMirror, true, false),

			Fetch:  []gitconfig.RefSpec{gitconfig.RefSpec("+refs/heads/*:refs/heads/*")},

		}); err != nil {

			os.RemoveAll(RepoPath(repo.Name, true))

			return -1, err

		}

	}

	if err := tx.Commit(); err != nil {

		os.RemoveAll(RepoPath(repo.Name, true))

		return -1, err

	}

	rid, _ := res.LastInsertId()

	return rid, nil

}

func DelRepo(rid int64) error {

	repo, err := GetRepo(rid)

	if err != nil {

		return err

	}

	if err := os.RemoveAll(RepoPath(repo.Name, true)); err != nil {

		return err

	}

	if _, err := db.Exec("DELETE FROM repos WHERE id = ?", rid); err != nil {

		return err

	}

	Cron.RemoveFor(rid)

	Cron.Update()

	return nil

}

func RepoExists(name string) (bool, error) {

	if err := db.QueryRow(

		"SELECT name FROM repos WHERE name_lower = ?", strings.ToLower(name),

	).Scan(&name); err != nil {

		if !errors.Is(err, sql.ErrNoRows) {

			return false, err

		} else {

			return false, nil

		}

	} else {

		return true, nil

	}

}

func UpdateRepo(rid int64, repo Repo) error {

	old, err := GetRepo(rid)

	if err != nil {

		return err

	}

	tx, err := db.Begin()

	if err != nil {

		return err

	}

	defer tx.Rollback()

	if _, err := tx.Exec(

		`UPDATE repos SET name = ?, name_lower = ?, description = ?, default_branch = ?, upstream = ?, visibility = ?,

		is_mirror = ? WHERE id = ?`, repo.Name, strings.ToLower(repo.Name), repo.Description, repo.DefaultBranch,

		repo.Upstream, repo.Visibility, repo.IsMirror, rid,

	); err != nil {

		return err

	}

	if repo.Name != old.Name {

		if err := os.MkdirAll(filepath.Dir(RepoPath(repo.Name, true)), 0o777); err != nil {

			return err

		}

		if err := os.Rename(RepoPath(old.Name, true), RepoPath(repo.Name, true)); err != nil {

			return err

		}

	}

	var r *git.Repository

	if repo.DefaultBranch != old.DefaultBranch {

		// if r == nil {

		r, err = git.PlainOpen(RepoPath(repo.Name, true))

		if err != nil {

			return err

		}

		// }

		ref := plumbing.NewSymbolicReference(plumbing.HEAD, plumbing.NewBranchReferenceName(repo.DefaultBranch))

		if err := r.Storer.SetReference(ref); err != nil {

			return err

		}

	}

	/* If the upstream URL has been removed, remove the remote */

	if repo.Upstream == "" && old.Upstream != "" {

		if r == nil {

			r, err = git.PlainOpen(RepoPath(repo.Name, true))

			if err != nil {

				return err

			}

		}

		if err := r.DeleteRemote("origin"); err != nil {

			return err

		}

	}

	/* If the upstream URL has been added or changed, update the remote */

	if repo.Upstream != "" && repo.Upstream != old.Upstream {

		if r == nil {

			r, err = git.PlainOpen(RepoPath(repo.Name, true))

			if err != nil {

				return err

			}

		}

		if err := r.DeleteRemote("origin"); err != nil && !errors.Is(err, git.ErrRemoteNotFound) {

			return err

		}

		if _, err := r.CreateRemote(&gitconfig.RemoteConfig{

			Name:   "origin",

			URLs:   []string{repo.Upstream},

			Mirror: util.If(repo.IsMirror, true, false),

			Fetch:  []gitconfig.RefSpec{gitconfig.RefSpec("+refs/heads/*:refs/heads/*")},

		}); err != nil {

			log.Println("[repo/update]", err.Error())

		}

	}

	if err := tx.Commit(); err != nil {

		os.Rename(RepoPath(repo.Name, true), RepoPath(old.Name, true))

		log.Println("[repo/update]", "error while editing, check repo \""+old.Name+"\"/\""+repo.Name+"\"")

		return err

	}

	return nil

}

func ChownRepo(rid int64, uid int64) error {

	if _, err := db.Exec("UPDATE repos SET owner_id = ? WHERE id = ?", uid, rid); err != nil {

		return err

	}

	return nil

}

func Pull(rid int64) error {

	repo, err := GetRepo(rid)

	if err != nil {

		return err

	}

	r, err := git.PlainOpen(RepoPath(repo.Name, true))

	if err != nil {

		return err

	}

	if err := r.Fetch(&git.FetchOptions{}); err != nil {

		return err

	}

	return nil

}

func IsVisible(repo *Repo, auth bool, user *User) bool {

	if repo.Visibility == Public || (repo.Visibility == Limited && auth) || (auth && user.Id == repo.OwnerId) {

		return true

	}

	return false

}