package macro

import (
	"errors"
	"fmt"
	"log"
	"strings"
	"time"

	"git.fromouter.space/crunchy-rocks/clessy-ng/modules"
	"git.fromouter.space/crunchy-rocks/clessy-ng/utils"

	"git.fromouter.space/hamcha/tg"
	"github.com/cockroachdb/pebble"
	jsoniter "github.com/json-iterator/go"
)

type Macro struct {
	Value  string
	Author tg.APIUser
	Time   time.Time
}

var macros map[string]Macro

const macroKey = "mod/macros/data"

type Module struct {
	client *tg.Telegram
	name   string
	kv     *pebble.DB
}

func (m *Module) Initialize(options modules.ModuleOptions) error {
	m.client = options.API
	m.name = options.Name
	m.kv = options.KV

	macros = make(map[string]Macro)
	err := utils.ReadJSON(m.kv, macroKey, &macros)
	if err != nil {
		if !errors.Is(err, pebble.ErrNotFound) {
			log.Println("[macro] WARN: Could not load macros (db error): " + err.Error())
			return err
		}
	}
	log.Printf("[macro] Loaded %d macros\n", len(macros))

	return nil
}

func (m *Module) OnUpdate(update tg.APIUpdate) {
	if !utils.IsCommand(update, m.name, "macro") {
		return
	}

	parts := strings.SplitN(*(update.Message.Text), " ", 3)
	switch len(parts) {
	case 2:
		name := strings.ToLower(parts[1])
		item, ok := macros[name]
		var out string
		if ok {
			out = fmt.Sprintf("<b>%s</b>\n%s\n<i>%s - %s</i>", name, item.Value, item.Author.Username, item.Time.Format("02-01-06 15:04"))
		} else {
			out = fmt.Sprintf("<b>%s</b>\n<i>macro inesistente</i>\n(configura con /macro %s <i>contenuto</i>)", name, name)
		}
		m.client.SendTextMessage(tg.ClientTextMessageData{
			ChatID:  update.Message.Chat.ChatID,
			Text:    out,
			ReplyID: &update.Message.MessageID,
		})
	case 3:
		name := strings.ToLower(parts[1])
		macros[name] = Macro{
			Value:  parts[2],
			Author: update.Message.User,
			Time:   time.Now(),
		}
		m.save()
		m.client.SendTextMessage(tg.ClientTextMessageData{
			ChatID:  update.Message.Chat.ChatID,
			Text:    fmt.Sprintf("<b>%s</b> → %s", name, parts[2]),
			ReplyID: &update.Message.MessageID,
		})
	default:
		m.client.SendTextMessage(tg.ClientTextMessageData{
			ChatID:  update.Message.Chat.ChatID,
			Text:    "<b>Sintassi</b>\n<b>Leggi</b>: /macro <i>nome-macro</i>\n<b>Scrivi</b>: /macro <i>nome-macro</i> <i>contenuto macro</i>",
			ReplyID: &update.Message.MessageID,
		})
	}
}

func (m *Module) save() {
	byt, err := jsoniter.ConfigFastest.Marshal(macros)
	if err != nil {
		log.Println("[macro] WARN: Could not encode macros: " + err.Error())
	}
	err = m.kv.Set([]byte(macroKey), byt, &pebble.WriteOptions{Sync: true})
	if err != nil {
		log.Println("[macro] WARN: Could not save macros to db: " + err.Error())
		return
	}
}