package builder

import (
	"fmt"
	"io"
	"net/url"
	"os"
	"path"
	"slices"
	"sync"
	"time"

	"website/internal/config"
	"website/internal/log"

	cp "github.com/otiai10/copy"
	"github.com/pkg/errors"
	"github.com/snabb/sitemap"
)

type IOConfig struct {
	Source      string `conf:"default:.,short:s,flag:src"`
	Destination string `conf:"default:website,short:d,flag:dest"`
	BaseURL     config.URL
	Development bool `conf:"default:false,flag:dev"`
}

type Result struct {
	Hashes []string
}

func mkdirp(dirs ...string) error {
	err := os.MkdirAll(path.Join(dirs...), 0755)

	return errors.Wrap(err, "could not create directory")
}

func outputToFile(output io.Reader, filename ...string) error {
	log.Debug("outputting file", "filename", path.Join(filename...))
	file, err := os.OpenFile(path.Join(filename...), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
	if err != nil {
		return errors.WithMessage(err, "could not open output file")
	}
	defer file.Close()

	if _, err := file.ReadFrom(output); err != nil {
		return errors.WithMessage(err, "could not write output file")
	}

	return nil
}

func writerToFile(writer io.WriterTo, filename ...string) error {
	log.Debug("outputting file", "filename", path.Join(filename...))
	file, err := os.OpenFile(path.Join(filename...), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
	if err != nil {
		return errors.WithMessage(err, "could not open output file")
	}
	defer file.Close()

	if _, err := writer.WriteTo(file); err != nil {
		return errors.WithMessage(err, "could not write output file")
	}

	return nil
}

func build(outDir string, config config.Config) (*Result, error) {
	log.Debug("output", "dir", outDir)
	r := &Result{
		Hashes: make([]string, 0),
	}
	assetsOnce = sync.Once{}
	privateDir := path.Join(outDir, "private")
	if err := mkdirp(privateDir); err != nil {
		return nil, errors.WithMessage(err, "could not create private directory")
	}
	publicDir := path.Join(outDir, "public")
	if err := mkdirp(publicDir); err != nil {
		return nil, errors.WithMessage(err, "could not create public directory")
	}

	err := cp.Copy("static", publicDir, cp.Options{
		PreserveTimes:     true,
		PermissionControl: cp.AddPermission(0755),
	})
	if err != nil {
		return nil, errors.WithMessage(err, "could not copy static files")
	}

	if err := mkdirp(publicDir, "post"); err != nil {
		return nil, errors.WithMessage(err, "could not create post output directory")
	}
	log.Debug("reading posts")
	posts, tags, err := readPosts("content", "post", publicDir)
	if err != nil {
		return nil, err
	}

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

	for _, post := range posts {
		if err := mkdirp(publicDir, "post", post.Basename); err != nil {
			return nil, errors.WithMessage(err, "could not create directory for post")
		}
		log.Debug("rendering post", "post", post.Basename)
		sm.Add(&sitemap.URL{
			Loc:     post.URL,
			LastMod: &post.Date,
		})
		output, err := renderPost(post, config)
		if err != nil {
			return nil, errors.WithMessagef(err, "could not render post %s", post.Input)
		}
		if err := outputToFile(output, post.Output); err != nil {
			return nil, err
		}
	}

	if err := mkdirp(publicDir, "tags"); err != nil {
		return nil, errors.WithMessage(err, "could not create directory for tags")
	}
	log.Debug("rendering tags list")
	output, err := renderTags(tags, config, "/tags")
	if err != nil {
		return nil, errors.WithMessage(err, "could not render tags")
	}
	if err := outputToFile(output, publicDir, "tags", "index.html"); err != nil {
		return nil, err
	}
	sm.Add(&sitemap.URL{
		Loc:     "/tags/",
		LastMod: &lastMod,
	})

	for _, tag := range tags.ToSlice() {
		matchingPosts := []Post{}
		for _, post := range posts {
			if slices.Contains(post.Taxonomies.Tags, tag) {
				matchingPosts = append(matchingPosts, post)
			}
		}
		if err := mkdirp(publicDir, "tags", tag); err != nil {
			return nil, errors.WithMessage(err, "could not create directory")
		}
		log.Debug("rendering tags page", "tag", tag)
		url := "/tags/" + tag
		output, err := renderListPage(tag, config, matchingPosts, url)
		if err != nil {
			return nil, errors.WithMessage(err, "could not render tag page")
		}
		if err := outputToFile(output, publicDir, "tags", tag, "index.html"); err != nil {
			return nil, err
		}
		sm.Add(&sitemap.URL{
			Loc:     url,
			LastMod: &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")
		}
		if err := outputToFile(feed, publicDir, "tags", tag, "atom.xml"); err != nil {
			return nil, err
		}
	}

	log.Debug("rendering list page")
	listPage, err := renderListPage("", config, posts, "/post")
	if err != nil {
		return nil, errors.WithMessage(err, "could not render list page")
	}
	if err := outputToFile(listPage, publicDir, "post", "index.html"); err != nil {
		return nil, err
	}
	sm.Add(&sitemap.URL{
		Loc:     "/post/",
		LastMod: &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")
	}
	if err := outputToFile(feed, publicDir, "atom.xml"); err != nil {
		return nil, err
	}

	log.Debug("rendering feed styles")
	feedStyles, err := renderFeedStyles()
	if err != nil {
		return nil, errors.WithMessage(err, "could not render feed styles")
	}
	if err := outputToFile(feedStyles, publicDir, "feed-styles.xsl"); 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")
	homePage, err := renderHomepage(config, posts, "/")
	if err != nil {
		return nil, errors.WithMessage(err, "could not render homepage")
	}
	if err := outputToFile(homePage, publicDir, "index.html"); 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
	sm.Add(&sitemap.URL{
		Loc: "/",
	})
	h, err = getHTMLStyleHash(publicDir, "index.html")
	r.Hashes = append(r.Hashes, h)

	log.Debug("rendering 404 page")
	notFound, err := render404(config, "/404.html")
	if err != nil {
		return nil, errors.WithMessage(err, "could not render 404 page")
	}
	if err := outputToFile(notFound, publicDir, "404.html"); err != nil {
		return nil, err
	}

	log.Debug("rendering sitemap")
	if err := writerToFile(sm, publicDir, "sitemap.xml"); err != nil {
		return nil, err
	}

	log.Debug("rendering robots.txt")
	rob, err := renderRobotsTXT(config)
	if err != nil {
		return nil, err
	}
	if err := outputToFile(rob, publicDir, "robots.txt"); err != nil {
		return nil, err
	}

	return r, nil
}

func BuildSite(ioConfig IOConfig) (*Result, error) {
	config, err := config.GetConfig()
	if err != nil {
		return nil, errors.WithMessage(err, "could not get config")
	}
	config.InjectLiveReload = ioConfig.Development

	if ioConfig.BaseURL.URL != nil {
		config.BaseURL.URL, err = url.Parse(ioConfig.BaseURL.String())
		if err != nil {
			return nil, errors.WithMessage(err, "could not re-parse base URL")
		}
	}

	if ioConfig.Development && ioConfig.Destination != "website" {
		err = os.RemoveAll(ioConfig.Destination)
		if err != nil {
			return nil, errors.WithMessage(err, "could not remove destination directory")
		}
	}

	return build(ioConfig.Destination, *config)
}