package fs

import (
	"context"
	"os"
	"path/filepath"
	"strings"
	"text/template"

	sr "tildegit.org/tjp/sliderule"
	"tildegit.org/tjp/sliderule/spartan"
)

// SpartanFileHandler builds a handler which serves up files from a root directory.
//
// It only serves responses for paths which correspond to regular files or symlinks to them.
func SpartanFileHandler(fsroot, urlroot string) sr.Handler {
	fsroot = strings.TrimRight(fsroot, "/")

	return sr.HandlerFunc(func(ctx context.Context, request *sr.Request) *sr.Response {
		if !strings.HasPrefix(request.Path, urlroot) {
			return nil
		}
		requestpath := strings.Trim(strings.TrimPrefix(request.Path, urlroot), "/")

		fpath := filepath.Join(fsroot, requestpath)
		if isPrivate(fpath) {
			return nil
		}
		if isf, err := isFile(fpath); err != nil {
			return spartan.ServerError(err)
		} else if !isf {
			return nil
		}

		file, err := os.Open(fpath)
		if err != nil {
			return spartan.ServerError(err)
		}
		return spartan.Success(mediaType(fpath), file)
	})
}

// SpartanDirectoryDefault serves up default files for directory path requests.
//
// If any of the supported filenames are found, the contents of the file is returned as the
// spartan response.
//
// It returns nil for any paths which don't correspond to a directory.
//
// When it encounters a directory path which doesn't end in a trailing slash (/) it
// redirects to the URL with the slash appended. This is necessary for relative links
// in the directory's contents to function properly.
func SpartanDirectoryDefault(fsroot, urlroot string, filenames ...string) sr.Handler {
	fsroot = strings.TrimRight(fsroot, "/")

	return sr.HandlerFunc(func(ctx context.Context, request *sr.Request) *sr.Response {
		if !strings.HasPrefix(request.Path, urlroot) {
			return nil
		}

		if !strings.HasSuffix(request.Path, "/") {
			u := *request.URL
			u.Path += "/"
			return spartan.Redirect(u.String())
		}

		requestpath := strings.Trim(strings.TrimPrefix(request.Path, urlroot), "/")
		fpath := filepath.Join(fsroot, requestpath)
		if isPrivate(fpath) {
			return nil
		}
		if isd, err := isDir(fpath); err != nil {
			return spartan.ServerError(err)
		} else if !isd {
			return nil
		}

		for _, fname := range filenames {
			candidatepath := filepath.Join(fpath, fname)
			if isf, err := isFile(candidatepath); err != nil {
				return spartan.ServerError(err)
			} else if !isf {
				continue
			}

			file, err := os.Open(candidatepath)
			if err != nil {
				return spartan.ServerError(err)
			}
			return spartan.Success(mediaType(candidatepath), file)
		}

		return nil
	})
}

// SpartanDirectoryListing produces a listing of the contents of any requested directories.
//
// It returns a nil response for any paths which don't correspond to a filesystem directory.
//
// When it encounters a directory path which doesn't end in a trailing slash (/) it
// redirects to a URL with the trailing slash appended. This is necessary for relative
// links not the directory's contents to function properly.
//
// The template may be nil, in which case DefaultSpartanDirectoryList is used instead. The
// template is then processed with RenderDirectoryListing.
func SpartanDirectoryListing(fsroot, urlroot string, template *template.Template) sr.Handler {
	fsroot = strings.TrimRight(fsroot, "/")

	return sr.HandlerFunc(func(ctx context.Context, request *sr.Request) *sr.Response {
		if !strings.HasSuffix(request.Path, "/") {
			u := *request.URL
			u.Path += "/"
			return spartan.Redirect(u.String())
		}
		if !strings.HasPrefix(request.Path, urlroot) {
			return nil
		}
		requestpath := strings.Trim(strings.TrimPrefix(request.Path, urlroot), "/")

		fpath := filepath.Join(fsroot, requestpath)
		if isPrivate(fpath) {
			return nil
		}
		if isd, err := isDir(fpath); err != nil {
			return spartan.ServerError(err)
		} else if !isd {
			return nil
		}

		if template == nil {
			template = DefaultSpartanDirectoryList
		}
		body, err := RenderDirectoryListing(fpath, requestpath, template, request.Server)
		if err != nil {
			return spartan.ServerError(err)
		}

		return spartan.Success("text/gemini", body)
	})
}

// DefaultSpartanDirectoryList is a tmeplate which renders a reasonable gemtext dir listing.
var DefaultSpartanDirectoryList = DefaultGeminiDirectoryList