package builder

import (
	"context"
	"database/sql"
	"fmt"
	"io"
	"io/fs"
	"os"
	"path"
	"path/filepath"
	"slices"
	"time"

	"go.alanpearce.eu/website/internal/buffer"
	"go.alanpearce.eu/website/internal/config"
	"go.alanpearce.eu/website/internal/content"
	"go.alanpearce.eu/website/internal/sitemap"
	"go.alanpearce.eu/website/internal/storage"
	"go.alanpearce.eu/website/internal/storage/sqlite"
	"go.alanpearce.eu/website/templates"
	"go.alanpearce.eu/x/log"

	mapset "github.com/deckarep/golang-set/v2"
	"gitlab.com/tozd/go/errors"
)

type Options struct {
	Source      string `conf:"default:.,short:s,flag:src"`
	Development bool   `conf:"default:false,flag:dev"`
	DB          *sql.DB
}

type Result struct {
	Hashes []string
}

func joinSourcePath(src string) func(string) string {
	return func(rel string) string {
		return filepath.Join(src, rel)
	}
}

func copyRecursive(storage storage.Writer, src string) error {
	buf := new(buffer.Buffer)
	return filepath.WalkDir(src, func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		rel, err := filepath.Rel(src, path)
		if err != nil {
			return err
		}
		if d.IsDir() {
			return storage.Mkdirp(rel)
		}

		sf, err := os.Open(path)
		if err != nil {
			return err
		}
		defer sf.Close()
		buf.Reset()
		if _, err := io.Copy(buf, sf); err != nil {
			return err
		}
		if err := storage.Write("/"+rel, buf); err != nil {
			return err
		}

		return nil
	})

}

func build(
	storage storage.Writer,
	ioConfig *Options,
	config *config.Config,
	log *log.Logger,
) (*Result, error) {
	ctx := context.TODO()
	buf := new(buffer.Buffer)
	joinSource := joinSourcePath(ioConfig.Source)

	r := &Result{
		Hashes: make([]string, 0),
	}

	err := copyRecursive(storage, joinSource("static"))
	if err != nil {
		return nil, errors.WithMessage(err, "could not copy static files")
	}

	log.Debug("reading posts")
	posts, tags, err := content.ReadPosts(&content.Config{
		Root:     joinSource("content"),
		InputDir: "post",
	}, log.Named("content"))
	if err != nil {
		return nil, err
	}

	sitemap := sitemap.New(config)
	lastMod := time.Now()
	if len(posts) > 0 {
		lastMod = posts[0].Date
	}

	for _, post := range posts {
		log.Debug("rendering post", "post", post.Basename)
		sitemap.AddPath(post.URL, post.Date)
		if err := templates.PostPage(config, post).Render(ctx, buf); err != nil {
			return nil, errors.WithMessage(err, "could not render post")
		}

		if err := storage.Write(post.URL, buf); err != nil {
			return nil, err
		}
	}

	log.Debug("rendering tags list")
	buf.Reset()
	if err := templates.TagsPage(config, "tags", mapset.Sorted(tags), "/tags").Render(ctx, buf); err != nil {
		return nil, err
	}
	if err := storage.Write("/tags/", buf); err != nil {
		return nil, err
	}
	sitemap.AddPath("/tags/", lastMod)

	for _, tag := range tags.ToSlice() {
		matchingPosts := []content.Post{}
		for _, post := range posts {
			if slices.Contains(post.Taxonomies.Tags, tag) {
				matchingPosts = append(matchingPosts, post)
			}
		}
		log.Debug("rendering tags page", "tag", tag)
		url := path.Join("/tags", tag) + "/"
		buf.Reset()
		if err := templates.TagPage(config, tag, matchingPosts, url).Render(ctx, buf); err != nil {
			return nil, err
		}
		if err = storage.Write(url, buf); err != nil {
			return nil, err
		}
		sitemap.AddPath(url, matchingPosts[0].Date)

		log.Debug("rendering tags feed", "tag", tag)
		feed, err := renderFeed(
			fmt.Sprintf("%s - %s", config.Title, tag),
			config,
			matchingPosts,
			tag,
		)
		if err != nil {
			return nil, errors.WithMessage(err, "could not render tag feed page")
		}
		buf.Reset()
		if _, err := feed.WriteTo(buf); err != nil {
			return nil, err
		}
		if err := storage.Write(path.Join("/tags", tag, "atom.xml"), buf); err != nil {
			return nil, err
		}
	}

	log.Debug("rendering list page")
	buf.Reset()
	if err := templates.ListPage(config, posts, "/post").Render(ctx, buf); err != nil {
		return nil, err
	}
	if err := storage.Write("/post/", buf); err != nil {
		return nil, err
	}
	sitemap.AddPath("/post/", lastMod)

	log.Debug("rendering feed")
	feed, err := renderFeed(config.Title, config, posts, "feed")
	if err != nil {
		return nil, errors.WithMessage(err, "could not render feed")
	}
	buf.Reset()
	if _, err := feed.WriteTo(buf); err != nil {
		return nil, err
	}
	if err := storage.Write("/atom.xml", buf); err != nil {
		return nil, err
	}

	log.Debug("rendering feed styles")
	feedStyles, err := renderFeedStyles(ioConfig.Source)
	if err != nil {
		return nil, errors.WithMessage(err, "could not render feed styles")
	}
	buf.Reset()
	if _, err := feedStyles.WriteTo(buf); err != nil {
		return nil, err
	}
	if err := storage.Write("/feed-styles.xsl", buf); err != nil {
		return nil, err
	}
	_, err = feedStyles.Seek(0, 0)
	if err != nil {
		return nil, err
	}
	h, err := getFeedStylesHash(feedStyles)
	if err != nil {
		return nil, err
	}
	r.Hashes = append(r.Hashes, h)

	log.Debug("rendering homepage")
	_, text, err := content.GetPost(joinSource(filepath.Join("content", "index.md")))
	if err != nil {
		return nil, err
	}
	content, err := content.RenderMarkdown(text)
	if err != nil {
		return nil, err
	}
	buf.Reset()
	if err := templates.Homepage(config, posts, content).Render(ctx, buf); err != nil {
		return nil, err
	}
	if err := storage.Write("/", buf); err != nil {
		return nil, err
	}

	// it would be nice to set LastMod here, but using the latest post
	// date would be wrong as the homepage has its own content file
	// without a date, which could be newer
	sitemap.AddPath("/", time.Time{})
	h, _ = getHTMLStyleHash(buf)
	r.Hashes = append(r.Hashes, h)

	log.Debug("rendering sitemap")
	buf.Reset()
	sitemap.WriteTo(buf)
	if err := storage.Write("/sitemap.xml", buf); err != nil {
		return nil, err
	}

	log.Debug("rendering robots.txt")
	rob, err := renderRobotsTXT(ioConfig.Source, config)
	if err != nil {
		return nil, err
	}
	buf.Reset()
	if _, err := io.Copy(buf, rob); err != nil {
		return nil, err
	}
	if err := storage.Write("/robots.txt", buf); err != nil {
		return nil, err
	}

	return r, nil
}

func BuildSite(options *Options, cfg *config.Config, log *log.Logger) (*Result, error) {
	if cfg == nil {
		return nil, errors.New("config is nil")
	}
	cfg.InjectLiveReload = options.Development

	templates.Setup()
	loadCSS(options.Source)

	var storage storage.Writer
	storage, err := sqlite.NewWriter(options.DB, log, &sqlite.Options{
		Compress: !options.Development,
	})
	if err != nil {
		return nil, errors.WithMessage(err, "could not create storage")
	}

	return build(storage, options, cfg, log)
}