package main

import (
	"context"
	"os"
	"os/signal"
	"strings"
	"syscall"
	"text/template"

	"github.com/spf13/pflag"
	"github.com/vmihailenco/msgpack/v5"
	"go.arsenm.dev/go-lemmy"
	"go.arsenm.dev/go-lemmy/types"
	"go.arsenm.dev/logger/log"
)

func main() {
	configPath := pflag.StringP("config", "c", "./lemmy-reply-bot.toml", "Path to the config file")
	dryRun := pflag.BoolP("dry-run", "D", false, "Don't actually send comments, just check for matches")
	pflag.Parse()

	ctx := context.Background()
	ctx, cancel := signal.NotifyContext(ctx, syscall.SIGINT, syscall.SIGTERM)
	defer cancel()

	err := loadConfig(*configPath)
	if err != nil {
		log.Fatal("Error loading config file").Err(err).Send()
	}

	c, err := lemmy.NewWebSocket(cfg.Lemmy.InstanceURL)
	if err != nil {
		log.Fatal("Error creating new Lemmy API client").Err(err).Send()
	}

	err = c.ClientLogin(ctx, types.Login{
		UsernameOrEmail: cfg.Lemmy.Account.UserOrEmail,
		Password:        cfg.Lemmy.Account.Password,
	})
	if err != nil {
		log.Fatal("Error logging in to Lemmy instance").Err(err).Send()
	}

	log.Info("Successfully logged in to Lemmy instance").Send()

	joinAll(c)

	c.OnReconnect(func(c *lemmy.WSClient) {
		joinAll(c)
		log.Info("Successfully reconnected to WebSocket").Send()
	})

	replyCh := make(chan replyJob, 200)

	if !*dryRun {
		go commentReplyWorker(ctx, c, replyCh)
	}

	commentWorker(ctx, c, replyCh)
}

type itemType uint8

const (
	comment itemType = iota
	post
)

type item struct {
	Type itemType
	ID   int
}

func commentWorker(ctx context.Context, c *lemmy.WSClient, replyCh chan<- replyJob) {
	repliedIDs := map[item]struct{}{}

	repliedStore, err := os.Open("replied.bin")
	if err == nil {
		err = msgpack.NewDecoder(repliedStore).Decode(&repliedIDs)
		if err != nil {
			log.Warn("Error decoding reply store").Err(err).Send()
		}
		repliedStore.Close()
	}

	for {
		select {
		case res := <-c.Responses():
			if res.IsOneOf(types.UserOperationCRUDCreateComment, types.UserOperationCRUDEditComment) {
				var cr types.CommentResponse
				err = lemmy.DecodeResponse(res.Data, &cr)
				if err != nil {
					log.Warn("Error while trying to decode comment").Err(err).Send()
					continue
				}

				if _, ok := repliedIDs[item{comment, cr.CommentView.Comment.ID}]; ok {
					continue
				}

				for i, reply := range cfg.Replies {
					re := compiledRegexes[reply.Regex]
					if !re.MatchString(cr.CommentView.Comment.Content) {
						continue
					}

					log.Info("Matched comment body").
						Int("reply-index", i).
						Int("comment-id", cr.CommentView.Comment.ID).
						Send()

					job := replyJob{
						CommentID: types.NewOptional(cr.CommentView.Comment.ID),
						PostID:    cr.CommentView.Comment.PostID,
					}

					matches := re.FindAllStringSubmatch(cr.CommentView.Comment.Content, -1)
					job.Content, err = executeTmpl(compiledTmpls[reply.Regex], matches)
					if err != nil {
						log.Warn("Error while executing template").Err(err).Send()
						continue
					}

					replyCh <- job

					repliedIDs[item{comment, cr.CommentView.Comment.ID}] = struct{}{}
				}
			} else if res.IsOneOf(types.UserOperationCRUDCreatePost, types.UserOperationCRUDEditPost) {
				var pr types.PostResponse
				err = lemmy.DecodeResponse(res.Data, &pr)
				if err != nil {
					log.Warn("Error while trying to decode comment").Err(err).Send()
					continue
				}

				if _, ok := repliedIDs[item{post, pr.PostView.Post.ID}]; ok {
					continue
				}

				body := pr.PostView.Post.URL.ValueOr("") + "\n\n" + pr.PostView.Post.Body.ValueOr("")
				for i, reply := range cfg.Replies {
					re := compiledRegexes[reply.Regex]
					if !re.MatchString(body) {
						continue
					}

					log.Info("Matched post body").
						Int("reply-index", i).
						Int("post-id", pr.PostView.Post.ID).
						Send()

					job := replyJob{PostID: pr.PostView.Post.ID}

					matches := re.FindAllStringSubmatch(body, -1)
					job.Content, err = executeTmpl(compiledTmpls[reply.Regex], matches)
					if err != nil {
						log.Warn("Error while executing template").Err(err).Send()
						continue
					}

					replyCh <- job

					repliedIDs[item{post, pr.PostView.Post.ID}] = struct{}{}
				}
			}
		case err := <-c.Errors():
			log.Warn("Lemmy client error").Err(err).Send()
		case <-ctx.Done():
			repliedStore, err := os.Create("replied.bin")
			if err != nil {
				log.Warn("Error creating reply store file").Err(err).Send()
				return
			}

			err = msgpack.NewEncoder(repliedStore).Encode(repliedIDs)
			if err != nil {
				log.Warn("Error encoding replies to reply store").Err(err).Send()
			}

			repliedStore.Close()
			return
		}
	}
}

type replyJob struct {
	Content   string
	CommentID types.Optional[int]
	PostID    int
}

func commentReplyWorker(ctx context.Context, c *lemmy.WSClient, ch <-chan replyJob) {
	for {
		select {
		case reply := <-ch:
			err := c.Request(types.UserOperationCRUDCreateComment, types.CreateComment{
				PostID:   reply.PostID,
				ParentID: reply.CommentID,
				Content:  reply.Content,
			})
			if err != nil {
				log.Warn("Error while trying to create new comment").Err(err).Send()
			}

			log.Info("Created new comment").
				Int("post-id", reply.PostID).
				Int("parent-id", reply.CommentID.ValueOr(-1)).
				Send()
		case <-ctx.Done():
			return
		}
	}
}

func executeTmpl(tmpl *template.Template, matches [][]string) (string, error) {
	sb := &strings.Builder{}
	err := tmpl.Execute(sb, matches)
	return sb.String(), err
}

func joinAll(c *lemmy.WSClient) {
	err := c.Request(types.UserOperationUserJoin, nil)
	if err != nil {
		log.Fatal("Error joining WebSocket user context").Err(err).Send()
	}

	err = c.Request(types.UserOperationCommunityJoin, types.CommunityJoin{
		CommunityID: 0,
	})
	if err != nil {
		log.Fatal("Error joining WebSocket community context").Err(err).Send()
	}
}