package main

import (
	"math"
	"sync"
	"time"

	"github.com/bwmarrin/discordgo"
)

const notInGeneralNerf = 10

var lastMessage = make(map[string]time.Time)
var incrementMutex = sync.Mutex{}
var levelUpRequirementCache [30]int

func init() {
	for i := 1; i <= 30; i++ {
		//Constructed on Desmos:
		//y=2^{\frac{x}{2}}+.1x^{2}+1.2x-1
		fi := float64(i)
		levelUpRequirementCache[i-1] = int(10000 * (math.Pow(2, fi/2) + 0.1*fi*fi + 1.2*fi - 1))
	}
}

func incrementXP(dg *discordgo.Session, discordID string, inGeneral bool) {
	amountToIncrement := calculateIncrement(discordID)
	if !inGeneral {
		amountToIncrement /= notInGeneralNerf
	}
	amountToIncrement *= getPrestige(dg, discordID)

	tx, err := db.Begin()
	if err != nil {
		logError(dg, "incrementXP", "begin", discordID, err)
		return
	}
	_, err = tx.Exec("INSERT INTO xp(id, xp) VALUES(?, ?) ON CONFLICT(id) DO UPDATE SET xp = xp+?;", discordID, amountToIncrement, amountToIncrement)
	if err != nil {
		logError(dg, "incrementXP", "insert", discordID, err)
		tx.Rollback()
		return
	}
	err = tx.Commit()
	if err != nil {
		logError(dg, "incrementXP", "commit", discordID, err)
		return
	}
	addToLevelQueue(discordID)
}

func getXP(dg *discordgo.Session, discordID string) int {
	rows, err := db.Query("SELECT xp FROM xp WHERE id=?", discordID)
	if err != nil {
		logError(dg, "getLevelAndXP", "select", discordID, err)
		return 0
	}
	defer rows.Close()
	if rows.Next() {
		var xp int
		rows.Scan(&xp)
		return xp
	}
	return 0
}

func getLevelAndXP(dg *discordgo.Session, discordID string) (int, int) {
	return convertXPIntoLevel(getXP(dg, discordID))
}

func calculateIncrement(discordID string) int {
	incrementMutex.Lock()
	defer incrementMutex.Unlock()

	now := time.Now()
	delta := now.Sub(lastMessage[discordID])
	lastMessage[discordID] = now

	if delta.Seconds() < 0 {
		return 0
	}

	//Constructed on Desmos:
	//y=\frac{100}{\left(1+e^{-\left(x-5\right)}\right)}
	return int(100 / (1 + math.Pow(math.E, -(delta.Seconds()-5))))
}

func convertXPIntoLevel(xp int) (int, int) {
	if xp < levelUpRequirementCache[0] {
		return 1, xp
	}
	for i := 0; i < 30; i++ {
		if levelUpRequirementCache[i] > xp {
			return i + 1, xp - levelUpRequirementCache[i-1]
		}
	}
	return 30, xp - levelUpRequirementCache[29]
}