package plugins

import (
	"fmt"
	"strconv"
	"strings"
	"time"
	"ymgb/database"
	"ymgb/database/psql"
	"ymgb/utils"

	"git.nix13.pw/scuroneko/extypes"
	"git.nix13.pw/scuroneko/laniakea"
)

func RegisterWaifus() *laniakea.Plugin[database.Context] {
	p := laniakea.NewPlugin[database.Context]("Waifus")

	p.NewCommand(myWaifu, "mywaifu").SetDescription("Список твоих вайфу")
	p.NewCommand(myWaifu, "моивайфу")
	p.NewCommand(waifuList, "wlist").SetDescription("Список всех вайфу")
	p.NewCommand(waifuList, "waifulist").SkipCommandAutoGen()
	p.NewCommand(waifuList, "влист")
	p.NewCommand(waifuList, "вайфулист")

	p.NewPayload(myWaifu, "waifu.my")
	p.NewPayload(waifuList, "waifu.list")
	p.NewPayload(waifuSell, "waifu.sell")
	p.NewPayload(buyWaifu, "waifu.buy")
	p.NewPayload(waifuInfo, "waifu.info")
	p.NewPayload(waifuSearch, "waifu.search")

	p.NewPayload(waifuNotImplemented, "waifu.confirm_buy")
	p.NewPayload(waifuNotImplemented, "waifu.confirm_sell")

	return p
}

func myWaifu(ctx *laniakea.MsgContext, db *database.Context) {
	userRep := psql.NewUserRepository(db)
	user, err := userRep.GetOrCreate(ctx.FromID, ctx.From.FirstName)
	if err != nil {
		ctx.Error(err)
		return
	}

	rep := psql.NewWaifuRepository(db)
	waifus, err := rep.GetByUserId(user.ID)
	if err != nil {
		ctx.Error(err)
		return
	}

	kb := laniakea.NewInlineKeyboard(2)
	out := []string{
		fmt.Sprintf("%s, %s!", user.Greeting, user.Name),
		"Список твоих вайфу:",
	}
	for _, w := range waifus {
		s := fmt.Sprintf("*%s* из \"*%s*\" \\(%d☆, ID: %d\\)", w.Name, w.Fandom, w.Rarity, w.ID)
		out = append(out, s)
		kb.AddCallbackButton(w.Name, "waifu.info", w.ID)
	}

	kb.AddLine()
	kb.AddCallbackButton("Искать", "waifu.search")
	kb.AddLine()
	kb.AddCallbackButton("Все вайфу", "waifu.list")
	if ctx.CallbackMsgId > 0 {
		ctx.EditCallbackMarkdown(strings.Join(out, "\n"), kb)
	} else {
		ctx.KeyboardMarkdown(strings.Join(out, "\n"), kb)
	}
}

func waifuList(ctx *laniakea.MsgContext, db *database.Context) {
	rep := psql.NewWaifuRepository(db)
	waifus, err := rep.GetAll()
	if err != nil {
		ctx.Error(err)
		return
	}
	out := make([]string, len(waifus))

	kb := laniakea.NewInlineKeyboard(2)
	for i, w := range waifus {
		var owner string
		if w.Owner == nil {
			owner = "нет"
		} else {
			owner = w.Owner.Name
		}
		out[i] = fmt.Sprintf("*%s* из \"*%s*\" \\(%d☆, ID: %d\\) Владелец: *%s*", w.Name, w.Fandom, w.Rarity, w.ID, owner)
		kb.AddCallbackButton(w.Name, "waifu.info", w.ID)
	}
	kb.AddLine()
	kb.AddCallbackButton("Мои вайфу", "waifu.my")

	if ctx.CallbackMsgId > 0 {
		if len(ctx.Msg.Photo) > 0 {
			ctx.CallbackDelete()
			ctx.KeyboardMarkdown(strings.Join(out, "\n"), kb)
		} else {
			ctx.EditCallbackMarkdown(strings.Join(out, "\n"), kb)
		}
	} else {
		ctx.KeyboardMarkdown(strings.Join(out, "\n"), kb)
	}
}

func waifuSell(ctx *laniakea.MsgContext, db *database.Context) {
	const CantSellWaifu = "Не удалось продать вайфу"

	waifuId, err := strconv.Atoi(ctx.Args[0])
	if err != nil {
		ctx.Error(err)
		return
	}

	rep := psql.NewWaifuRepository(db)
	waifu, err := rep.GetById(waifuId)
	if err != nil {
		ctx.Error(err)
		return
	}

	// Убедились что ид владельца совпадает с отправителем
	if waifu.Owner == nil {
		ctx.Answer(CantSellWaifu)
		return
	}
	if waifu.Owner.ID != ctx.FromID {
		ctx.Answer(CantSellWaifu)
		return
	}

	out := []string{
		fmt.Sprintf("Ты собираешься продать %s на рынок.", waifu.Name),
		"Это действие нельзя будет отменить!",
		fmt.Sprintf("Цена продажи составляет %s", utils.DecimalComma(&waifu.MarketPrice)),
	}

	kb := laniakea.NewInlineKeyboard(1)
	kb.AddCallbackButton("Продать", "waifu.confirm_sell", waifu.ID)
	kb.AddCallbackButton("Отмена", "waifu.info", waifu.ID)
	ctx.CallbackDelete()
	ctx.Keyboard(strings.Join(out, "\n"), kb)
}

func buyWaifu(ctx *laniakea.MsgContext, db *database.Context) {

}

func waifuInfo(ctx *laniakea.MsgContext, db *database.Context) {
	if len(ctx.Args) != 1 {
		ctx.Answer("Не указан ID вайфу!")
		return
	}

	waifuId, err := strconv.Atoi(ctx.Args[0])
	if err != nil {
		ctx.Error(err)
		return
	}

	rep := psql.NewWaifuRepository(db)
	waifu, err := rep.GetById(waifuId)
	if err != nil {
		ctx.Error(err)
		return
	}

	out := []string{
		fmt.Sprintf("*%s* из \"*%s*\"", waifu.Name, waifu.Fandom),
		fmt.Sprintf("Редкость: %d☆", waifu.Rarity),
		laniakea.EscapePunctuation(fmt.Sprintf("Бонус к деньгам: x%.2f", waifu.MoneyBonus.InexactFloat64())),
		laniakea.EscapePunctuation(fmt.Sprintf("Бонус к опыту: x%.2f", waifu.ExpBonus.InexactFloat64())),
		fmt.Sprintf("Рыночная стоимость: %s¥", utils.DecimalComma(&waifu.MarketPrice)),
	}
	kb := laniakea.NewInlineKeyboard(2)
	if !waifu.OwnerID.Valid {
		kb.AddCallbackButton("Купить", "waifu.buy", waifu.ID)
	}
	if waifu.OwnerID.Valid && waifu.OwnerID.Int64 == int64(ctx.FromID) {
		kb.AddCallbackButton("Продать", "waifu.sell", waifu.ID)
	}

	kb.AddLine()
	kb.AddCallbackButton("Все вайфу", "waifu.list")
	kb.AddCallbackButton("Мои вайфу", "waifu.my")
	if len(waifu.Image) > 0 {
		ctx.CallbackDelete()
		if waifu.Name != "" {
			ctx.AnswerPhotoKeyboardMarkdown(waifu.Image, strings.Join(out, "\n"), kb)
		} else {
			ctx.KeyboardMarkdown(strings.Join(out, "\n"), kb)
		}
	} else {
		ctx.EditCallbackMarkdown(strings.Join(out, "\n"), kb)
	}
	ctx.AnswerCbQuery()
}

func waifuSearch(ctx *laniakea.MsgContext, db *database.Context) {
	userRep := psql.NewUserRepository(db)
	user, err := userRep.GetOrCreate(ctx.FromID, ctx.Msg.From.FirstName)
	if err != nil {
		ctx.Error(err)
		return
	}

	kb := laniakea.NewInlineKeyboard(2).AddCallbackButton("Мои вайфу", "waifu.my").AddCallbackButton("Все вайфу", "waifu.list")
	if time.Now().Before(user.WaifuSearchTime.Add(time.Hour * 4)) {
		ctx.EditCallback("Вайфу можно искать раз в 4 часа", kb)
		return
	}

	rep := psql.NewWaifuRepository(db)
	count, err := rep.GetFreeCount()
	if err != nil {
		ctx.Error(err)
		return
	}
	if count == 0 {
		ctx.EditCallbackMarkdown("Не осталось свободных вайфу… :\\(\nПопробуй позже или купи на рынке\\!", kb)
		return
	}

	rand := utils.RandRange(0, 100)
	if 10 < rand && rand < 90 {
		ctx.EditCallback("Ты ничего не нашёл\\!", kb)
		return
	}

	var freeWaifus extypes.Slice[psql.Waifu]
	rarity := 3
	if rand == 0 {
		rarity = 5
	} else if rand > 0 && rand < 7 {
		rarity = 4
	}

	freeWaifus, err = rep.GetFreeByRarity(rarity)
	if err != nil {
		ctx.Error(err)
		return
	}

	if len(freeWaifus) == 0 {
		ctx.EditCallback("Ты ничего не нашёл\\!", kb)
		return
	}

	foundWaifuIndex := utils.RandRange(0, len(freeWaifus))
	waifu := freeWaifus[foundWaifuIndex]
	out := []string{
		"Ты нашел новую вайфу!",
		fmt.Sprintf("*%s* из \"*%s*\"", waifu.Name, waifu.Fandom),
		fmt.Sprintf("Редкость: %d☆", waifu.Rarity),
		fmt.Sprintf("Бонус к деньгам: x%.2f", waifu.MoneyBonus.InexactFloat64()),
		fmt.Sprintf("Бонус к опыту: x%.2f", waifu.ExpBonus.InexactFloat64()),
		fmt.Sprintf("Рыночная стоимость: %s¥", utils.DecimalComma(&waifu.MarketPrice)),
	}
	if len(waifu.Image) > 0 {
		ctx.AnswerPhotoMarkdown(waifu.Image, strings.Join(out, "\n"))
	} else {
		ctx.EditCallbackMarkdown(strings.Join(out, "\n"), kb)
	}
}

func waifuNotImplemented(ctx *laniakea.MsgContext, _ *database.Context) {
	kb := laniakea.NewInlineKeyboard(2).AddCallbackButton("Мои вайфу", "waifu.my").AddCallbackButton("Все вайфу", "waifu.list")
	ctx.EditCallback("Данная функция ещё не реализована", kb)
}