package routes

import (
	"fmt"
	"io/fs"
	"log"
	"net"
	"path"
	"path/filepath"
	"strconv"
	"strings"
	"time"

	"github.com/fsnotify/fsnotify"
	"github.com/savsgio/atreugo/v11"
	"github.com/valyala/fasthttp"

	"alin.ovh/elgit/config"
)

var (
	ErrMethodNotAllowed = fmt.Errorf("that's not possible")
	ErrNotFound         = fmt.Errorf("nothing like that here")
)

func Handlers(c *config.Config, staticFiles fs.FS) *atreugo.Atreugo {
	d := deps{
		c: c,
	}

	addr := net.JoinHostPort(c.Server.Host, strconv.FormatInt(c.Server.Port, 10))
	cfg := atreugo.Config{
		Addr:                         addr,
		Name:                         c.Server.Name,
		Compress:                     c.Server.Compress,
		Logger:                       log.Default(),
		NotFoundView:                 d.NotFound,
		MethodNotAllowedView:         nil,
		ErrorView:                    d.Error,
		PanicView:                    d.Panic,
		ReadTimeout:                  5 * time.Second,
		DisablePreParseMultipartForm: true,
		GracefulShutdown:             !c.Server.Development,
		CloseOnShutdown:              !c.Server.Development,
		StreamRequestBody:            true,
	}
	if strings.Contains(c.Server.Host, ":") {
		cfg.Network = "tcp6"
	}
	if c.Server.Development {
		cfg.PanicView = nil
	}
	srv := atreugo.New(cfg)

	watcher, err := fsnotify.NewWatcher()
	if err != nil {
		log.Fatal(err)
	}

	plist := filepath.Join(c.Repo.Root, "projects.list")

	d.projects, err = ReadProjectsList(plist)
	if err != nil {
		log.Fatal(err)
	}

	err = watcher.Add(plist)
	if err != nil {
		log.Fatal(err)
	}

	go func() {
		for {
			select {
			case event, ok := <-watcher.Events:
				if !ok {
					continue
				}
				if event.Op.Has(fsnotify.Write) {
					d.projects, err = ReadProjectsList(plist)
					if err != nil {
						log.Println(err)
					}
				}
			case err, ok := <-watcher.Errors:
				if !ok {
					continue
				}
				log.Println("error:", err)
			}
		}
	}()

	go func() {
		d.UpdateRepos()
		for range time.Tick(time.Minute) {
			d.UpdateRepos()
		}
	}()

	d.mountRepoPaths(srv.NewGroupPath("/{name}"))
	d.mountRepoPaths(srv.NewGroupPath("/{category}/{name}"))

	srv.StaticFS("/static/", staticFiles)
	srv.GET("/", d.Index)
	srv.GET("/favicon.ico", func(rc *atreugo.RequestCtx) error {
		return rc.TextResponse(
			fasthttp.StatusMessage(fasthttp.StatusNoContent),
			fasthttp.StatusNoContent,
		)
	})

	return srv
}

func (d deps) mountRepoPaths(router *atreugo.Router) {
	router.UseBefore(func(rc *atreugo.RequestCtx) error {
		category, _ := rc.UserValue("category").(string)
		name, _ := rc.UserValue("name").(string)
		repoName := path.Join(category, name)

		if d.isNotAllowed(repoName) {
			log.Printf("access not allowed: %s", repoName)

			return ErrNotFound
		}
		path, err := d.GetCleanPath(repoName)
		if err != nil {
			log.Printf("getcleanpath error: %v", err)

			return ErrNotFound
		}

		rc.SetUserValue("repoName", repoName)
		rc.SetUserValue("repoPath", path)

		return rc.Next()
	})
	router.GET("/tree/{ref}/{rest:*}", d.RepoTree)
	router.GET("/blob/{ref}/{rest:*}", d.FileContent)
	router.GET("/tree/{ref}/", d.RepoTree)
	router.GET("/log/{ref}/", d.Log)
	router.GET("/archive/{file}", d.Archive)
	router.GET("/commit/{ref}", d.Diff)
	router.GET("/commit/{ref}/{file:*}", d.FileDiff)
	router.GET("/refs/", d.Refs)
	router.GET("/info/refs", d.InfoRefs)
	router.POST("/git-upload-pack", d.UploadPack)
	router.GET("/", d.RepoIndex)
}