package web

import (
	"context"
	"errors"
	"io"
	"log"
	"mime/multipart"
	"net/http"
	"os"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"

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

	"hearthforge/internal/db"
	"hearthforge/internal/gitcmd"
	"hearthforge/internal/markdown"
	"hearthforge/internal/util"
	"hearthforge/internal/web/views"
)

const releasesPerPage = 20

// sourceFormats are the archives Archive writes, in display order.
var sourceFormats = []struct{ format, ext string }{
	{"zip", ".zip"},
	{"tar.gz", ".tar.gz"},
	{"tar.zst", ".tar.zst"},
}

// unsafeAssetChar matches everything a stored asset name may not contain.
var unsafeAssetChar = regexp.MustCompile(`[^a-zA-Z0-9._-]`)

// sanitizeFilename reduces an uploaded name to a plain file name.
func sanitizeFilename(name string) string {
	safe := unsafeAssetChar.ReplaceAllString(filepath.Base(name), "_")
	if safe == "" || strings.Trim(safe, ".") == "" {
		return "_"
	}
	return safe
}

func (s *Server) releaseRoutes(r chi.Router) {
	r.Get("/{repo}/releases", s.releaseList)
	r.Get("/{repo}/releases/{id}", s.releaseDetail)
	r.Get("/{repo}/releases/{id}/assets/{filename}", s.releaseAssetDownload)
	r.Get("/{repo}/releases/{id}/source/{filename}", s.releaseSourceDownload)

	r.Group(func(r chi.Router) {
		r.Use(s.requireAdmin)
		r.Get("/{repo}/releases/new", s.newRelease)
		r.Post("/{repo}/releases", s.createRelease)
		r.Post("/{repo}/releases/{id}/delete", s.deleteRelease)
	})
}

// releaseDir is the on-disk home of one release.
func (s *Server) releaseDir(id int64) string {
	return filepath.Join(s.Cfg.ReleasesDir(), strconv.FormatInt(id, 10))
}

// releaseParam loads the release named in the URL inside the given repository.
func (s *Server) releaseParam(w http.ResponseWriter, r *http.Request, repoID int64) (*db.Release, bool) {
	id, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
	if err != nil {
		http.Error(w, "Not found", http.StatusNotFound)
		return nil, false
	}
	release, err := s.DB.ReleaseInRepo(r.Context(), repoID, id)
	if err != nil {
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		return nil, false
	}
	if release == nil {
		http.Error(w, "Not found", http.StatusNotFound)
		return nil, false
	}
	return release, true
}

func (s *Server) releaseList(w http.ResponseWriter, r *http.Request) {
	repo, ok := s.visibleRepo(w, r)
	if !ok {
		return
	}
	total, err := s.DB.CountReleases(r.Context(), repo.ID)
	if err != nil {
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		return
	}
	page := util.Paginate(util.ParsePage(r.URL.Query().Get("page")), total, releasesPerPage)
	releases, err := s.DB.ListReleases(r.Context(), repo.ID, releasesPerPage, page.Offset)
	if err != nil {
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		return
	}
	ids := make([]int64, len(releases))
	for i, rel := range releases {
		ids[i] = rel.ID
	}
	counts, err := s.DB.AssetCounts(r.Context(), ids)
	if err != nil {
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		return
	}
	items := make([]views.ReleaseListItem, len(releases))
	for i, rel := range releases {
		item := views.ReleaseListItem{Release: rel, AssetCount: counts[rel.ID]}
		if rel.Notes != nil && *rel.Notes != "" {
			item.NotesPlain = markdown.ToPlaintext(*rel.Notes)
			item.NotesHTML = s.MD.Render(*rel.Notes, "", nil)
		}
		items[i] = item
	}
	views.Render(w, http.StatusOK, views.ReleaseList(s.Cfg, User(r), repo, items, views.PageInfo{
		Page:        page.Page,
		TotalPages:  page.TotalPages,
		URLTemplate: "/" + repo.Name + "/releases?page={page}",
	}))
}

func (s *Server) newRelease(w http.ResponseWriter, r *http.Request) {
	repo, ok := s.visibleRepo(w, r)
	if !ok {
		return
	}
	views.Render(w, http.StatusOK, views.NewRelease(s.Cfg, User(r), repo, "", nil))
}

func (s *Server) createRelease(w http.ResponseWriter, r *http.Request) {
	if s.limited(w, r, uploadLimiter, false) {
		return
	}
	repo, ok := s.visibleRepo(w, r)
	if !ok {
		return
	}
	if err := parseUploadForm(r, s.Cfg.MaxUploadBytes); err != nil {
		http.Error(w, "Bad Request", http.StatusBadRequest)
		return
	}
	if r.MultipartForm != nil {
		defer r.MultipartForm.RemoveAll()
	}

	tagCreated := false
	name := strings.TrimSpace(r.FormValue("name"))
	notes := strings.TrimSpace(r.FormValue("notes"))
	createTag := r.FormValue("create_tag") == "on"
	tagName := ""
	revision := ""
	if createTag {
		tagName = strings.TrimSpace(r.FormValue("tag_name"))
		revision = strings.TrimSpace(r.FormValue("revision"))
	}
	if tooLong(w, r.FormValue("name"), s.Cfg.MaxTitleBytes) ||
		tooLong(w, r.FormValue("tag_name"), s.Cfg.MaxTitleBytes) ||
		tooLong(w, r.FormValue("notes"), s.Cfg.MaxTextBodyBytes) {
		return
	}

	values := &views.ReleaseFormValues{
		CreateTag:         createTag,
		TagName:           r.FormValue("tag_name"),
		Revision:          r.FormValue("revision"),
		Name:              r.FormValue("name"),
		Notes:             r.FormValue("notes"),
		IncludeSourceCode: r.FormValue("include_source_code") == "on",
	}
	fail := func(msg string) {
		views.Render(w, http.StatusOK, views.NewRelease(s.Cfg, User(r), repo, msg, values))
	}

	if name == "" {
		fail("Release title is required")
		return
	}
	if createTag {
		switch {
		case tagName == "":
			fail("Tag name is required when creating a git tag")
			return
		case !validTagName.MatchString(tagName):
			fail("Tag name may only contain letters, digits, dots, hyphens, underscores, and plus signs")
			return
		case revision == "":
			fail("Revision is required when creating a git tag")
			return
		}
		// The release row carries UNIQUE(repo_id, tag_name). Check it before
		// creating the tag, so a rejected insert cannot leave a stray tag.
		exists, err := s.DB.ReleaseExistsForTag(r.Context(), repo.ID, tagName)
		if err != nil {
			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
			return
		}
		if exists {
			views.Render(w, http.StatusUnprocessableEntity,
				views.NewRelease(s.Cfg, User(r), repo, "A release for this tag already exists", values))
			return
		}
		message := name
		if notes != "" {
			message = name + "\n\n" + notes
		}
		tagger := gitcmd.Ident{Name: s.Cfg.CommitterName, Email: s.Cfg.CommitterEmail}
		err = s.Git.CreateTag(r.Context(), repo.Name, tagName, revision, message, tagger)
		switch {
		case errors.Is(err, gitcmd.ErrExists):
			fail(`Git tag "` + tagName + `" already exists in this repository`)
			return
		case errors.Is(err, gitcmd.ErrBadRef), errors.Is(err, gitcmd.ErrInvalidRef):
			fail(`"` + revision + `" is not a valid revision in this repository`)
			return
		case err != nil:
			fail("Failed to create git tag")
			return
		}
		tagCreated = true
	}

	includeSource := values.IncludeSourceCode && createTag && tagName != ""
	var tagPtr, notesPtr *string
	if createTag {
		tagPtr = &tagName
	}
	if notes != "" {
		notesPtr = &notes
	}

	var files []*multipart.FileHeader
	if r.MultipartForm != nil {
		files = r.MultipartForm.File["files"]
	}
	// One stored file must map to one asset row. Two uploads that sanitize to
	// the same name would overwrite each other and still insert two rows.
	if duplicateAssetName(files) {
		views.Render(w, http.StatusUnprocessableEntity,
			views.NewRelease(s.Cfg, User(r), repo, "Duplicate asset name", values))
		return
	}

	now := db.NowISO()
	// The row goes in first so the release id names the directory. Archive
	// generation and upload copying then run outside any transaction: the
	// database has a single connection and must not be held for file work.
	id, err := s.DB.CreateRelease(r.Context(), repo.ID, tagPtr, name, notesPtr, includeSource, now)
	if err != nil {
		if isUniqueViolation(err) {
			views.Render(w, http.StatusUnprocessableEntity,
				views.NewRelease(s.Cfg, User(r), repo, "A release for this tag already exists", values))
			return
		}
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		return
	}
	// A half-written release is removed row and directory together, which is
	// also what SyncReleases does for a directory left behind by a crash.
	rollback := func() {
		// The tag this request created belongs to the release. Leaving it
		// behind would block a retry with the same tag name.
		if tagCreated {
			if derr := s.Git.DeleteTag(context.WithoutCancel(r.Context()), repo.Name, tagName); derr != nil {
				log.Printf("delete tag %q after failed release write: %v", tagName, derr)
			}
		}
		os.RemoveAll(s.releaseDir(id))
		if derr := s.DB.DeleteRelease(context.WithoutCancel(r.Context()), id); derr != nil {
			log.Printf("delete release %d after failed write: %v", id, derr)
		}
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
	}

	dir := s.releaseDir(id)
	if includeSource {
		sourceDir := filepath.Join(dir, "source")
		if err := os.MkdirAll(sourceDir, 0o755); err != nil {
			rollback()
			return
		}
		if err := s.Git.Archive(r.Context(), repo.Name, tagName, repo.Name, sourceDir); err != nil {
			rollback()
			return
		}
	}
	assets, err := writeReleaseAssets(filepath.Join(dir, "assets"), files)
	if err != nil {
		rollback()
		return
	}
	if err := s.DB.AddReleaseAssets(r.Context(), id, assets, now); err != nil {
		rollback()
		return
	}
	redirectTo(w, r, "/"+repo.Name+"/releases/"+strconv.FormatInt(id, 10))
}

// duplicateAssetName reports whether two uploads sanitize to the same name.
func duplicateAssetName(files []*multipart.FileHeader) bool {
	seen := make(map[string]bool, len(files))
	for _, fh := range files {
		if fh.Size == 0 {
			continue
		}
		name := sanitizeFilename(fh.Filename)
		if seen[name] {
			return true
		}
		seen[name] = true
	}
	return false
}

// writeReleaseAssets stores the uploaded files and returns their asset rows.
// Empty uploads are skipped, like the browser's empty file input.
func writeReleaseAssets(assetsDir string, files []*multipart.FileHeader) ([]db.NewAsset, error) {
	var assets []db.NewAsset
	for _, fh := range files {
		if fh.Size == 0 {
			continue
		}
		if len(assets) == 0 {
			if err := os.MkdirAll(assetsDir, 0o755); err != nil {
				return nil, err
			}
		}
		filename := sanitizeFilename(fh.Filename)
		size, err := writeUpload(filepath.Join(assetsDir, filename), fh)
		if err != nil {
			return nil, err
		}
		assets = append(assets, db.NewAsset{Filename: filename, Size: size})
	}
	return assets, nil
}

func writeUpload(path string, fh *multipart.FileHeader) (int64, error) {
	src, err := fh.Open()
	if err != nil {
		return 0, err
	}
	defer src.Close()
	dst, err := os.Create(path)
	if err != nil {
		return 0, err
	}
	defer dst.Close()
	return io.Copy(dst, src)
}

func (s *Server) releaseDetail(w http.ResponseWriter, r *http.Request) {
	repo, ok := s.visibleRepo(w, r)
	if !ok {
		return
	}
	release, ok := s.releaseParam(w, r, repo.ID)
	if !ok {
		return
	}
	assets, err := s.DB.ListReleaseAssets(r.Context(), release.ID)
	if err != nil {
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		return
	}
	notesHTML := ""
	if release.Notes != nil && *release.Notes != "" {
		notesHTML = s.MD.Render(*release.Notes, "", nil)
	}

	var archives []views.SourceArchive
	if release.IncludeSourceCode && release.TagName != nil {
		base := repo.Name + "-" + *release.TagName
		sourceDir := filepath.Join(s.releaseDir(release.ID), "source")
		for _, f := range sourceFormats {
			info, err := os.Stat(filepath.Join(sourceDir, base+f.ext))
			if err != nil {
				continue
			}
			archives = append(archives, views.SourceArchive{
				Format:   f.format,
				Filename: base + f.ext,
				Size:     info.Size(),
			})
		}
	}
	views.Render(w, http.StatusOK,
		views.ReleaseDetail(s.Cfg, User(r), repo, release, notesHTML, assets, archives))
}

func (s *Server) releaseAssetDownload(w http.ResponseWriter, r *http.Request) {
	repo, ok := s.visibleRepo(w, r)
	if !ok {
		return
	}
	release, ok := s.releaseParam(w, r, repo.ID)
	if !ok {
		return
	}
	filename := filepath.Base(chi.URLParam(r, "filename"))
	asset, err := s.DB.ReleaseAssetByFilename(r.Context(), release.ID, filename)
	if err != nil {
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		return
	}
	if asset == nil {
		http.Error(w, "Not found", http.StatusNotFound)
		return
	}
	serveReleaseFile(w, filepath.Join(s.releaseDir(release.ID), "assets", filename), filename)
}

func (s *Server) releaseSourceDownload(w http.ResponseWriter, r *http.Request) {
	repo, ok := s.visibleRepo(w, r)
	if !ok {
		return
	}
	release, ok := s.releaseParam(w, r, repo.ID)
	if !ok {
		return
	}
	if !release.IncludeSourceCode {
		http.Error(w, "Not found", http.StatusNotFound)
		return
	}
	filename := filepath.Base(chi.URLParam(r, "filename"))
	serveReleaseFile(w, filepath.Join(s.releaseDir(release.ID), "source", filename), filename)
}

// serveReleaseFile sends one file as an attachment. The caller must reduce the
// name to a plain file name, so the path cannot escape the release directory.
func serveReleaseFile(w http.ResponseWriter, path, filename string) {
	f, err := os.Open(path)
	if err != nil {
		http.Error(w, "Not found", http.StatusNotFound)
		return
	}
	defer f.Close()
	info, err := f.Stat()
	if err != nil || info.IsDir() {
		http.Error(w, "Not found", http.StatusNotFound)
		return
	}
	w.Header().Set("Content-Disposition", util.ContentDisposition("attachment", filename))
	w.Header().Set("Content-Type", "application/octet-stream")
	w.Header().Set("Content-Length", strconv.FormatInt(info.Size(), 10))
	io.Copy(w, f)
}

func (s *Server) deleteRelease(w http.ResponseWriter, r *http.Request) {
	repo, ok := s.visibleRepo(w, r)
	if !ok {
		return
	}
	release, ok := s.releaseParam(w, r, repo.ID)
	if !ok {
		return
	}
	// The files go first, so a crash in between leaves a visible but broken
	// release instead of a row pointing at missing files.
	if err := os.RemoveAll(s.releaseDir(release.ID)); err != nil {
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		return
	}
	if err := s.DB.DeleteRelease(r.Context(), release.ID); err != nil {
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		return
	}
	redirectTo(w, r, "/"+repo.Name+"/releases")
}

// SyncReleases reconciles the release directories with the database at startup.
// An orphaned directory is left behind when the server dies after writing the
// files but before the transaction commits. A missing directory is left behind
// when it dies after the removal but before the row is deleted.
func (s *Server) SyncReleases(ctx context.Context) error {
	ids, err := s.DB.AllReleaseIDs(ctx)
	if err != nil {
		return err
	}
	known := make(map[string]bool, len(ids))
	for _, id := range ids {
		known[strconv.FormatInt(id, 10)] = true
	}

	// The directory does not exist on first run, so a read error is not fatal.
	entries, _ := os.ReadDir(s.Cfg.ReleasesDir())
	for _, e := range entries {
		if !e.IsDir() || known[e.Name()] {
			continue
		}
		if _, err := strconv.ParseInt(e.Name(), 10, 64); err != nil {
			continue
		}
		if err := os.RemoveAll(filepath.Join(s.Cfg.ReleasesDir(), e.Name())); err != nil {
			return err
		}
		log.Printf("Removed orphaned release directory: %s", e.Name())
	}

	// Only releases with source archives or assets have a directory.
	withDir, err := s.DB.ReleaseIDsWithDirectory(ctx)
	if err != nil {
		return err
	}
	var stale []int64
	for _, id := range withDir {
		if _, err := os.Stat(s.releaseDir(id)); err != nil {
			stale = append(stale, id)
		}
	}
	if len(stale) == 0 {
		return nil
	}
	if err := s.DB.DeleteReleases(ctx, stale); err != nil {
		return err
	}
	log.Printf("Removed %d stale release record(s)", len(stale))
	return nil
}