Goit

// Copyright (C) 2023, Jakob Wakeling

// All rights reserved.

package goit

import (

	"archive/zip"

	"database/sql"

	"encoding/json"

	"errors"

	"fmt"

	"io"

	"io/fs"

	"log"

	"os"

	"path/filepath"

	"slices"

	"strings"

	"time"

	"github.com/Jamozed/Goit/res"

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

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

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

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

	_ "github.com/mattn/go-sqlite3"

)

var Conf config

var db *sql.DB

var Favicon []byte

var Cron *cron.Cron

var Reserved []string = []string{"admin", "repo", "static", "user"}

var StartTime = time.Now()

func Goit() error {

	if conf, err := loadConfig(); err != nil {

		return err

	} else {

		Conf = conf

	}

	if err := os.MkdirAll(Conf.LogsPath, 0o777); err != nil {

		return fmt.Errorf("[config] %w", err)

	}

	logFile, err := os.Create(filepath.Join(Conf.LogsPath, fmt.Sprint("goit_", time.Now().Unix(), ".log")))

	if err != nil {

		log.Fatalln("[log]", err.Error())

	}

	log.SetOutput(io.MultiWriter(os.Stderr, logFile))

	log.Println("Starting Goit", res.Version)

	log.Println("[Config] using data path:", Conf.DataPath)

	if err := os.MkdirAll(Conf.DataPath, 0o777); err != nil {

		return fmt.Errorf("[config] %w", err)

	}

	if dat, err := os.ReadFile(filepath.Join(Conf.DataPath, "favicon.png")); err != nil {

		log.Println("[favicon]", err.Error())

	} else {

		Favicon = dat

	}

	if db, err = sql.Open("sqlite3", filepath.Join(Conf.DataPath, "goit.db?_timeout=5000")); err != nil {

		return fmt.Errorf("[database] %w", err)

	}

	/* Update the database if necessary */

	if err := updateDatabase(db); err != nil {

		return fmt.Errorf("[database] %w", err)

	}

	/* Create an admin user if one does not exist */

	if exists, err := UserExists("admin"); err != nil {

		log.Println("[admin:exists]", err.Error())

		err = nil /* ignored */

	} else if !exists {

		if salt, err := Salt(); err != nil {

			log.Println("[admin:salt]", err.Error())

			err = nil /* ignored */

		} else if _, err = db.Exec(

			"INSERT INTO users (id, name, name_full, pass, pass_algo, salt, is_admin) VALUES (?, ?, ?, ?, ?, ?, ?)",

			0, "admin", "Administrator", Hash("admin", salt), "argon2", salt, true,

		); err != nil {

			log.Println("[admin:INSERT]", err.Error())

			err = nil /* ignored */

		}

	}

	/* Initialise and start the cron service */

	Cron = cron.New()

	Cron.Start()

	/* Periodically clean up expired sessions */

	Cron.Add(-1, cron.Hourly, CleanupSessions)

	/* Add cron jobs for mirror repositories */

	repos, err := GetRepos()

	if err != nil {

		return err

	}

	for _, r := range repos {

		if r.IsMirror {

			util.Debugln("Adding mirror cron job for", r.Name)

			rid, name := r.Id, r.Name

			Cron.Add(r.Id, cron.Daily, func() {

				if err := Pull(rid); err != nil {

					log.Println("[cron:mirror]", rid, name, err.Error())

				} else {

					log.Println("[cron:mirror] updated", rid, name)

				}

			})

		}

	}

	Cron.Update()

	return nil

}

func RepoPath(name string, abs bool) string {

	return util.If(abs, filepath.Join(Conf.DataPath, "repos", name+".git"), filepath.Join(name+".git"))

}

func IsLegal(s string) bool {

	for i := 0; i < len(s); i += 1 {

		if !slices.Contains([]byte("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.~/"), s[i]) {

			return false

		}

	}

	return true

}

func Backup() error {

	if conf, err := loadConfig(); err != nil {

		return err

	} else {

		Conf = conf

	}

	data := struct {

		Users []User `json:"users"`

		Repos []Repo `json:"repos"`

	}{}

	bdir := filepath.Join(Conf.DataPath, "backup")

	if err := os.MkdirAll(bdir, 0o777); err != nil {

		return err

	}

	db, err := sql.Open("sqlite3", filepath.Join(Conf.DataPath, "goit.db?_timeout=5000&_txlock=immediate"))

	if err != nil {

		return err

	}

	tx, err := db.Begin()

	if err != nil {

		return err

	}

	defer tx.Rollback()

	/* Dump users */

	rows, err := tx.Query("SELECT id, name, name_full, pass, pass_algo, salt, is_admin FROM users")

	if err != nil {

		return err

	}

	defer rows.Close()

	for rows.Next() {

		u := User{}

		if err := rows.Scan(&u.Id, &u.Name, &u.FullName, &u.Pass, &u.PassAlgo, &u.Salt, &u.IsAdmin); err != nil {

			return err

		}

		data.Users = append(data.Users, u)

	}

	/* Dump repositories */

	rows, err = tx.Query(

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

	)

	if err != nil {

		return 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 err

		}

		data.Repos = append(data.Repos, r)

	}

	/* Open an output ZIP file */

	ts := "goit_" + time.Now().UTC().Format("20060102T150405Z")

	log.Println("Backing up to", filepath.Join(bdir, ts+".zip"))

	zf, err := os.Create(filepath.Join(bdir, ts+".zip"))

	if err != nil {

		return err

	}

	defer zf.Close()

	zw := zip.NewWriter(zf)

	defer zw.Close()

	/* Copy repositories to ZIP */

	tempdir, err := os.MkdirTemp(os.TempDir(), "goit-")

	if err != nil {

		return err

	}

	defer os.RemoveAll(tempdir)

	for _, r := range data.Repos {

		t0 := time.Now()

		cd := filepath.Join(tempdir, RepoPath(r.Name, false))

		gr, err := git.PlainClone(cd, true, &git.CloneOptions{

			URL: RepoPath(r.Name, true), Mirror: true,

		})

		if err != nil {

			if errors.Is(err, transport.ErrRepositoryNotFound) {

				log.Println("Skipping", r.Name, "as it does not exist")

				continue

			}

			if errors.Is(err, transport.ErrEmptyRemoteRepository) {

				log.Println("Skipping", r.Name, "as it is empty")

				continue

			}

			return err

		}

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

			return fmt.Errorf("%s %w", cd, err)

		}

		/* Walk duplicated repository and add it to the ZIP */

		if err = filepath.WalkDir(cd, func(path string, d fs.DirEntry, err error) error {

			if err != nil {

				return err

			}

			info, err := d.Info()

			if err != nil {

				return err

			}

			head, err := zip.FileInfoHeader(info)

			if err != nil {

				return err

			}

			head.Name = filepath.Join(ts, "repos", strings.TrimPrefix(path, tempdir))

			if d.IsDir() {

				head.Name += "/"

			} else {

				head.Method = zip.Store

			}

			w, err := zw.CreateHeader(head)

			if err != nil {

				return err

			}

			if !d.IsDir() {

				fi, err := os.Open(path)

				if err != nil {

					return err

				}

				if _, err := io.Copy(w, fi); err != nil {

					return err

				}

			}

			return nil

		}); err != nil {

			return err

		}

		os.RemoveAll(cd)

		log.Println("Backed up", r.Name, "in", time.Since(t0))

	}

	/* Write database as JSON to ZIP */

	if b, err := json.MarshalIndent(data, "", "\t"); err != nil {

		return err

	} else if w, err := zw.Create(filepath.Join(ts, "goit.json")); err != nil {

		return err

	} else if _, err := w.Write(b); err != nil {

		return err

	}

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

		return err

	}

	return nil

}