package main

import (
	"context"
	"database/sql"
	_ "embed"
	"os/signal"
	"strings"
	"syscall"
	"text/template"
	"time"
	"unsafe"

	"github.com/spf13/pflag"
	"go.elara.ws/go-lemmy"
	"go.elara.ws/go-lemmy/types"
	"go.elara.ws/lemmy-reply-bot/internal/store"
	"go.elara.ws/logger/log"
	_ "modernc.org/sqlite"
)

type Submatches []string

func (sm Submatches) Item(i int) string {
	return sm[i]
}

type TmplContext struct {
	Matches []Submatches
	Type    string
}

func (tc TmplContext) Match(i, j int) string {
	return tc.Matches[i][j]
}

//go:embed sql/schema.sql
var schema string

func init() {
	db, err := sql.Open("sqlite", "replied.db")
	if err != nil {
		log.Fatal("Error opening database during init").Err(err).Send()
	}
	_, err = db.Exec(schema)
	if err != nil {
		log.Fatal("Error initializing database").Err(err).Send()
	}
	err = db.Close()
	if err != nil {
		log.Fatal("Error closing database after init").Err(err).Send()
	}
}

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.New(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()

	replyCh := make(chan replyJob, 200)

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

	commentWorker(ctx, c, replyCh)
}

func commentWorker(ctx context.Context, c *lemmy.Client, replyCh chan<- replyJob) {
	db, err := sql.Open("sqlite", "replied.db")
	if err != nil {
		log.Fatal("Error opening reply database").Err(err).Send()
	}
	rs := store.New(db)

	for {
		select {
		case <-time.After(15 * time.Second):
			comments, err := c.Comments(ctx, types.GetComments{
				Type:  types.NewOptional(types.ListingTypeLocal),
				Sort:  types.NewOptional(types.CommentSortTypeNew),
				Limit: types.NewOptional[int64](50),
			})
			if err != nil {
				log.Warn("Error getting comments").Err(err).Send()
				continue
			}

			for _, c := range comments.Comments {
				// Skip all non-local comments
				if !c.Community.Local {
					continue
				}

				// If the item we're checking for already exists, we've already replied, so skip it
				if c, err := rs.ItemExists(ctx, store.ItemExistsParams{
					ID:          int64(c.Comment.ID),
					ItemType:    store.Comment,
					UpdatedTime: c.Comment.Updated.Unix(),
				}); c > 0 && err == nil {
					continue
				} else if err != nil {
					log.Warn("Error checking if item exists").Err(err).Send()
					continue
				}

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

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

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

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

					replyCh <- job

					err = rs.AddItem(ctx, store.AddItemParams{
						ID:          int64(c.Comment.ID),
						ItemType:    store.Comment,
						UpdatedTime: c.Comment.Updated.Unix(),
					})
					if err != nil {
						log.Warn("Error adding comment to the reply store").Err(err).Send()
						continue
					}
				}
			}

			posts, err := c.Posts(ctx, types.GetPosts{
				Type:  types.NewOptional(types.ListingTypeLocal),
				Sort:  types.NewOptional(types.SortTypeNew),
				Limit: types.NewOptional[int64](20),
			})
			if err != nil {
				log.Warn("Error getting comments").Err(err).Send()
				continue
			}

			for _, p := range posts.Posts {
				// Skip all non-local posts
				if !p.Community.Local {
					continue
				}

				// If the item we're checking for already exists, we've already replied, so skip it
				if c, err := rs.ItemExists(ctx, store.ItemExistsParams{
					ID:          int64(p.Post.ID),
					ItemType:    store.Post,
					UpdatedTime: p.Post.Updated.Unix(),
				}); c > 0 && err == nil {
					continue
				} else if err != nil {
					log.Warn("Error checking if item exists").Err(err).Send()
					continue
				}

				body := p.Post.URL.ValueOr("") + "\n\n" + p.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", p.Post.ID).
						Send()

					job := replyJob{PostID: p.Post.ID}

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

					replyCh <- job

					err = rs.AddItem(ctx, store.AddItemParams{
						ID:          int64(p.Post.ID),
						ItemType:    store.Post,
						UpdatedTime: p.Post.Updated.Unix(),
					})
					if err != nil {
						log.Warn("Error adding post to the reply store").Err(err).Send()
						continue
					}
				}
			}
		case <-ctx.Done():
			err = db.Close()
			if err != nil {
				log.Warn("Error closing database").Err(err).Send()
				continue
			}
			return
		}
	}
}

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

func commentReplyWorker(ctx context.Context, c *lemmy.Client, ch <-chan replyJob) {
	for {
		select {
		case reply := <-ch:
			cr, err := c.CreateComment(ctx, 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)).
				Int("comment-id", cr.CommentView.Comment.ID).
				Send()
		case <-ctx.Done():
			return
		}
	}
}

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

// toSubmatches converts matches coming from PCRE2 to a
// submatch array used for the template
func toSubmatches(s [][]string) []Submatches {
	// Unfortunately, Go doesn't allow for this conversion
	// even though the memory layout is identical and it's
	// safe, so it is done using unsafe pointer magic
	return *(*[]Submatches)(unsafe.Pointer(&s))
}